grepmax 0.17.21 → 0.17.23

package/dist/commands/test-find.js

@@ -45,6 +45,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.testFind = void 0;
 const commander_1 = require("commander");
 const impact_1 = require("../lib/graph/impact");
+const test_hits_1 = require("../lib/graph/test-hits");
 const vector_db_1 = require("../lib/store/vector-db");
 const exit_1 = require("../lib/utils/exit");
 const project_registry_1 = require("../lib/utils/project-registry");
@@ -91,25 +92,18 @@ exports.testFind = new commander_1.Command("test")
             return;
         }
         const rel = (p) => p.startsWith(`${projectRoot}/`) ? p.slice(projectRoot.length + 1) : p;
+        // One line per test file: the file is what the reader runs; caller
+        // symbols inside it (often internal helpers) are detail, not the lead.
+        const grouped = (0, test_hits_1.groupTestHitsByFile)(tests);
         if (opts.agent) {
-            for (const t of tests) {
-                const hopLabel = t.hops === -1
-                    ? "via-import"
-                    : t.hops === 0
-                        ? "direct"
-                        : `${t.hops}-hop`;
-                console.log(`${rel(t.file)}:${t.line + 1}\t${t.symbol}\t${hopLabel}`);
+            for (const t of grouped) {
+                console.log(`${rel(t.file)}:${t.line + 1}\t${(0, test_hits_1.hopLabelAgent)(t.hops)}${(0, test_hits_1.formatViaAgent)(t.via)}`);
             }
         }
         else {
             console.log(`Tests for ${target}:\n`);
-            for (const t of tests) {
-                const hopLabel = t.hops === -1
-                    ? "via import"
-                    : t.hops === 0
-                        ? "calls directly"
-                        : `${t.hops} hop${t.hops > 1 ? "s" : ""} away`;
-                console.log(`  ${rel(t.file)}:${t.line + 1}  ${t.symbol}  (${hopLabel})`);
+            for (const t of grouped) {
+                console.log(`  ${rel(t.file)}:${t.line + 1}  (${(0, test_hits_1.hopLabelHuman)(t.hops)}${(0, test_hits_1.formatViaHuman)(t.via)})`);
             }
         }
     }

package/dist/commands/trace.js

@@ -43,8 +43,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.trace = void 0;
-const fs = __importStar(require("node:fs"));
 const commander_1 = require("commander");
+const callsites_1 = require("../lib/graph/callsites");
 const graph_builder_1 = require("../lib/graph/graph-builder");
 const formatter_1 = require("../lib/output/formatter");
 const vector_db_1 = require("../lib/store/vector-db");
@@ -78,33 +78,6 @@ function formatTraceAgent(graph, projectRoot) {
     }
     return lines.join("\n");
 }
