feat(indexer): search output overhaul + Qdrant Docker

src/indexer/commands/search.ts

@@ -1,9 +1,12 @@
+import { isAbsolute, relative } from "node:path";
 import { toToon } from "@app/json/lib/toon";
+import { isInteractive } from "@app/utils/cli";
 import { SafeJSON } from "@app/utils/json";
 import type { SearchResult } from "@app/utils/search/types";
 import { truncateText } from "@app/utils/string";
 import * as p from "@clack/prompts";
 import type { Command } from "commander";
+import pc from "picocolors";
 import { normalizeConfidence } from "../lib/confidence";
 import { formatChunkDisplayName } from "../lib/display-name";
 import { parseQueryWords } from "../lib/highlight";
@@ -56,7 +59,7 @@ export function registerSearchCommand(program: Command): void {
         .command("search")
         .description("Search across indexes")
         .argument("<query>", "Search query")
-        .option("-i, --index <name>", "Search specific index (default: all)")
+        .option("-i, --index <name>", "Index to search (auto-detect from cwd; 'all' for all)")
         .option("-m, --mode <mode>", "Search mode: fulltext, vector, hybrid (default: auto-detect)")
         .option("-l, --limit <n>", "Max results", parseInt, 20)
         .option("-f, --file <filter>", "Filter results to files matching this substring")
@@ -82,14 +85,67 @@ export function registerSearchCommand(program: Command): void {
                     return;
                 }
 
-                const names = opts.index ? [opts.index] : manager.getIndexNames();
+                let names: string[];
+
+                if (opts.index === "all") {
+                    names = manager.getIndexNames();
+                } else if (opts.index) {
+                    names = [opts.index];
+                } else {
+                    const allMeta = manager.listIndexes();
+
+                    if (allMeta.length === 0) {
+                        p.log.info("No indexes configured. Run: tools indexer add <path>");
+                        return;
+                    }
+
+                    if (allMeta.length === 1) {
+                        names = [allMeta[0].name];
+                    } else {
+                        const cwd = process.cwd();
+                        const cwdMatches = allMeta
+                            .filter((m) => {
+                                const rel = relative(m.config.baseDir, cwd);
+                                return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+                            })
+                            .sort((a, b) => b.config.baseDir.length - a.config.baseDir.length);
+
+                        const cwdMatch = cwdMatches[0];
+                        const isUniqueDeepest =
+                            cwdMatches.length < 2 ||
+                            cwdMatches[0].config.baseDir.length > cwdMatches[1].config.baseDir.length;
+
+                        if (cwdMatch && isUniqueDeepest) {
+                            names = [cwdMatch.name];
+                            p.log.info(pc.dim(`(using index "${cwdMatch.name}" from cwd)`));
+                        } else if (isInteractive()) {
+                            const allNames = allMeta.map((m) => m.name);
+                            const selected = await p.select({
+                                message: "Select index to search",
+                                options: [
+                                    { value: "__all__", label: "All indexes" },
+                                    ...allNames.map((n) => ({ value: n, label: n })),
+                                ],
+                            });
+
+                            if (p.isCancel(selected)) {
+                                p.log.info("Cancelled");
+                                return;
+                            }
+
+                            names = selected === "__all__" ? allNames : [selected];
+                        } else {
+                            p.log.error("Multiple indexes found. Use -i <name> or -i all.");
+                            return;
+                        }
+                    }
+                }
 
                 if (names.length === 0) {
                     p.log.info("No indexes configured. Run: tools indexer add <path>");
                     return;
                 }
 
-                // Load all indexers upfront for mode detection across all indexes
                 const indexers = await Promise.all(names.map((n) => manager.getIndex(n)));
 
                 let mode: SearchMode;
@@ -171,13 +227,22 @@ export function registerSearchCommand(program: Command): void {
                     return;
                 }
 
+                const baseDirs = new Map<string, string>();
+
+                for (const indexer of indexers) {
+                    const cfg = indexer.getConfig();
+                    baseDirs.set(cfg.name, cfg.baseDir);
+                }
+
                 const words = parseQueryWords(query);
                 const output = formatSearchResults({
                     results: filtered,
                     format: format as OutputFormat,
                     query,
                     mode: effectiveMode,
                     highlightWords: words,
+                    baseDirs,
+                    multiIndex: names.length > 1,
                 });
                 console.log(output);
             } finally {

src/indexer/lib/chunker.test.ts

@@ -1092,4 +1092,104 @@ import { c } from "./c";
             expect(result.chunks.length).toBe(1);
         });
     });
