grepmax 0.21.3 → 0.22.0

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

@@ -15,6 +15,19 @@ const filter_builder_1 = require("../utils/filter-builder");
 const query_timeout_1 = require("../utils/query-timeout");
 const callsites_1 = require("./callsites");
 const graph_traversal_1 = require("./graph-traversal");
+/** Sort key for the caller confidence tier: free call < member call < type ref. */
+function edgeRank(node) {
+    switch (node.edgeKind) {
+        case "free":
+            return 0;
+        case "member":
+            return 1;
+        case "type":
+            return 2;
+        default:
+            return 3;
+    }
+}
 class GraphBuilder {
     constructor(db, pathPrefix, excludePrefixes) {
         this.db = db;
@@ -59,6 +72,10 @@ class GraphBuilder {
                 "start_line",
                 "defined_symbols",
                 "referenced_symbols",
+                // member_/type_ are needed so each caller edge can be tagged free vs
+                // member vs type (the confidence tier + builtin-member suppression).
+                "member_referenced_symbols",
+                "type_referenced_symbols",
                 "role",
                 "parent_symbol",
                 "complexity",
@@ -76,7 +93,23 @@ class GraphBuilder {
                     const fam = (0, languages_1.languageFamilyForPath)(String((_a = row.path) !== null && _a !== void 0 ? _a : ""));
                     return fam == null || fam === anchorFamily;
                 });
-            return guarded.map((row) => this.mapRowToNode(row, symbol, "caller"));
+            const nodes = guarded.map((row) => this.mapRowToNode(row, symbol, "caller"));
+            // Caller-side builtin-member suppression. A member call `x.T()` to a builtin
+            // name T (`.get`/`.map`/`.forEach`) is almost always an unrelated stdlib
+            // method, not a real caller of the project symbol T — mirrors the callee-side
+            // guard in buildGraph. Only fires when T itself is a builtin name, so a normal
+            // symbol that merely has member callers is untouched.
+            const filtered = (0, callsites_1.isBuiltinCallee)(symbol)
+                ? nodes.filter((n) => n.edgeKind !== "member")
+                : nodes;
+            // Confidence sort: free calls (EXTRACTED) first, then member, then type,
+            // preserving scan order within a tier (Array.sort is stable). Keeps the
+            // trustworthy callers above the display caps (peek MAX_CALLERS, MCP limits)
+            // so guesses don't read as facts.
+            return filtered
+                .map((n, i) => ({ n, i }))
+                .sort((a, b) => edgeRank(a.n) - edgeRank(b.n) || a.i - b.i)
+                .map(({ n }) => n);
         });
     }
     /**
@@ -105,6 +138,7 @@ class GraphBuilder {
      */
     buildGraph(symbol) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             const table = yield this.db.ensureTable();
             const escaped = (0, filter_builder_1.escapeSqlString)(symbol);
             // 1. Get Center (Definition)
