grepmax 0.17.21 → 0.17.23

package/dist/lib/graph/impact.js

@@ -14,6 +14,7 @@ exports.resolveTargetSymbols = resolveTargetSymbols;
 exports.findTests = findTests;
 exports.findDependents = findDependents;
 const filter_builder_1 = require("../utils/filter-builder");
+const query_timeout_1 = require("../utils/query-timeout");
 const graph_builder_1 = require("./graph-builder");
 const TEST_DIR_RE = /(^|\/)(__tests__|tests?|specs?|benchmark)(\/|$)/i;
 const TEST_FILE_RE = /\.(test|spec)\.[cm]?[jt]sx?$/i;
@@ -90,7 +91,11 @@ function expandFileSymbols(symbols, vectorDb, projectRoot, excludePrefixes) {
                 expanded.add(s);
             }
         }
-        return [...expanded];
+        // Cap the fan-out: a large class file can define 50+ symbols, and every
+        // expanded symbol costs one caller-scan (and more in the fallback). The
+        // original target stays first; co-defined symbols are best-effort extras.
+        const MAX_EXPANDED = 15;
+        return [...expanded].slice(0, MAX_EXPANDED);
     });
 }
 /**
@@ -111,7 +116,7 @@ function findTests(symbols_1, vectorDb_1, projectRoot_1) {
             yield walkCallers(symbol, graphBuilder, testHits, 0, depth, new Set());
         }
         if (testHits.size === 0) {
-            const importFiles = yield findImportFallbackTests(expanded, vectorDb, projectRoot, excludePrefixes);
+            const importFiles = yield findImportFallbackTests(expanded, symbols, vectorDb, projectRoot, excludePrefixes);
             for (const file of importFiles) {
                 testHits.set(`${file}:(referenced)`, {
                     file,
@@ -124,12 +129,13 @@ function findTests(symbols_1, vectorDb_1, projectRoot_1) {
         return [...testHits.values()].sort((a, b) => a.hops - b.hops || a.file.localeCompare(b.file));
     });
 }
-function findImportFallbackTests(symbols, vectorDb, projectRoot, excludePrefixes) {
+function findImportFallbackTests(expandedSymbols, originalSymbols, vectorDb, projectRoot, excludePrefixes) {
     return __awaiter(this, void 0, void 0, function* () {
         const files = new Set();
         // Signal 1: referenced_symbols match (precise; works when the chunker
-        // captured call references in test bodies).
-        const dependents = yield findDependents(symbols, vectorDb, projectRoot, undefined, 50, excludePrefixes);
+        // captured call references in test bodies). Uses the expanded set so tests
+        // that call a method of the target class still match.
+        const dependents = yield findDependents(expandedSymbols, vectorDb, projectRoot, undefined, 50, excludePrefixes);
         for (const d of dependents) {
             if (isTestPath(d.file))
                 files.add(d.file);
@@ -143,14 +149,18 @@ function findImportFallbackTests(symbols, vectorDb, projectRoot, excludePrefixes
             const exNorm = ex.endsWith("/") ? ex : `${ex}/`;
             pathScope += ` AND path NOT LIKE '${(0, filter_builder_1.escapeSqlString)(exNorm)}%'`;
         }
-        for (const sym of symbols) {
-            const rows = yield table
+        // Textual matching runs on the ORIGINAL targets only: matching co-defined
+        // file symbols (helpers like `log`) textually drags in every test file
+        // that mentions them, drowning the answer in false positives.
+        for (const sym of originalSymbols) {
+            // No .limit() here: LIKE + limit deadlocks in @lancedb 0.27.x when more
+            // rows match than the limit (verified). Unlimited scan is fast; cap in JS.
+            const rows = yield (0, query_timeout_1.withQueryTimeout)(table
                 .query()
                 .select(["path"])
                 .where(`content LIKE '%${(0, filter_builder_1.escapeSqlString)(sym)}%' AND ${pathScope}`)
-                .limit(100)
-                .toArray();
-            for (const row of rows) {
+                .toArray(), `content LIKE %${sym}% (test fallback)`);
+            for (const row of rows.slice(0, 500)) {
                 const p = String(row.path || "");
                 if (isTestPath(p))
                     files.add(p);
@@ -198,11 +208,14 @@ function findDependents(symbols_1, vectorDb_1, projectRoot_1, excludePaths_1) {
         }
         const counts = new Map();
         for (const sym of symbols) {
+            // 200, not 20: with per-chunk rows a popular symbol easily exceeds 20
+            // chunks, and truncation here silently drops whole dependent files.
+            // (array_contains + limit does not hit the LIKE+limit native hang.)
             const rows = yield table
                 .query()
                 .select(["path"])
                 .where(`array_contains(referenced_symbols, '${(0, filter_builder_1.escapeSqlString)(sym)}') AND ${pathScope}`)
-                .limit(20)
+                .limit(200)
                 .toArray();
             for (const row of rows) {
                 const p = String(row.path || "");

package/dist/lib/graph/test-hits.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupTestHitsByFile = groupTestHitsByFile;
+exports.formatViaAgent = formatViaAgent;
+exports.formatViaHuman = formatViaHuman;
+exports.hopLabelAgent = hopLabelAgent;
+exports.hopLabelHuman = hopLabelHuman;
+function groupTestHitsByFile(hits) {
+    const byFile = new Map();
+    // Sort by hops so the first hit per file carries the best line/hops and
+    // `via` lists closest callers first ((referenced) fallback hits sort last).
+    const ordered = [...hits].sort((a, b) => (a.hops === -1 ? Number.MAX_SAFE_INTEGER : a.hops) -
+        (b.hops === -1 ? Number.MAX_SAFE_INTEGER : b.hops));
+    for (const h of ordered) {
+        let g = byFile.get(h.file);
+        if (!g) {
+            g = { file: h.file, line: h.line, hops: h.hops, via: [] };
+            byFile.set(h.file, g);
+        }
+        if (h.symbol && h.symbol !== "(referenced)" && !g.via.includes(h.symbol)) {
+            g.via.push(h.symbol);
+        }
+    }
+    return [...byFile.values()].sort((a, b) => (a.hops === -1 ? Number.MAX_SAFE_INTEGER : a.hops) -
+        (b.hops === -1 ? Number.MAX_SAFE_INTEGER : b.hops) ||
+        a.file.localeCompare(b.file));
+}
+const MAX_VIA = 3;
+/** `via=helperA,helperB(+2)` agent detail, or "" when there is none. */
+function formatViaAgent(via) {
+    if (via.length === 0)
+        return "";
+    const shown = via.slice(0, MAX_VIA).join(",");
+    const more = via.length > MAX_VIA ? `(+${via.length - MAX_VIA})` : "";
+    return `\tvia=${shown}${more}`;
+}
+/** `, via helperA, helperB (+2 more)` human detail, or "" when none. */
+function formatViaHuman(via) {
+    if (via.length === 0)
+        return "";
+    const shown = via.slice(0, MAX_VIA).join(", ");
+    const more = via.length > MAX_VIA ? ` (+${via.length - MAX_VIA} more)` : "";
+    return `, via ${shown}${more}`;
+}
+function hopLabelAgent(hops) {
+    return hops === -1 ? "via-import" : hops === 0 ? "direct" : `${hops}-hop`;
+}
+function hopLabelHuman(hops) {
+    return hops === -1
+        ? "via import"
+        : hops === 0
+            ? "calls directly"
+            : `${hops} hop${hops > 1 ? "s" : ""} away`;
+}