+
+    describe("Heading strategy — improved splitting", () => {
+        it("preserves heading context in sub-chunks of large sections", () => {
+            const bigBody = Array.from({ length: 200 }, (_, i) => `Line ${i} of content with enough words to consume tokens.`).join("\n\n");
+            const content = `## Big Section\n\n${bigBody}`;
+
+            const result = chunkFile({
+                filePath: "doc.md",
+                content,
+                strategy: "heading",
+                maxTokens: 100,
+            });
+
+            expect(result.parser).toBe("heading");
+            expect(result.chunks.length).toBeGreaterThan(1);
+
+            // Every sub-chunk after the first should contain the heading
+            for (const chunk of result.chunks.slice(1)) {
+                expect(chunk.content).toContain("## Big Section");
+            }
+        });
+
+        it("splits at paragraph boundaries, not mid-paragraph", () => {
+            const para1 = "First paragraph with several words that make it meaningful.";
+            const para2 = "Second paragraph also has content that should stay together.";
+            const para3 = "Third paragraph is the final one in this section.";
+            const content = `## Section\n\n${para1}\n\n${para2}\n\n${para3}`;
+
+            const result = chunkFile({
+                filePath: "doc.md",
+                content,
+                strategy: "heading",
+                maxTokens: 50,
+            });
+
+            expect(result.parser).toBe("heading");
+
+            for (const chunk of result.chunks) {
+                // No paragraph should be cut in the middle — each paragraph
+                // should appear fully in exactly one chunk
+                if (chunk.content.includes("First paragraph")) {
+                    expect(chunk.content).toContain(para1);
+                }
+
+                if (chunk.content.includes("Second paragraph")) {
+                    expect(chunk.content).toContain(para2);
+                }
+
+                if (chunk.content.includes("Third paragraph")) {
+                    expect(chunk.content).toContain(para3);
+                }
+            }
+        });
+
+        it("names preamble content before first heading", () => {
+            const content = `This is preamble text before any heading.\n\nMore preamble.\n\n## First Heading\n\nContent here.`;
+
+            const result = chunkFile({
+                filePath: "doc.md",
+                content,
+                strategy: "heading",
+            });
+
+            expect(result.parser).toBe("heading");
+
+            const preambleChunk = result.chunks[0];
+            expect(preambleChunk.name).toBeDefined();
+            expect(preambleChunk.name).not.toBe("chunk");
+            expect(preambleChunk.content).toContain("preamble text");
+        });
+
+        it("keeps small sections as single chunks", () => {
+            const content = `## Small Section\n\nJust a few words here.`;
+
+            const result = chunkFile({
+                filePath: "doc.md",
+                content,
+                strategy: "heading",
+            });
+
+            expect(result.parser).toBe("heading");
+            expect(result.chunks.length).toBe(1);
+            expect(result.chunks[0].name).toBe("Small Section");
+            expect(result.chunks[0].name).not.toContain("(part");
+        });
+
+        it("handles markdown with no headings at all", () => {
+            const content = `Just plain text.\n\nWith some paragraphs.\n\nAnd nothing else.`;
+
+            const result = chunkFile({
+                filePath: "doc.md",
+                content,
+                strategy: "heading",
+            });
+
+            expect(result.parser).toBe("heading");
+            expect(result.chunks.length).toBeGreaterThanOrEqual(1);
+            expect(result.chunks[0].name).toBeDefined();
+        });
+    });
 });

src/indexer/lib/chunker.ts