@@ -127,8 +161,8 @@ class GraphBuilder {
                 : null;
             // 2. Get Callers — anchored to the center definition's language family so a
             // bare name shared across languages doesn't pull in cross-language callers.
-            const anchorFamily = center ? (0, languages_1.languageFamilyForPath)(center.file) : null;
-            const callers = yield this.getCallers(symbol, anchorFamily);
+            const centerFamily = center ? (0, languages_1.languageFamilyForPath)(center.file) : null;
+            const callers = yield this.getCallers(symbol, centerFamily);
             // 3. Get Callees — resolve each to a GraphNode with file:line
             const calleeNames = center ? center.calls.slice(0, 15) : [];
             const centerFile = center ? center.file : "";
@@ -154,11 +188,17 @@ class GraphBuilder {
                     .limit(25)
                     .toArray();
                 if (rows.length > 0) {
-                    // Prefer-self-file: a callee the center also defines locally is almost
-                    // certainly that local definition. Falls back to the first row when no
-                    // candidate is in the center's file (unchanged behaviour then).
+                    // Prefer-self-file, then same-language-family. Only fall back to the
+                    // first row when no candidate shares the center's file or family.
                     const selfRow = rows.find((r) => { var _a; return String((_a = r.path) !== null && _a !== void 0 ? _a : "") === centerFile; });
-                    calleeNodes.push(this.mapRowToNode((selfRow !== null && selfRow !== void 0 ? selfRow : rows[0]), name, "center"));
+                    const familyRow = centerFamily
+                        ? rows.find((r) => {
+                            var _a;
+                            return (0, languages_1.languageFamilyForPath)(String((_a = r.path) !== null && _a !== void 0 ? _a : "")) ===
+                                centerFamily;
+                        })
+                        : undefined;
+                    calleeNodes.push(this.mapRowToNode(((_a = selfRow !== null && selfRow !== void 0 ? selfRow : familyRow) !== null && _a !== void 0 ? _a : rows[0]), name, "center"));
                 }
                 else if (!(0, callsites_1.isBuiltinCallee)(name)) {
                     // Unresolved + a known builtin (.map/.get/forEach) → suppress the
@@ -255,10 +295,7 @@ class GraphBuilder {
     /** Distinct symbols that reference the given symbol (inbound edges). */
     callersOf(symbol) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Anchor the guard to this symbol's own definition language family so the
-            // bare name doesn't pull in callers from an unrelated language.
-            const loc = yield this.resolveLocation(symbol);
-            const nodes = yield this.getCallers(symbol, loc ? (0, languages_1.languageFamilyForPath)(loc.file) : null);
+            const nodes = yield this.getAnchoredCallers(symbol);
             const out = [];
             for (const n of nodes) {
                 if (n.symbol && n.symbol !== "unknown" && !out.includes(n.symbol)) {
@@ -312,12 +349,19 @@ class GraphBuilder {
      * several languages); falls back to the first definition when none match.
      */
     resolveLocation(symbol, anchorFamily) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const def = yield this.resolveDefinition(symbol, anchorFamily);
+            return def ? { file: def.file, line: def.line } : null;
+        });
+    }
+    /** Resolve a symbol to its defining chunk plus language family metadata. */
+    resolveDefinition(symbol, anchorFamily) {
         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
                 .query()
-                .select(["path", "start_line"])
+                .select(["path", "start_line", "is_exported"])
                 .where(this.scopeWhere(`array_contains(defined_symbols, '${escaped}')`))
                 // No anchor → keep the cheap single-row fetch. With one, pull a few
                 // candidates so we can pick the same-family definition instead of guessing.
@@ -335,7 +379,20 @@ class GraphBuilder {
                 if (match)
                     r = match;
             }
-            return { file: String(r.path || ""), line: Number(r.start_line || 0) };
+            const file = String(r.path || "");
+            return {
+                file,
+                line: Number(r.start_line || 0),
+                family: (0, languages_1.languageFamilyForPath)(file),
+                isExported: Boolean(r.is_exported),
+            };
+        });
+    }
+    getAnchoredCallers(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const def = yield this.resolveDefinition(symbol);
+            return this.getCallers(symbol, (_a = def === null || def === void 0 ? void 0 : def.family) !== null && _a !== void 0 ? _a : null);
         });
     }
     /**
@@ -386,6 +443,26 @@ class GraphBuilder {
         if (type === "center") {
             symbol = targetSymbol;
         }
+        // Classify HOW a caller references the target, for the confidence tier. Check
+        // member first: member names are ALSO in referenced_symbols (additive column),
+        // so a plain `referencedSymbols.includes` can't tell the two apart. Center and
+        // callee nodes get no edgeKind (not applicable).
+        let edgeKind;
+        let confidence;
+        if (type === "caller") {
+            if (toArray(row.member_referenced_symbols).includes(targetSymbol)) {
+                edgeKind = "member";
+                confidence = "INFERRED";
+            }
+            else if (referencedSymbols.includes(targetSymbol)) {
+                edgeKind = "free";
+                confidence = "EXTRACTED";
+            }
+            else if (toArray(row.type_referenced_symbols).includes(targetSymbol)) {
+                edgeKind = "type";
+                confidence = "INFERRED";
+            }
+        }
         return {
             symbol,
             file: row.path,
@@ -394,6 +471,8 @@ class GraphBuilder {
             calls: referencedSymbols,
             calledBy: [], // To be filled if we do reverse lookup
             complexity: row.complexity,
+            edgeKind,
+            confidence,
         };
     }
 }

package/dist/lib/graph/impact.js

@@ -13,6 +13,7 @@ exports.isTestPath = isTestPath;
 exports.resolveTargetSymbols = resolveTargetSymbols;
 exports.findTests = findTests;
 exports.findDependents = findDependents;
+const languages_1 = require("../core/languages");
 const filter_builder_1 = require("../utils/filter-builder");
 const query_timeout_1 = require("../utils/query-timeout");
 const graph_builder_1 = require("./graph-builder");
@@ -50,11 +51,49 @@ function resolveTargetSymbols(target, vectorDb, projectRoot) {
                     symbols.add(s);
                 }
             }
-            return { symbols: [...symbols], resolvedAsFile: true };
+            const family = (0, languages_1.languageFamilyForPath)(absPath);
+            return {
+                symbols: [...symbols],
+                resolvedAsFile: true,
+                symbolFamilies: new Map([...symbols].map((s) => [s, family])),
+            };
         }
         return { symbols: [target], resolvedAsFile: false };
     });
 }
+function familyMatchesPath(anchorFamily, filePath) {
+    if (anchorFamily == null)
+        return true;
+    const family = (0, languages_1.languageFamilyForPath)(filePath);
+    return family == null || family === anchorFamily;
+}
+function resolveSymbolFamilies(symbols, vectorDb, projectRoot, excludePrefixes, seed) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const families = new Map(seed);
+        const missing = symbols.filter((s) => !families.has(s));
+        if (missing.length === 0)
+            return families;
+        const table = yield vectorDb.ensureTable();
+        const prefix = projectRoot.endsWith("/") ? projectRoot : `${projectRoot}/`;
+        let pathScope = (0, filter_builder_1.pathStartsWith)(prefix);
+        for (const ex of excludePrefixes !== null && excludePrefixes !== void 0 ? excludePrefixes : []) {
+            const exNorm = ex.endsWith("/") ? ex : `${ex}/`;
+            pathScope += ` AND ${(0, filter_builder_1.pathNotStartsWith)(exNorm)}`;
+        }
+        for (const sym of missing) {
+            const rows = yield table
+                .query()
+                .select(["path"])
+                .where(`array_contains(defined_symbols, '${(0, filter_builder_1.escapeSqlString)(sym)}') AND ${pathScope}`)
+                .limit(25)
+                .toArray();
+            const file = String(((_a = rows[0]) === null || _a === void 0 ? void 0 : _a.path) || "");
+            families.set(sym, file ? (0, languages_1.languageFamilyForPath)(file) : null);
+        }
+        return families;
+    });
+}
 /**
  * For a single symbol, expand to include all symbols defined in the same file.
  * This catches cases where tests call methods of a class rather than the class name itself
@@ -109,16 +148,18 @@ function expandFileSymbols(symbols, vectorDb, projectRoot, excludePrefixes) {
  * Fallback hits are tagged with hops = -1.
  */
 function findTests(symbols_1, vectorDb_1, projectRoot_1) {
-    return __awaiter(this, arguments, void 0, function* (symbols, vectorDb, projectRoot, depth = 1, excludePrefixes) {
+    return __awaiter(this, arguments, void 0, function* (symbols, vectorDb, projectRoot, depth = 1, excludePrefixes, symbolFamilies) {
+        var _a;
         const graphBuilder = new graph_builder_1.GraphBuilder(vectorDb, projectRoot, excludePrefixes);
         const testHits = new Map(); // key: file+symbol
         // Expand single-symbol targets to include all symbols from the same file
         const expanded = yield expandFileSymbols(symbols, vectorDb, projectRoot, excludePrefixes);
+        const families = yield resolveSymbolFamilies(expanded, vectorDb, projectRoot, excludePrefixes, symbolFamilies);
         for (const symbol of expanded) {
-            yield walkCallers(symbol, graphBuilder, testHits, 0, depth, new Set());
+            yield walkCallers(symbol, graphBuilder, testHits, 0, depth, new Set(), (_a = families.get(symbol)) !== null && _a !== void 0 ? _a : null);
         }
         if (testHits.size === 0) {
-            const importFiles = yield findImportFallbackTests(expanded, symbols, vectorDb, projectRoot, excludePrefixes);
+            const importFiles = yield findImportFallbackTests(expanded, symbols, vectorDb, projectRoot, excludePrefixes, families);
             for (const file of importFiles) {
                 testHits.set(`${file}:(referenced)`, {
                     file,
@@ -131,13 +172,14 @@ 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(expandedSymbols, originalSymbols, vectorDb, projectRoot, excludePrefixes) {
+function findImportFallbackTests(expandedSymbols, originalSymbols, vectorDb, projectRoot, excludePrefixes, symbolFamilies) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
         const files = new Set();
         // Signal 1: referenced_symbols match (precise; works when the chunker
         // 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);
+        const dependents = yield findDependents(expandedSymbols, vectorDb, projectRoot, undefined, 50, excludePrefixes, symbolFamilies);
         for (const d of dependents) {
             if (isTestPath(d.file))
                 files.add(d.file);
@@ -155,6 +197,7 @@ function findImportFallbackTests(expandedSymbols, originalSymbols, vectorDb, pro
         // 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) {
+            const family = (_a = symbolFamilies === null || symbolFamilies === void 0 ? void 0 : symbolFamilies.get(sym)) !== null && _a !== void 0 ? _a : null;
             // 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
@@ -164,19 +207,19 @@ function findImportFallbackTests(expandedSymbols, originalSymbols, vectorDb, pro
                 .toArray(), `content LIKE %${sym}% (test fallback)`);
             for (const row of rows.slice(0, 500)) {
                 const p = String(row.path || "");
-                if (isTestPath(p))
+                if (isTestPath(p) && familyMatchesPath(family, p))
                     files.add(p);
             }
         }
         return files;
     });
 }
-function walkCallers(symbol, graphBuilder, testHits, currentHop, maxDepth, visited) {
+function walkCallers(symbol, graphBuilder, testHits, currentHop, maxDepth, visited, anchorFamily) {
     return __awaiter(this, void 0, void 0, function* () {
         if (visited.has(symbol))
             return;
         visited.add(symbol);
-        const callers = yield graphBuilder.getCallers(symbol);
+        const callers = yield graphBuilder.getCallers(symbol, anchorFamily);
         for (const caller of callers) {
             if (isTestPath(caller.file)) {
                 const key = `${caller.file}:${caller.symbol}`;
@@ -191,7 +234,7 @@ function walkCallers(symbol, graphBuilder, testHits, currentHop, maxDepth, visit
             }
             // Continue walking callers if within depth
             if (currentHop < maxDepth - 1) {
-                yield walkCallers(caller.symbol, graphBuilder, testHits, currentHop + 1, maxDepth, visited);
+                yield walkCallers(caller.symbol, graphBuilder, testHits, currentHop + 1, maxDepth, visited, (0, languages_1.languageFamilyForPath)(caller.file));
             }
         }
     });
@@ -201,15 +244,18 @@ function walkCallers(symbol, graphBuilder, testHits, currentHop, maxDepth, visit
  * Returns files sorted by number of shared symbols (descending).
  */
 function findDependents(symbols_1, vectorDb_1, projectRoot_1, excludePaths_1) {
-    return __awaiter(this, arguments, void 0, function* (symbols, vectorDb, projectRoot, excludePaths, limit = 10, excludePrefixes) {
+    return __awaiter(this, arguments, void 0, function* (symbols, vectorDb, projectRoot, excludePaths, limit = 10, excludePrefixes, symbolFamilies) {
+        var _a, _b;
         const table = yield vectorDb.ensureTable();
         let pathScope = (0, filter_builder_1.pathStartsWith)(`${projectRoot}/`);
         for (const ex of excludePrefixes !== null && excludePrefixes !== void 0 ? excludePrefixes : []) {
             const exNorm = ex.endsWith("/") ? ex : `${ex}/`;
             pathScope += ` AND ${(0, filter_builder_1.pathNotStartsWith)(exNorm)}`;
         }
-        const counts = new Map();
+        const symbolsByFile = new Map();
+        const families = yield resolveSymbolFamilies(symbols, vectorDb, projectRoot, excludePrefixes, symbolFamilies);
         for (const sym of symbols) {
+            const family = (_a = families.get(sym)) !== null && _a !== void 0 ? _a : null;
             // 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.)
@@ -223,12 +269,16 @@ function findDependents(symbols_1, vectorDb_1, projectRoot_1, excludePaths_1) {
                 const p = String(row.path || "");
                 if (excludePaths === null || excludePaths === void 0 ? void 0 : excludePaths.has(p))
                     continue;
-                counts.set(p, (counts.get(p) || 0) + 1);
+                if (!familyMatchesPath(family, p))
+                    continue;
+                const set = (_b = symbolsByFile.get(p)) !== null && _b !== void 0 ? _b : new Set();
+                set.add(sym);
+                symbolsByFile.set(p, set);
             }
         }
-        return Array.from(counts.entries())
-            .sort((a, b) => b[1] - a[1])
+        return Array.from(symbolsByFile.entries())
+            .sort((a, b) => b[1].size - a[1].size)
             .slice(0, limit)
-            .map(([file, sharedSymbols]) => ({ file, sharedSymbols }));
+            .map(([file, symbols]) => ({ file, sharedSymbols: symbols.size }));
     });
 }

package/dist/lib/index/batch-processor.js

@@ -63,6 +63,7 @@ class ProjectBatchProcessor {
         this.pending = new Map();
         this.retryCount = new Map();
         this.debounceTimer = null;
+        this.activeBatch = null;
         this.processing = false;
         this.closed = false;
         this.currentBatchAc = null;
@@ -105,14 +106,34 @@ class ProjectBatchProcessor {
             var _a;
             this.closed = true;
             (_a = this.currentBatchAc) === null || _a === void 0 ? void 0 : _a.abort();
-            if (this.debounceTimer)
+            if (this.debounceTimer) {
                 clearTimeout(this.debounceTimer);
+                this.debounceTimer = null;
+            }
+            if (this.activeBatch) {
+                yield this.activeBatch;
+            }
         });
     }
     scheduleBatch() {
         if (this.debounceTimer)
             clearTimeout(this.debounceTimer);
-        this.debounceTimer = setTimeout(() => this.processBatch(), DEBOUNCE_MS);
+        this.debounceTimer = setTimeout(() => {
+            this.debounceTimer = null;
+            this.startBatch();
+        }, DEBOUNCE_MS);
+    }
+    startBatch() {
+        if (this.activeBatch)
+            return;
+        const run = this.processBatch().catch((err) => {
+            console.error(`[${this.wtag}] Batch processing failed:`, err);
+        });
+        this.activeBatch = run;
+        void run.finally(() => {
+            if (this.activeBatch === run)
+                this.activeBatch = null;
+        });
     }
     processBatch() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -124,7 +145,10 @@ class ProjectBatchProcessor {
                 (0, logger_1.log)(this.wtag, "Disk critically low — deferring batch processing");
                 if (this.debounceTimer)
                     clearTimeout(this.debounceTimer);
-                this.debounceTimer = setTimeout(() => this.processBatch(), 60000);
+                this.debounceTimer = setTimeout(() => {
+                    this.debounceTimer = null;
+                    this.startBatch();
+                }, 60000);
                 return;
             }
             this.processing = true;
@@ -158,11 +182,10 @@ class ProjectBatchProcessor {
                 const vectors = [];
                 const metaUpdates = new Map();
                 const metaDeletes = [];
-                const attempted = new Set();
+                const completed = new Set();
                 for (const [absPath, event] of batch) {
                     if (batchAc.signal.aborted)
                         break;
-                    attempted.add(absPath);
                     processed++;
                     if (batch.size > 10 &&
                         (processed % 10 === 0 || processed === batch.size)) {
@@ -172,6 +195,7 @@ class ProjectBatchProcessor {
                         deletes.push(absPath);
                         metaDeletes.push(absPath);
                         reindexed++;
+                        completed.add(absPath);
                         continue;
                     }
                     // change or add
@@ -186,10 +210,12 @@ class ProjectBatchProcessor {
                                 metaDeletes.push(absPath);
                                 reindexed++;
                             }
+                            completed.add(absPath);
                             continue;
                         }
                         const cached = this.metaCache.get(absPath);
                         if ((0, cache_check_1.isFileCached)(cached, stats)) {
+                            completed.add(absPath);
                             continue;
                         }
                         // Fast path: if only mtime changed but size matches and we have a hash,
@@ -199,6 +225,7 @@ class ProjectBatchProcessor {
                             const hash = (0, file_utils_1.computeContentHash)(buf, absPath);
                             if (hash === cached.hash) {
                                 metaUpdates.set(absPath, Object.assign(Object.assign({}, cached), { mtimeMs: stats.mtimeMs }));
+                                completed.add(absPath);
                                 continue;
                             }
                         }
@@ -213,12 +240,14 @@ class ProjectBatchProcessor {
                         };
                         if (cached && cached.hash === result.hash) {
                             metaUpdates.set(absPath, metaEntry);
+                            completed.add(absPath);
                             continue;
                         }
                         if (result.shouldDelete) {
                             deletes.push(absPath);
                             metaUpdates.set(absPath, metaEntry);
                             reindexed++;
+                            completed.add(absPath);
                             continue;
                         }
                         deletes.push(absPath);
@@ -227,6 +256,7 @@ class ProjectBatchProcessor {
                         }
                         metaUpdates.set(absPath, metaEntry);
                         reindexed++;
+                        completed.add(absPath);
                     }
                     catch (err) {
                         if (batchAc.signal.aborted)
@@ -236,6 +266,7 @@ class ProjectBatchProcessor {
                             deletes.push(absPath);
                             metaDeletes.push(absPath);
                             reindexed++;
+                            completed.add(absPath);
                         }
                         else {
                             console.error(`[${this.wtag}] Failed to process ${absPath}:`, err);
@@ -243,12 +274,14 @@ class ProjectBatchProcessor {
                                 console.error(`[${this.wtag}] Worker pool unhealthy, aborting batch`);
                                 break;
                             }
+                            completed.add(absPath);
                         }
                     }
                 }
-                // Requeue files that weren't attempted (aborted or pool unhealthy)
+                // Requeue files that didn't reach a terminal outcome. This includes the
+                // file whose worker was in flight when the batch was aborted.
                 for (const [absPath, event] of batch) {
-                    if (!attempted.has(absPath) && !this.pending.has(absPath)) {
+                    if (!completed.has(absPath) && !this.pending.has(absPath)) {
                         this.pending.set(absPath, event);
                     }
                 }
@@ -339,11 +372,14 @@ class ProjectBatchProcessor {
                 clearTimeout(batchTimeout);
                 this.currentBatchAc = null;
                 this.processing = false;
-                if (this.pending.size > 0) {
+                if (!this.closed && this.pending.size > 0) {
                     if (backoffOverrideMs > 0) {
                         if (this.debounceTimer)
                             clearTimeout(this.debounceTimer);
-                        this.debounceTimer = setTimeout(() => this.processBatch(), backoffOverrideMs);
+                        this.debounceTimer = setTimeout(() => {
+                            this.debounceTimer = null;
+                            this.startBatch();
+                        }, backoffOverrideMs);
                     }
                     else {
                         this.scheduleBatch();

package/dist/lib/llm/tools.js

@@ -293,15 +293,15 @@ function executeImpact(args, ctx) {
         if (!target)
             return "(error: missing target)";
         const depth = clampDepth(args.depth);
-        const { symbols, resolvedAsFile } = yield (0, impact_1.resolveTargetSymbols)(target, ctx.vectorDb, ctx.projectRoot);
+        const { symbols, resolvedAsFile, symbolFamilies } = yield (0, impact_1.resolveTargetSymbols)(target, ctx.vectorDb, ctx.projectRoot);
         if (symbols.length === 0)
             return "(not found)";
         const excludePaths = resolvedAsFile
             ? new Set([path.resolve(ctx.projectRoot, target)])
             : undefined;
         const [deps, tests] = yield Promise.all([
-            (0, impact_1.findDependents)(symbols, ctx.vectorDb, ctx.projectRoot, excludePaths),
-            (0, impact_1.findTests)(symbols, ctx.vectorDb, ctx.projectRoot, depth),
+            (0, impact_1.findDependents)(symbols, ctx.vectorDb, ctx.projectRoot, excludePaths, undefined, undefined, symbolFamilies),
+            (0, impact_1.findTests)(symbols, ctx.vectorDb, ctx.projectRoot, depth, undefined, symbolFamilies),
         ]);
         if (deps.length === 0 && tests.length === 0)
             return "(no impact detected)";