-function findCallSiteSnippet(fileCache, callerFile, callerLine, targetSymbol) {
-    if (!callerFile)
-        return null;
-    let lines = fileCache.get(callerFile);
-    if (!lines) {
-        try {
-            lines = fs.readFileSync(callerFile, "utf-8").split("\n");
-        }
-        catch (_a) {
-            return null;
-        }
-        fileCache.set(callerFile, lines);
-    }
-    // Search a bounded window starting at the caller's definition line.
-    const start = Math.max(0, callerLine);
-    const end = Math.min(lines.length, callerLine + 200);
-    const wordRe = new RegExp(`\\b${targetSymbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`);
-    for (let i = start; i < end; i++) {
-        if (wordRe.test(lines[i])) {
-            return { snippet: lines[i].trim(), snippetLine: i };
-        }
-    }
-    // Window didn't contain the symbol — chunker rolled the reference up to a
-    // parent scope. Skip the snippet rather than showing a misleading default;
-    // the caller's file:line is still emitted.
-    return null;
-}
 function buildInboundTree(callerTree, targetSymbol, fileCache, withSnippets, limit) {
     var _a, _b, _c;
     const out = [];
@@ -114,7 +87,7 @@ function buildInboundTree(callerTree, targetSymbol, fileCache, withSnippets, lim
     const seen = new Set();
     for (const t of callerTree) {
         const snippet = withSnippets
-            ? findCallSiteSnippet(fileCache, t.node.file, t.node.line, targetSymbol)
+            ? (0, callsites_1.findCallSiteSnippet)(fileCache, t.node.file, t.node.line, targetSymbol)
             : null;
         const dedupeKey = `${t.node.file}:${(_a = snippet === null || snippet === void 0 ? void 0 : snippet.snippetLine) !== null && _a !== void 0 ? _a : t.node.line}`;
         if (seen.has(dedupeKey))

package/dist/config.js

@@ -76,6 +76,11 @@ exports.CONFIG = {
     EMBED_BATCH_SIZE: 24,
     WORKER_THREADS: DEFAULT_WORKER_THREADS,
     QUERY_PREFIX: "",
+    // Bump when chunk metadata semantics change in a way that requires a full
+    // reindex to take effect. v2: sub-chunk symbol lists scoped to the chunk's
+    // own content (previously every split sub-chunk inherited the parent's
+    // full defined/referenced symbol lists, fabricating graph edges).
+    CHUNKER_VERSION: 2,
 };
 exports.WORKER_TIMEOUT_MS = Number.parseInt(process.env.GMAX_WORKER_TIMEOUT_MS || "60000", 10);
 exports.WORKER_BOOT_TIMEOUT_MS = Number.parseInt(process.env.GMAX_WORKER_BOOT_TIMEOUT_MS || "300000", 10);

package/dist/eval-like-limit-probe.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * Regression probe for the @lancedb 0.27.x LIKE + limit deadlock.
+ *
+ * A `content LIKE '%X%'` scan with `.limit(N)` never resolves when more than
+ * N rows match — the limit-pushdown cancellation loses the completion (same
+ * family as lancedb/lancedb#2189). gmax works around it by scanning without a
+ * limit and capping in JS; this probe tells us when an upstream lancedb
+ * upgrade makes the limited shape safe again (so the workaround can go).
+ *
+ * Exit 0 = limited LIKE scan resolved (upstream fixed, or matches < limit).
+ * Exit 1 = timed out — the deadlock is still present, keep the workarounds.
+ *
+ * Run: `npx tsx src/eval-like-limit-probe.ts [needle]` (default: "Daemon",
+ * which matches >100 chunks in this repo's index).
+ */
+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 });
+const config_1 = require("./config");
+const vector_db_1 = require("./lib/store/vector-db");
+const filter_builder_1 = require("./lib/utils/filter-builder");
+const query_timeout_1 = require("./lib/utils/query-timeout");
+const needle = process.argv[2] || "Daemon";
+const TIMEOUT_MS = 10000;
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = new vector_db_1.VectorDB(config_1.PATHS.lancedbDir);
+        const table = yield db.ensureTable();
+        const where = `content LIKE '%${(0, filter_builder_1.escapeSqlString)(needle)}%'`;
+        const all = yield (0, query_timeout_1.withQueryTimeout)(table.query().select(["path"]).where(where).toArray(), "unlimited LIKE scan", TIMEOUT_MS);
+        console.log(`unlimited scan: ${all.length} matches for '%${needle}%'`);
+        if (all.length < 2) {
+            console.log("needle too rare to exercise the bug — pick a common one");
+            process.exit(0);
+        }
+        const limit = Math.max(1, Math.floor(all.length / 2));
+        const t0 = Date.now();
+        try {
+            const rows = yield (0, query_timeout_1.withQueryTimeout)(table.query().select(["path"]).where(where).limit(limit).toArray(), `LIKE scan with limit ${limit} < ${all.length} matches`, TIMEOUT_MS);
+            console.log(`limited scan OK: ${rows.length} rows in ${Date.now() - t0}ms — ` +
+                `upstream deadlock not reproduced; LIKE+limit workarounds may be removable`);
+            process.exit(0);
+        }
+        catch (err) {
+            console.error(String(err));
+            console.error("LIKE+limit deadlock still present — keep the unlimited-scan workarounds");
+            process.exit(1);
+        }
+    });
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/lib/daemon/daemon.js

@@ -62,8 +62,7 @@ const config_1 = require("../../config");
 const batch_processor_1 = require("../index/batch-processor");
 const syncer_1 = require("../index/syncer");
 const watcher_1 = require("../index/watcher");
-const searcher_1 = require("../search/searcher");
-const retriever_1 = require("../skeleton/retriever");
+const search_handler_1 = require("./search-handler");
 const meta_cache_1 = require("../store/meta-cache");
 const vector_db_1 = require("../store/vector-db");
 const process_1 = require("../utils/process");
@@ -766,7 +765,7 @@ class Daemon {
                     });
                     const proj = (0, project_registry_1.getProject)(root);
                     if (proj) {
-                        (0, project_registry_1.registerProject)(Object.assign(Object.assign({}, proj), { lastIndexed: new Date().toISOString(), chunkCount: result.indexed, status: "indexed" }));
+                        (0, project_registry_1.registerProject)(Object.assign(Object.assign({}, proj), { lastIndexed: new Date().toISOString(), chunkCount: result.indexed, status: "indexed", chunkerVersion: config_1.CONFIG.CHUNKER_VERSION }));
                     }
                     yield this.watchProject(root);
                     (0, logger_1.log)("daemon", `indexPendingProject done: ${name} — ${result.total} files, ${result.indexed} chunks, ${Date.now() - start}ms`);