@@ -608,14 +608,117 @@ function chunkByLine(opts: { filePath: string; content: string; maxTokens: numbe
     return { chunks, language, parser: "line" };
 }
 
+// ─── Paragraph-aware splitting for markdown ─────────────────────
+function splitByParagraphs(opts: {
+    content: string;
+    filePath: string;
+    startLine: number;
+    kind: string;
+    name?: string;
+    maxTokens: number;
+    headingLine?: string;
+}): ChunkRecord[] {
+    const { content, filePath, startLine, kind, name, maxTokens, headingLine } = opts;
+    const paragraphs = content.split(/\n\n+/);
+
+    if (paragraphs.length <= 1) {
+        return splitChunkByLines({
+            content,
+            filePath,
+            startLine,
+            kind,
+            name,
+            language: "markdown",
+            maxTokens,
+        });
+    }
+
+    const chunks: ChunkRecord[] = [];
+    let accumulated: string[] = [];
+    let accStartLine = startLine;
+
+    function flush(): void {
+        if (accumulated.length === 0) {
+            return;
+        }
+
+        const sourceContent = accumulated.join("\n\n");
+
+        if (sourceContent.trim().length === 0) {
+            return;
+        }
+
+        let chunkContent = sourceContent;
+
+        // Prepend heading to sub-chunks after the first for context
+        if (chunks.length > 0 && headingLine) {
+            chunkContent = `${headingLine}\n\n${sourceContent}`;
+        }
+
+        const sourceLineCount = sourceContent.split("\n").length;
+        const partLabel = chunks.length > 0 ? ` (part ${chunks.length + 1})` : "";
+
+        chunks.push({
+            id: xxhash(chunkContent),
+            filePath,
+            startLine: accStartLine,
+            endLine: accStartLine + sourceLineCount - 1,
+            content: chunkContent,
+            kind,
+            name: name ? `${name}${partLabel}` : undefined,
+            language: "markdown",
+        });
+
+        accumulated = [];
+    }
+
+    let lineOffset = startLine;
+
+    for (const para of paragraphs) {
+        // If a single paragraph exceeds maxTokens, fall back to line splitting
+        if (accumulated.length === 0 && estimateTokens(para) > maxTokens) {
+            const paraChunks = splitChunkByLines({
+                content: headingLine ? `${headingLine}\n\n${para}` : para,
+                filePath,
+                startLine: lineOffset,
+                kind,
+                name,
+                language: "markdown",
+                maxTokens,
+            });
+            chunks.push(...paraChunks);
+            lineOffset += para.split("\n").length + 1;
+            accStartLine = lineOffset;
+            continue;
+        }
+
+        const candidate = [...accumulated, para].join("\n\n");
+        const withHeading = chunks.length > 0 && headingLine ? `${headingLine}\n\n${candidate}` : candidate;
+
+        if (estimateTokens(withHeading) > maxTokens && accumulated.length > 0) {
+            flush();
+            accStartLine = lineOffset;
+        }
+
+        accumulated.push(para);
+        lineOffset += para.split("\n").length + 1;
+    }
+
+    flush();
+
+    return chunks;
+}
+
 // ─── Heading strategy (markdown) ────────────────────────────────
 function chunkByHeading(opts: { filePath: string; content: string; maxTokens: number }): ChunkResult {
     const { filePath, content, maxTokens } = opts;
     const lines = content.split("\n");
     const chunks: ChunkRecord[] = [];
     let currentLines: string[] = [];
     let currentName: string | undefined;
+    let currentHeadingLine: string | undefined;
     let currentStartLine = 0;
+    let seenHeading = false;
 
     function flushSection(): void {
         if (currentLines.length === 0) {
@@ -628,14 +731,28 @@ function chunkByHeading(opts: { filePath: string; content: string; maxTokens: nu
             return;
         }
 
-        const subChunks = splitChunkByLines({
+        if (estimateTokens(sectionContent) <= maxTokens) {
+            chunks.push({
+                id: xxhash(sectionContent),
+                filePath,
+                startLine: currentStartLine,
+                endLine: currentStartLine + currentLines.length - 1,
+                content: sectionContent,
+                kind: "heading",
+                name: currentName,
+                language: "markdown",
+            });
+            return;
+        }
+
+        const subChunks = splitByParagraphs({
             content: sectionContent,
             filePath,
             startLine: currentStartLine,
             kind: "heading",
             name: currentName,
-            language: "markdown",
             maxTokens,
+            headingLine: currentHeadingLine,
         });
 
         chunks.push(...subChunks);
@@ -649,8 +766,15 @@ function chunkByHeading(opts: { filePath: string; content: string; maxTokens: nu
             flushSection();
             currentLines = [line];
             currentName = headingMatch[2].trim();
+            currentHeadingLine = line;
             currentStartLine = i;
+            seenHeading = true;
         } else {
+            // Name preamble content (before first heading)
+            if (!seenHeading && !currentName && line.trim().length > 0) {
+                currentName = line.trim().length > 50 ? `${line.trim().slice(0, 50)}...` : line.trim();
+            }
+
             currentLines.push(line);
         }
     }