package/dist/lib/help/agent-cheatsheet.js

@@ -37,6 +37,11 @@ Survey:
 
 Scope flags: --root <name|path>, --in <subpath>, --exclude <subpath>.
 Roles in results: [DEFI] [ORCH] [IMPL] [DOCS].
+Notation: s=/d= score/distance (higher s / lower d = better) · C:n complexity ·
+  <- caller / -> callee · dep:/rev: outbound/inbound file deps (count = shared symbols) ·
+  test hops: direct = calls it, N-hop = N calls away, via-import = imports but call unseen ·
+  test via=X,Y: caller symbols inside the test file (often helpers, not the tests) ·
+  (not indexed) = external/builtin, no definition in the index.
 Recovery: "not added yet" → gmax add; stale → gmax index; broken → gmax doctor --fix.`;
 /** Full SessionStart context = prefix + cheatsheet. */
 exports.SESSION_START_HINT = `${exports.SESSION_START_PREFIX}\n\n${exports.AGENT_CHEATSHEET}`;

package/dist/lib/index/chunker.js

@@ -811,6 +811,40 @@ class TreeSitterChunker {
             return { chunks: combined, metadata };
         });
     }
+    /**
+     * Restrict a sub-chunk's symbol lists to names that actually occur in its
+     * content slice. `{...chunk}` would otherwise copy the parent's full
+     * definedSymbols/referencedSymbols into every sub-chunk, fabricating graph
+     * edges: each sub-chunk of a large class "defines" the class and
+     * "references" everything the class references, so caller/dependent queries
+     * return one phantom hit per sub-chunk (verified: 3 real call sites → 66).
+     */
+    static scopeSymbolsToContent(sub) {
+        const occurs = (s) => {
+            if (!s)
+                return false;
+            if (/^\w+$/.test(s)) {
+                return new RegExp(`\\b${s}\\b`).test(sub.content);
+            }
+            // Names with non-word chars ($foo, a.b) — substring match is the best
+            // we can do without a parser; over-keeping is safer than dropping edges.
+            return sub.content.includes(s);
+        };
+        if (sub.definedSymbols) {
+            const original = sub.definedSymbols;
+            sub.definedSymbols = original.filter(occurs);
+            // A mid-body slice defines nothing itself — keep the enclosing
+            // definition's name as parentSymbol so graph consumers can attribute
+            // the chunk ("Daemon" beats "unknown").
+            if (sub.definedSymbols.length === 0 && !sub.parentSymbol && original[0]) {
+                sub.parentSymbol = original[0];
+            }
+        }
+        if (sub.referencedSymbols) {
+            sub.referencedSymbols = sub.referencedSymbols.filter(occurs);
+        }
+        return sub;
+    }
     splitIfTooBig(chunk) {
         const charCount = chunk.content.length;
         const lines = chunk.content.split("\n");
@@ -830,7 +864,7 @@ class TreeSitterChunker {
             const subLines = lines.slice(i, end);
             if (subLines.length < 3 && i > 0)
                 continue;
-            subChunks.push(Object.assign(Object.assign({}, chunk), { content: subLines.join("\n"), startLine: chunk.startLine + i, endLine: chunk.startLine + end - 1 }));
+            subChunks.push(TreeSitterChunker.scopeSymbolsToContent(Object.assign(Object.assign({}, chunk), { content: subLines.join("\n"), startLine: chunk.startLine + i, endLine: chunk.startLine + end - 1 })));
         }
         return subChunks.flatMap((sc) => sc.content.length > this.MAX_CHUNK_CHARS ? this.splitByChars(sc) : [sc]);
     }
@@ -844,7 +878,7 @@ class TreeSitterChunker {
                 continue;
             const prefixLines = chunk.content.slice(0, i).split("\n").length - 1;
             const subLineCount = sub.split("\n").length;
-            res.push(Object.assign(Object.assign({}, chunk), { content: sub, startLine: chunk.startLine + prefixLines, endLine: chunk.startLine + prefixLines + subLineCount - 1 }));
+            res.push(TreeSitterChunker.scopeSymbolsToContent(Object.assign(Object.assign({}, chunk), { content: sub, startLine: chunk.startLine + prefixLines, endLine: chunk.startLine + prefixLines + subLineCount - 1 })));
         }
         return res;
     }

package/dist/lib/output/agent-search-formatter.js

@@ -101,11 +101,66 @@ function firstSignatureLine(chunk) {
     }
     return "";
 }
-function hintFor(chunk) {
+const QUERY_STOPWORDS = new Set([
+    "the", "and", "for", "with", "that", "this", "from", "into", "where",
+    "when", "how", "what", "does", "not", "are", "was", "has", "have", "its",
+    "all", "can", "use", "uses", "using", "code",
+]);
+function extractQueryTerms(query) {
+    if (!query)
+        return [];
+    const terms = query
+        .toLowerCase()
+        .split(/[^a-z0-9_]+/)
+        .filter((t) => t.length >= 3 && !QUERY_STOPWORDS.has(t));
+    return [...new Set(terms)];
+}
+function truncateHint(line) {
+    return line.length > 120 ? `${line.slice(0, 117)}...` : line;
+}
+/**
+ * The chunk line that best matches the query terms — it shows *why* this
+ * chunk hit, where the first signature line only shows what the chunk is.
+ * Most distinct terms wins; code beats comments on a tie; earliest otherwise.
+ */
+function queryMatchingLine(chunk, terms) {
+    var _a, _b;
+    if (!terms.length)
+        return "";
+    const raw = String((_b = (_a = chunk.content) !== null && _a !== void 0 ? _a : chunk.text) !== null && _b !== void 0 ? _b : "");
+    let best = "";
+    let bestScore = 0;
+    let bestIsComment = true;
+    for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.length < 5)
+            continue;
+        if (trimmed.startsWith("import ") || trimmed.startsWith("File:"))
+            continue;
+        if (trimmed === "{" || trimmed === "}")
+            continue;
+        const lower = trimmed.toLowerCase();
+        let score = 0;
+        for (const t of terms)
+            if (lower.includes(t))
+                score++;
+        if (score === 0)
+            continue;
+        const isComment = /^(\/\/|\/\*|\*|#)/.test(trimmed);
+        if (score > bestScore ||
+            (score === bestScore && bestIsComment && !isComment)) {
+            best = trimmed;
+            bestScore = score;
+            bestIsComment = isComment;
+        }
+    }
+    return truncateHint(best);
+}
+function hintFor(chunk, queryTerms) {
     if (typeof chunk.summary === "string" && chunk.summary) {
         return chunk.summary;
     }
-    return firstSignatureLine(chunk);
+    return queryMatchingLine(chunk, queryTerms) || firstSignatureLine(chunk);
 }
 function explainSuffix(chunk, enabled) {
     if (!enabled || !chunk.scoreBreakdown)
@@ -117,6 +172,7 @@ function formatAgentSearchResults(results, projectRoot, options = {}) {
     var _a, _b;
     if (!results.length)
         return "(none)";
+    const queryTerms = extractQueryTerms(options.query);
     const groups = new Map();
     for (const result of results) {
         const absPath = chunkPath(result);
@@ -152,7 +208,7 @@ function formatAgentSearchResults(results, projectRoot, options = {}) {
             const score = typeof result.score === "number"
                 ? `\ts=${result.score.toFixed(3)}`
                 : "";
-            const hint = hintFor(result);
+            const hint = hintFor(result, queryTerms);
             const locator = grouped
                 ? `  :${chunkStartLine(result)}`
                 : `${rel}:${chunkStartLine(result)}`;

package/dist/lib/output/compact-results.js

@@ -0,0 +1,244 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toTextResults = toTextResults;
+exports.toCompactHits = toCompactHits;
+exports.formatCompactTable = formatCompactTable;
+exports.resultCountHeader = resultCountHeader;
+const path = __importStar(require("node:path"));
+function toTextResults(data) {
+    return data.map((r) => {
+        var _a, _b, _c, _d, _e, _f;
+        const rawPath = typeof ((_a = r.metadata) === null || _a === void 0 ? void 0 : _a.path) === "string"
+            ? r.metadata.path
+            : "Unknown path";
+        const start = typeof ((_b = r.generated_metadata) === null || _b === void 0 ? void 0 : _b.start_line) === "number"
+            ? r.generated_metadata.start_line
+            : 0;
+        const end = typeof ((_c = r.generated_metadata) === null || _c === void 0 ? void 0 : _c.end_line) === "number"
+            ? r.generated_metadata.end_line
+            : start + Math.max(0, ((_e = (_d = r.generated_metadata) === null || _d === void 0 ? void 0 : _d.num_lines) !== null && _e !== void 0 ? _e : 1) - 1);
+        return {
+            path: rawPath,
+            score: r.score,
+            content: r.text || "",
+            chunk_type: (_f = r.generated_metadata) === null || _f === void 0 ? void 0 : _f.type,
+            start_line: start,
+            end_line: end,
+        };
+    });
+}
+function getPreviewText(chunk) {
+    var _a, _b, _c, _d, _e;
+    const maxLen = 140;
+    const lines = (_b = (_a = chunk.text) === null || _a === void 0 ? void 0 : _a.split("\n").map((l) => l.trim()).filter(Boolean)) !== null && _b !== void 0 ? _b : [];
+    let preview = (_c = lines[0]) !== null && _c !== void 0 ? _c : "";
+    if (!preview && ((_d = chunk.defined_symbols) === null || _d === void 0 ? void 0 : _d.length)) {
+        preview = (_e = chunk.defined_symbols[0]) !== null && _e !== void 0 ? _e : "";
+    }
+    if (preview.length > maxLen) {
+        preview = `${preview.slice(0, maxLen)}...`;
+    }
+    return preview;
+}
+function toCompactHits(data) {
+    return data.map((chunk) => {
+        var _a, _b, _c, _d, _e, _f;
+        const rawPath = typeof ((_a = chunk.metadata) === null || _a === void 0 ? void 0 : _a.path) === "string"
+            ? chunk.metadata.path
+            : "Unknown path";
+        const start = typeof ((_b = chunk.generated_metadata) === null || _b === void 0 ? void 0 : _b.start_line) === "number"
+            ? chunk.generated_metadata.start_line
+            : 0;
+        const end = typeof ((_c = chunk.generated_metadata) === null || _c === void 0 ? void 0 : _c.end_line) === "number"
+            ? chunk.generated_metadata.end_line
+            : start + Math.max(0, ((_e = (_d = chunk.generated_metadata) === null || _d === void 0 ? void 0 : _d.num_lines) !== null && _e !== void 0 ? _e : 1) - 1);
+        return {
+            path: rawPath,
+            range: `${start + 1}-${end + 1}`,
+            start_line: start,
+            end_line: end,
+            role: chunk.role,
+            confidence: chunk.confidence,
+            score: chunk.score,
+            defined: Array.isArray(chunk.defined_symbols)
+                ? chunk.defined_symbols.slice(0, 3)
+                : typeof chunk.defined_symbols === "string"
+                    ? [chunk.defined_symbols]
+                    : typeof ((_f = chunk.defined_symbols) === null || _f === void 0 ? void 0 : _f.toArray) === "function"
+                        ? chunk.defined_symbols.toArray().slice(0, 3)
+                        : [],
+            preview: getPreviewText(chunk),
+            summary: typeof chunk.summary === "string" ? chunk.summary : undefined,
+        };
+    });
+}
+function compactRole(role) {
+    if (!role)
+        return "UNK";
+    if (role.startsWith("ORCH"))
+        return "ORCH";
+    if (role.startsWith("DEF"))
+        return "DEF";
+    if (role.startsWith("IMP"))
+        return "IMPL";
+    return role.slice(0, 4).toUpperCase();
+}
+function compactConf(conf) {
+    if (!conf)
+        return "U";
+    const c = conf.toUpperCase();
+    if (c.startsWith("H"))
+        return "H";
+    if (c.startsWith("M"))
+        return "M";
+    if (c.startsWith("L"))
+        return "L";
+    return "U";
+}
+function compactScore(score) {
+    if (typeof score !== "number")
+        return "";
+    const fixed = score.toFixed(3);
+    return fixed
+        .replace(/^0\./, ".")
+        .replace(/\.?0+$/, (m) => (m.startsWith(".") ? "" : m));
+}
+function truncateEnd(s, max) {
+    if (max <= 0)
+        return "";
+    if (s.length <= max)
+        return s;
+    if (max <= 3)
+        return s.slice(0, max);
+    return `${s.slice(0, max - 3)}...`;
+}
+function padR(s, w) {
+    const n = Math.max(0, w - s.length);
+    return s + " ".repeat(n);
+}
+function padL(s, w) {
+    const n = Math.max(0, w - s.length);
+    return " ".repeat(n) + s;
+}
+function formatCompactTSV(hits, projectRoot, query) {
+    var _a, _b;
+    if (!hits.length)
+        return "No matches found.";
+    const lines = [];
+    lines.push(`gmax hits\tquery=${query}\tcount=${hits.length}`);
+    lines.push("path\tlines\tscore\trole\tconf\tdefined\tsummary");
+    for (const hit of hits) {
+        const relPath = path.isAbsolute(hit.path)
+            ? path.relative(projectRoot, hit.path)
+            : hit.path;
+        const score = compactScore(hit.score);
+        const role = compactRole(hit.role);
+        const conf = compactConf(hit.confidence);
+        const defs = ((_a = hit.defined) !== null && _a !== void 0 ? _a : []).join(",");
+        const summary = (_b = hit.summary) !== null && _b !== void 0 ? _b : "";
+        lines.push([relPath, hit.range, score, role, conf, defs, summary].join("\t"));
+    }
+    return lines.join("\n");
+}
+function formatCompactPretty(hits, projectRoot, query, termWidth, useAnsi) {
+    var _a;
+    if (!hits.length)
+        return "No matches found.";
+    const dim = (s) => (useAnsi ? `\x1b[90m${s}\x1b[0m` : s);
+    const bold = (s) => (useAnsi ? `\x1b[1m${s}\x1b[0m` : s);
+    const wLines = 9;
+    const wScore = 6;
+    const wRole = 4;
+    const wConf = 1;
+    const wDef = 20;
+    const gutters = 5;
+    const fixed = wLines + wScore + wRole + wConf + wDef + gutters;
+    const wPath = Math.max(24, Math.min(64, termWidth - fixed));
+    const header = `gmax hits  count=${hits.length}  query="${query}"`;
+    const cols = [
+        padR("path", wPath),
+        padR("lines", wLines),
+        padL("score", wScore),
+        padR("role", wRole),
+        padR("c", wConf),
+        padR("defined", wDef),
+    ].join(" ");
+    const out = [];
+    out.push(bold(header));
+    out.push(dim(cols));
+    for (const hit of hits) {
+        const relPath = path.isAbsolute(hit.path)
+            ? path.relative(projectRoot, hit.path)
+            : hit.path;
+        const score = compactScore(hit.score);
+        const role = compactRole(hit.role);
+        const conf = compactConf(hit.confidence);
+        const defs = ((_a = hit.defined) !== null && _a !== void 0 ? _a : []).join(",") || "-";
+        const displayPath = `${relPath}:${hit.start_line + 1}`;
+        const paddedPath = padR(displayPath, wPath);
+        const row = [
+            paddedPath,
+            padR(hit.range, wLines),
+            padL(score || "", wScore),
+            padR(role, wRole),
+            padR(conf, wConf),
+            padR(truncateEnd(defs, wDef), wDef),
+        ].join(" ");
+        out.push(row);
+    }
+    return out.join("\n");
+}
+function formatCompactTable(hits, projectRoot, query, opts) {
+    var _a;
+    if (!hits.length)
+        return "No matches found.";
+    if (!opts.isTTY || opts.plain) {
+        return formatCompactTSV(hits, projectRoot, query);
+    }
+    const termWidth = Math.max(80, (_a = process.stdout.columns) !== null && _a !== void 0 ? _a : 120);
+    return formatCompactPretty(hits, projectRoot, query, termWidth, true);
+}
+function resultCountHeader(results, maxCount) {
+    var _a, _b, _c;
+    const files = new Set();
+    for (const r of results) {
+        const p = (_c = (_a = r.path) !== null && _a !== void 0 ? _a : (_b = r.metadata) === null || _b === void 0 ? void 0 : _b.path) !== null && _c !== void 0 ? _c : "";
+        if (p)
+            files.add(p);
+    }
+    const showing = results.length < maxCount ? `${results.length}` : `top ${results.length}`;
+    return `Found ${results.length} match${results.length === 1 ? "" : "es"} (showing ${showing}) across ${files.size} file${files.size === 1 ? "" : "s"}`;
+}

package/dist/lib/search/searcher.js

@@ -817,7 +817,7 @@ class Searcher {
                 const displayRows = yield table
                     .query()
                     .select([
-                    "id", "defined_symbols", "imports", "exports",
+                    "id", "defined_symbols", "parent_symbol", "imports", "exports",
                     "summary", "file_skeleton",
                 ])
                     .where(`id IN (${finalIds.join(",")})`)
@@ -828,6 +828,7 @@ class Searcher {
                     const extra = displayMap.get(item.record.id);
                     if (extra) {
                         item.record.defined_symbols = extra.defined_symbols;
+                        item.record.parent_symbol = extra.parent_symbol;
                         item.record.imports = extra.imports;
                         item.record.exports = extra.exports;
                         item.record.summary = extra.summary;

package/dist/lib/utils/query-timeout.js

@@ -0,0 +1,52 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryTimeoutError = void 0;
+exports.withQueryTimeout = withQueryTimeout;
+const DEFAULT_TIMEOUT_MS = Number(process.env.GMAX_QUERY_TIMEOUT_MS || "") || 15000;
+class QueryTimeoutError extends Error {
+    constructor(label, ms) {
+        super(`LanceDB query timed out after ${ms}ms (${label}). ` +
+            `The store may be busy or hitting a native scan bug — retry, or run: gmax doctor`);
+        this.name = "QueryTimeoutError";
+    }
+}
+exports.QueryTimeoutError = QueryTimeoutError;
+/**
+ * Race a LanceDB query against a wall-clock timeout so a native-layer deadlock
+ * surfaces as a loud error instead of hanging the process forever.
+ *
+ * Known trigger (@lancedb/lancedb 0.27.x): a `content LIKE` scan with
+ * `.limit(N)` where more than N rows match never resolves — the limit-pushdown
+ * cancellation loses the completion (see lancedb/lancedb#2189 for the same
+ * family of hangs). Callers should also avoid that query shape (scan without
+ * a limit and cap in JS); this wrapper is the backstop for shapes we missed.
+ *
+ * The timed-out native promise is NOT cancelled — its tokio task may stay
+ * parked. CLI commands exit via gracefulExit() (process.exit), so the leak is
+ * bounded to the command's lifetime. Long-lived callers (daemon) should treat
+ * a QueryTimeoutError as a signal that the connection may be wedged.
+ */
+function withQueryTimeout(promise_1, label_1) {
+    return __awaiter(this, arguments, void 0, function* (promise, label, ms = DEFAULT_TIMEOUT_MS) {
+        let timer;
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new QueryTimeoutError(label, ms)), ms);
+        });
+        try {
+            return yield Promise.race([promise, timeout]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.17.21",
+  "version": "0.17.23",
   "author": "Robert Owens <78518764+reowens@users.noreply.github.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {
@@ -59,7 +59,7 @@
   "dependencies": {
     "@clack/prompts": "^1.1.0",
     "@huggingface/transformers": "^4.0.0",
-    "@lancedb/lancedb": "^0.27.1",
+    "@lancedb/lancedb": "^0.30.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@parcel/watcher": "^2.5.6",
     "apache-arrow": "^18.1.0",

package/plugins/grepmax/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.17.21",
+  "version": "0.17.23",
   "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
   "author": {
     "name": "Robert Owens",