@@ -841,105 +840,19 @@ class Daemon {
     }
     search(payload, signal) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
-            if (!this.vectorDb) {
-                return { ok: false, error: "daemon not ready" };
-            }
-            const root = payload.projectRoot;
-            if (!this.processors.has(root)) {
-                // A full index (--reset) or the initial index removes/defers the
-                // processor while (re)building. The partial index is still queryable, so
-                // answer the search and flag it partial (below) rather than erroring —
-                // only truly-unwatched, not-indexing projects get "not watched".
-                const indexingNow = this.indexProgress.has(root) || ((_a = (0, project_registry_1.getProject)(root)) === null || _a === void 0 ? void 0 : _a.status) === "pending";
-                if (!indexingNow) {
-                    return {
-                        ok: false,
-                        error: "project not watched",
-                        hint: `run: gmax add ${root}`,
-                    };
-                }
-            }
-            let searcher = this.searchers.get(root);
-            if (!searcher) {
-                searcher = new searcher_1.Searcher(this.vectorDb);
-                this.searchers.set(root, searcher);
-            }
-            this.lastActivity = Date.now();
-            let result;
-            try {
-                result = yield searcher.search(payload.query, payload.limit, {
-                    rerank: payload.rerank === true,
-                    explain: payload.explain === true,
-                    seeds: payload.seeds,
-                }, payload.filters, payload.pathPrefix, undefined, signal);
-            }
-            catch (err) {
-                if ((err === null || err === void 0 ? void 0 : err.name) === "AbortError") {
-                    return { ok: false, error: "aborted" };
-                }
-                const msg = err instanceof Error ? err.message : String(err);
-                return { ok: false, error: "search_failed", hint: msg };
-            }
-            const response = { ok: true, data: result.data };
-            if ((_b = result.warnings) === null || _b === void 0 ? void 0 : _b.length)
-                response.warnings = result.warnings;
-            // Annotate partial results when the index is still catching up, so an
-            // agent can caveat or retry. Only attached when actually indexing (the
-            // formatter suppresses the settled case anyway).
-            const idx = this.indexState(root);
-            if (idx.indexing)
-                response.indexState = idx;
-            // --skeleton support: fetch per-file skeletons inline so the CLI doesn't
-            // have to open its own VectorDB. getStoredSkeleton is a single LIMIT-1
-            // lookup; cheap enough to call for the top N distinct paths.
-            if (payload.includeSkeletons && result.data.length > 0) {
-                const limit = payload.skeletonLimit && payload.skeletonLimit > 0 ? payload.skeletonLimit : 5;
-                const seen = new Set();
-                const skeletons = {};
-                for (const chunk of result.data) {
-                    const p = (_c = chunk.path) !== null && _c !== void 0 ? _c : (_d = chunk.metadata) === null || _d === void 0 ? void 0 : _d.path;
-                    if (!p || seen.has(p))
-                        continue;
-                    seen.add(p);
-                    if (seen.size > limit)
-                        break;
-                    try {
-                        const sk = yield (0, retriever_1.getStoredSkeleton)(this.vectorDb, p);
-                        if (sk)
-                            skeletons[p] = sk;
-                    }
-                    catch (_e) {
-                        // best-effort — drop the entry, keep the search result
-                    }
-                }
-                if (Object.keys(skeletons).length > 0)
-                    response.skeletons = skeletons;
-            }
-            // --symbol support: build a 1-hop graph using the warm vectorDb. ~5
-            // LanceDB queries; doesn't touch the worker pool.
-            if (payload.includeGraph) {
-                try {
-                    const { GraphBuilder } = yield Promise.resolve().then(() => __importStar(require("../graph/graph-builder")));
-                    const builder = new GraphBuilder(this.vectorDb, root);
-                    response.graph = yield builder.buildGraphMultiHop(payload.query, 1);
-                }
-                catch (_f) {
-                    // best-effort — drop graph, keep results
-                }
-            }
-            // 2 MB cap on the JSON line. Lance can return huge chunks for unusual
-            // queries (very long markdown blobs). Above this we fall back to the
-            // in-process path which writes to stdout instead of a socket.
-            const serialized = JSON.stringify(response);
-            if (serialized.length > 2 * 1024 * 1024) {
-                return {
-                    ok: false,
-                    error: "oversize",
-                    hint: `${serialized.length} bytes — falling back to in-process search`,
-                };
-            }
-            return response;
+            // Search handling lives in search-handler.ts (Phase 12 split). The daemon
+            // supplies its warm VectorDB + watcher/index bookkeeping; the handler runs
+            // the query and assembles the response.
+            return (0, search_handler_1.handleDaemonSearch)({
+                vectorDb: this.vectorDb,
+                processors: this.processors,
+                indexProgress: this.indexProgress,
+                searchers: this.searchers,
+                getIndexState: (root) => this.indexState(root),
+                touchActivity: () => {
+                    this.lastActivity = Date.now();
+                },
+            }, payload, signal);
         });
     }
     listProjects() {

package/dist/lib/daemon/search-handler.js

@@ -0,0 +1,159 @@
+"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;
+    };
+})();
+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.handleDaemonSearch = handleDaemonSearch;
+const searcher_1 = require("../search/searcher");
+const retriever_1 = require("../skeleton/retriever");
+const project_registry_1 = require("../utils/project-registry");
+/**
+ * Daemon-side search: runs the hybrid+rerank against the already-warm VectorDB
+ * and optionally attaches inline skeletons / a 1-hop graph / a partial-index
+ * footer. Extracted from Daemon.search() (Phase 12) — behavior-preserving.
+ */
+function handleDaemonSearch(deps, payload, signal) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        const { vectorDb } = deps;
+        if (!vectorDb) {
+            return { ok: false, error: "daemon not ready" };
+        }
+        const root = payload.projectRoot;
+        if (!deps.processors.has(root)) {
+            // A full index (--reset) or the initial index removes/defers the
+            // processor while (re)building. The partial index is still queryable, so
+            // answer the search and flag it partial (below) rather than erroring —
+            // only truly-unwatched, not-indexing projects get "not watched".
+            const indexingNow = deps.indexProgress.has(root) || ((_a = (0, project_registry_1.getProject)(root)) === null || _a === void 0 ? void 0 : _a.status) === "pending";
+            if (!indexingNow) {
+                return {
+                    ok: false,
+                    error: "project not watched",
+                    hint: `run: gmax add ${root}`,
+                };
+            }
+        }
+        let searcher = deps.searchers.get(root);
+        if (!searcher) {
+            searcher = new searcher_1.Searcher(vectorDb);
+            deps.searchers.set(root, searcher);
+        }
+        deps.touchActivity();
+        let result;
+        try {
+            result = yield searcher.search(payload.query, payload.limit, {
+                rerank: payload.rerank === true,
+                explain: payload.explain === true,
+                seeds: payload.seeds,
+            }, payload.filters, payload.pathPrefix, undefined, signal);
+        }
+        catch (err) {
+            if ((err === null || err === void 0 ? void 0 : err.name) === "AbortError") {
+                return { ok: false, error: "aborted" };
+            }
+            const msg = err instanceof Error ? err.message : String(err);
+            return { ok: false, error: "search_failed", hint: msg };
+        }
+        const response = { ok: true, data: result.data };
+        if ((_b = result.warnings) === null || _b === void 0 ? void 0 : _b.length)
+            response.warnings = result.warnings;
+        // Annotate partial results when the index is still catching up, so an
+        // agent can caveat or retry. Only attached when actually indexing (the
+        // formatter suppresses the settled case anyway).
+        const idx = deps.getIndexState(root);
+        if (idx.indexing)
+            response.indexState = idx;
+        // --skeleton support: fetch per-file skeletons inline so the CLI doesn't
+        // have to open its own VectorDB. getStoredSkeleton is a single LIMIT-1
+        // lookup; cheap enough to call for the top N distinct paths.
+        if (payload.includeSkeletons && result.data.length > 0) {
+            const limit = payload.skeletonLimit && payload.skeletonLimit > 0
+                ? payload.skeletonLimit
+                : 5;
+            const seen = new Set();
+            const skeletons = {};
+            for (const chunk of result.data) {
+                const p = (_c = chunk.path) !== null && _c !== void 0 ? _c : (_d = chunk.metadata) === null || _d === void 0 ? void 0 : _d.path;
+                if (!p || seen.has(p))
+                    continue;
+                seen.add(p);
+                if (seen.size > limit)
+                    break;
+                try {
+                    const sk = yield (0, retriever_1.getStoredSkeleton)(vectorDb, p);
+                    if (sk)
+                        skeletons[p] = sk;
+                }
+                catch (_e) {
+                    // best-effort — drop the entry, keep the search result
+                }
+            }
+            if (Object.keys(skeletons).length > 0)
+                response.skeletons = skeletons;
+        }
+        // --symbol support: build a 1-hop graph using the warm vectorDb. ~5
+        // LanceDB queries; doesn't touch the worker pool.
+        if (payload.includeGraph) {
+            try {
+                const { GraphBuilder } = yield Promise.resolve().then(() => __importStar(require("../graph/graph-builder")));
+                const builder = new GraphBuilder(vectorDb, root);
+                response.graph = yield builder.buildGraphMultiHop(payload.query, 1);
+            }
+            catch (_f) {
+                // best-effort — drop graph, keep results
+            }
+        }
+        // 2 MB cap on the JSON line. Lance can return huge chunks for unusual
+        // queries (very long markdown blobs). Above this we fall back to the
+        // in-process path which writes to stdout instead of a socket.
+        const serialized = JSON.stringify(response);
+        if (serialized.length > 2 * 1024 * 1024) {
+            return {
+                ok: false,
+                error: "oversize",
+                hint: `${serialized.length} bytes — falling back to in-process search`,
+            };
+        }
+        return response;
+    });
+}

package/dist/lib/graph/callsites.js

@@ -0,0 +1,148 @@
+"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.findCallSiteSnippet = findCallSiteSnippet;
+exports.resolveCallSites = resolveCallSites;
+exports.isBuiltinCallee = isBuiltinCallee;
+/**
+ * Call-site resolution for chunk-granularity caller edges.
+ *
+ * `GraphBuilder.getCallers()` returns one row per *chunk* whose
+ * referenced_symbols contains the target — for a large class split into many
+ * chunks that means many rows pointing at chunk boundaries, not call sites.
+ * These helpers re-anchor each caller row to the actual line that mentions the
+ * target symbol and collapse duplicates, so consumers (trace, peek, impact)
+ * report real call sites with true counts.
+ */
+const fs = __importStar(require("node:fs"));
+function findCallSiteSnippet(fileCache, callerFile, callerLine, targetSymbol) {
+    if (!callerFile)
+        return null;
+    let lines = fileCache.get(callerFile);
+    if (!lines) {
+        try {
+            lines = fs.readFileSync(callerFile, "utf-8").split("\n");
+        }
+        catch (_a) {
+            return null;
+        }
+        fileCache.set(callerFile, lines);
+    }
+    // Search a bounded window starting at the caller's definition line.
+    const start = Math.max(0, callerLine);
+    const end = Math.min(lines.length, callerLine + 200);
+    const wordRe = new RegExp(`\\b${targetSymbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`);
+    for (let i = start; i < end; i++) {
+        if (wordRe.test(lines[i])) {
+            return { snippet: lines[i].trim(), snippetLine: i };
+        }
+    }
+    // Window didn't contain the symbol — chunker rolled the reference up to a
+    // parent scope. Skip the snippet rather than showing a misleading default;
+    // the caller's file:line is still emitted.
+    return null;
+}
+/**
+ * Resolve chunk-level caller rows to deduplicated call sites. Rows from
+ * different chunks of the same file that resolve to the same source line
+ * collapse into one entry; rows whose window doesn't contain the symbol
+ * dedupe by file+symbol so split-chunk spam can't multiply them.
+ */
+function resolveCallSites(callers, targetSymbol, fileCache = new Map()) {
+    var _a, _b;
+    const out = [];
+    const seen = new Set();
+    for (const c of callers) {
+        const snippet = findCallSiteSnippet(fileCache, c.file, c.line, targetSymbol);
+        const key = snippet
+            ? `${c.file}:${snippet.snippetLine}`
+            : `${c.file}:${c.symbol}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push({
+            symbol: c.symbol,
+            file: c.file,
+            line: c.line,
+            snippet: (_a = snippet === null || snippet === void 0 ? void 0 : snippet.snippet) !== null && _a !== void 0 ? _a : null,
+            snippetLine: (_b = snippet === null || snippet === void 0 ? void 0 : snippet.snippetLine) !== null && _b !== void 0 ? _b : null,
+        });
+    }
+    return out;
+}
+/**
+ * Identifiers that read as "callees" in referenced_symbols but are language
+ * or runtime builtins — listing them as "(not indexed)" callees is noise.
+ * Only consulted for UNRESOLVED names; a project symbol that shadows one of
+ * these still shows up because it resolves to an indexed definition.
+ */
+const BUILTIN_CALLEES = new Set([
+    // Object/primitive methods
+    "toString", "valueOf", "hasOwnProperty",
+    // Array/String methods
+    "push", "pop", "shift", "unshift", "slice", "splice", "concat", "join",
+    "map", "filter", "reduce", "forEach", "find", "findIndex", "some", "every",
+    "includes", "indexOf", "lastIndexOf", "sort", "reverse", "flat", "flatMap",
+    "keys", "values", "entries", "fill",
+    "split", "trim", "trimStart", "trimEnd", "replace", "replaceAll", "match",
+    "matchAll", "test", "exec", "padStart", "padEnd", "repeat", "charAt",
+    "charCodeAt", "codePointAt", "startsWith", "endsWith", "toLowerCase",
+    "toUpperCase", "substring", "substr", "localeCompare", "normalize",
+    // Map/Set methods
+    "get", "set", "has", "add", "delete", "clear",
+    // Math/Date/Number members
+    "trunc", "floor", "ceil", "round", "abs", "min", "max", "random", "pow",
+    "sqrt", "log2", "log10", "sign", "now", "parse", "parseInt", "parseFloat",
+    "isInteger", "isFinite", "isNaN", "toFixed", "toISOString",
+    // Promise/Function members
+    "then", "catch", "finally", "resolve", "reject", "all", "allSettled",
+    "race", "any", "call", "apply", "bind",
+    // JSON / global constructors & functions
+    "JSON", "stringify", "Math", "Date", "Promise", "Array", "Object", "String",
+    "Number", "Boolean", "Symbol", "RegExp", "Error", "TypeError", "RangeError",
+    "Map", "Set", "WeakMap", "WeakSet", "Buffer", "URL", "URLSearchParams",
+    "isArray", "from", "of", "assign", "freeze", "create", "getOwnPropertyNames",
+    "fromEntries", "setTimeout", "setInterval", "clearTimeout", "clearInterval",
+    "queueMicrotask", "structuredClone", "fetch", "console", "process",
+    "require", "encodeURIComponent", "decodeURIComponent", "encodeURI",
+    "decodeURI", "atob", "btoa",
+    // console members
+    "warn", "info", "debug", "trace", "table", "dir", "group", "groupEnd",
+    "assert", "time", "timeEnd",
+]);
+/** True when an UNRESOLVED callee name is a known JS/TS builtin. */
+function isBuiltinCallee(name) {
+    return BUILTIN_CALLEES.has(name);
+}

package/dist/lib/graph/graph-builder.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GraphBuilder = void 0;
 const filter_builder_1 = require("../utils/filter-builder");
+const query_timeout_1 = require("../utils/query-timeout");
 const graph_traversal_1 = require("./graph-traversal");
 class GraphBuilder {
     constructor(db, pathPrefix, excludePrefixes) {
@@ -132,15 +133,18 @@ class GraphBuilder {
         return __awaiter(this, void 0, void 0, function* () {
             const table = yield this.db.ensureTable();
             const escaped = (0, filter_builder_1.escapeSqlString)(symbol);
-            const rows = yield table
+            // 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(this.scopeWhere(`content LIKE '%import%${escaped}%'`))
-                .limit(100)
-                .toArray();
+                .toArray(), `content LIKE %import%${symbol}% (importers)`);
             const files = new Set();
             for (const row of rows) {
                 files.add(String(row.path || ""));
+                if (files.size >= 100)
+                    break;
             }
             return Array.from(files);
         });