codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

package/dist/src/retrieval-eval.js

@@ -1,11 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RetrievalEvaluator = exports.EvalSuiteError = void 0;
+exports.RetrievalEvaluator = exports.LIVE_GROUP = exports.EvalSuiteError = exports.STAGE_ORDER = void 0;
 exports.parseSuite = parseSuite;
+exports.corporaOf = corporaOf;
+exports.isUnderRoot = isUnderRoot;
+exports.checkCaseCorpora = checkCaseCorpora;
 exports.mergeSuites = mergeSuites;
+exports.signTest = signTest;
+exports.pairedChange = pairedChange;
+exports.formatThresholdConditions = formatThresholdConditions;
 exports.compare = compare;
 const zod_1 = require("zod");
-/** Thrown by `parseSuite` before any search runs — names the offending case and field. */
+const constants_1 = require("./constants");
+const eval_vector_index_1 = require("./eval-vector-index");
+const CATEGORIES = ['identifier', 'behaviour', 'concept'];
+exports.STAGE_ORDER = ['vector', 'reranked'];
+const STAGE_SOURCE = { reranked: 'vector' };
+const UNRANKED = 11;
 class EvalSuiteError extends Error {
     caseId;
     field;
@@ -29,11 +40,15 @@ const CaseSchema = zod_1.z.object({
     expect: zod_1.z.array(ExpectedAnswerSchema).min(1),
     threshold: zod_1.z.number().min(0).max(1).optional(),
 });
+const CorpusSchema = zod_1.z.object({
+    root: zod_1.z.string().min(1).refine(r => !r.startsWith('/') && !r.split('/').includes('..') && !r.endsWith('/'), 'must be a workspace-relative directory'),
+    commit: zod_1.z.string().regex(/^[0-9a-f]{40}$/, 'must be a full 40-hex commit SHA'),
+}).strict();
 const SuiteSchema = zod_1.z.object({
     version: zod_1.z.literal(1),
+    corpus: CorpusSchema.optional(),
     cases: zod_1.z.array(CaseSchema),
 });
-/** Best-effort id of the case at `cases[index]` in a raw (possibly invalid) object, for error messages. */
 function rawCaseId(raw, index) {
     if (typeof raw !== 'object' || raw === null)
         return null;
@@ -46,7 +61,6 @@ function rawCaseId(raw, index) {
     const id = entry.id;
     return typeof id === 'string' ? id : null;
 }
-/** Validates a loaded suite object against the schema; rejects before any search runs. */
 function parseSuite(raw) {
     const result = SuiteSchema.safeParse(raw);
     if (!result.success) {
@@ -64,10 +78,40 @@ function parseSuite(raw) {
         }
         seen.add(c.id);
     }
-    return result.data;
+    const corpus = result.data.corpus?.root ?? null;
+    return { ...result.data, cases: result.data.cases.map(c => ({ ...c, corpus })) };
+}
+function corporaOf(suites) {
+    const byRoot = new Map();
+    for (const suite of suites) {
+        if (!suite.corpus)
+            continue;
+        const prev = byRoot.get(suite.corpus.root);
+        if (prev && prev.commit !== suite.corpus.commit) {
+            throw new EvalSuiteError(`Corpus ${suite.corpus.root} is declared at two commits: ${prev.commit} and ${suite.corpus.commit}`, null, 'corpus');
+        }
+        byRoot.set(suite.corpus.root, { root: suite.corpus.root, commit: suite.corpus.commit });
+    }
+    return [...byRoot.values()].sort((a, b) => (a.root < b.root ? -1 : a.root > b.root ? 1 : 0));
+}
+function isUnderRoot(dir, root) {
+    return dir === root || dir.startsWith(root + '/');
+}
+async function checkCaseCorpora(cases, projectDir) {
+    for (const c of cases) {
+        if (!c.corpus)
+            continue;
+        const dir = await projectDir(c.project);
+        if (dir === null) {
+            throw new EvalSuiteError(`Project ${c.project} is not indexed, so it cannot be checked against corpus ${c.corpus} (case ${c.id}, field project)`, c.id, 'project');
+        }
+        if (!isUnderRoot(dir, c.corpus)) {
+            throw new EvalSuiteError(`Project ${c.project} (${dir}) is outside corpus ${c.corpus} (case ${c.id}, field project)`, c.id, 'project');
+        }
+    }
 }
-/** Merges several suites (already parsed) into one; case ids must be unique across all of them. */
 function mergeSuites(suites) {
+    corporaOf(suites);
     const cases = [];
     const seen = new Set();
     for (const suite of suites) {
@@ -80,7 +124,6 @@ function mergeSuites(suites) {
     }
     return { version: 1, cases };
 }
-/** `owner` matches exactly, or as a prefix at a `.` boundary (`RepairsService` accepts any member of the class). */
 function ownerMatches(ownerPath, expectedOwner) {
     return ownerPath === expectedOwner || ownerPath.startsWith(expectedOwner + '.');
 }
@@ -117,45 +160,219 @@ function rankOf(hits, valid) {
 function emptyMetrics() {
     return { count: 0, hit1: 0, hit5: 0, mrr10: 0 };
 }
-function accumulate(cases) {
-    const n = cases.length;
+function accumulate(ranks) {
+    const n = ranks.length;
     if (n === 0)
         return emptyMetrics();
     let hit1 = 0, hit5 = 0, mrrSum = 0;
-    for (const c of cases) {
-        if (c.rank === 1)
+    for (const rank of ranks) {
+        if (rank === 1)
             hit1++;
-        if (c.rank !== null && c.rank <= 5)
+        if (rank !== null && rank <= 5)
             hit5++;
-        mrrSum += c.rank !== null ? 1 / c.rank : 0;
+        mrrSum += rank !== null ? 1 / rank : 0;
     }
     return { count: n, hit1: hit1 / n, hit5: hit5 / n, mrr10: mrrSum / n };
 }
+function stageRank(c, stage) {
+    return c.stages[stage]?.rank ?? null;
+}
+function stageMetrics(cases, stage) {
+    const byCategory = {};
+    for (const category of CATEGORIES) {
+        const subset = cases.filter(c => c.category === category);
+        if (subset.length > 0)
+            byCategory[category] = accumulate(subset.map(c => stageRank(c, stage)));
+    }
+    return { overall: accumulate(cases.map(c => stageRank(c, stage))), byCategory };
+}
+function poolMetricsOf(cases) {
+    const count = cases.length;
+    return {
+        count,
+        recall: count === 0 ? 0 : cases.filter(c => c.poolRank !== null).length / count,
+        short: cases.filter(c => c.short).length,
+    };
+}
+function binomialCdfHalf(k, n) {
+    let pmf = Math.pow(0.5, n);
+    let cdf = pmf;
+    for (let i = 1; i <= k; i++) {
+        pmf = pmf * (n - i + 1) / i;
+        cdf += pmf;
+    }
+    return cdf;
+}
+function signTest(improved, worsened) {
+    const n = improved + worsened;
+    if (n === 0)
+        return 1;
+    return Math.min(1, 2 * binomialCdfHalf(Math.min(improved, worsened), n));
+}
+function pairCounts(pairs) {
+    let improved = 0, worsened = 0, unchanged = 0;
+    for (const p of pairs) {
+        if (p.to < p.from)
+            improved++;
+        else if (p.to > p.from)
+            worsened++;
+        else
+            unchanged++;
+    }
+    return { improved, worsened, unchanged, signTestP: signTest(improved, worsened) };
+}
+function pairedChange(from, to) {
+    const fromById = new Map(from.map(c => [c.id, c.rank]));
+    const pairs = [];
+    for (const c of to) {
+        if (!fromById.has(c.id))
+            continue;
+        pairs.push({ id: c.id, category: c.category, from: fromById.get(c.id) ?? UNRANKED, to: c.rank ?? UNRANKED });
+    }
+    const byCategory = {};
+    for (const category of CATEGORIES) {
+        const subset = pairs.filter(p => p.category === category);
+        if (subset.length > 0)
+            byCategory[category] = pairCounts(subset);
+    }
+    return {
+        overall: pairCounts(pairs),
+        byCategory,
+        hit5Gained: pairs.filter(p => p.from > 5 && p.to <= 5).map(p => p.id),
+        hit5Lost: pairs.filter(p => p.from <= 5 && p.to > 5).map(p => p.id),
+    };
+}
+function rankedCases(cases, stage) {
+    return cases.map(c => ({ id: c.id, category: c.category, rank: stageRank(c, stage) }));
+}
+function stageChangesOf(cases, stages) {
+    const changes = [];
+    for (const to of stages) {
+        const from = STAGE_SOURCE[to];
+        if (from && stages.includes(from)) {
+            changes.push({ from, to, change: pairedChange(rankedCases(cases, from), rankedCases(cases, to)) });
+        }
+    }
+    return changes;
+}
+function reportedStages(stages) {
+    return exports.STAGE_ORDER.filter(s => stages[s] !== undefined);
+}
+function sortedDistinct(values) {
+    return [...new Set(values)].sort((a, b) => {
+        if (a === b)
+            return 0;
+        if (a === null)
+            return -1;
+        if (b === null)
+            return 1;
+        return a < b ? -1 : 1;
+    });
+}
+exports.LIVE_GROUP = 'live';
+function runFigures(cases, stages, shortPool) {
+    const metrics = {};
+    for (const stage of stages)
+        metrics[stage] = stageMetrics(cases, stage);
+    const poolInput = (subset) => subset.map(c => ({ poolRank: c.poolRank, short: shortPool.get(c.id) }));
+    const poolByCategory = {};
+    for (const category of CATEGORIES) {
+        const subset = cases.filter(c => c.category === category);
+        if (subset.length > 0)
+            poolByCategory[category] = poolMetricsOf(poolInput(subset));
+    }
+    return {
+        cases: cases.length,
+        metrics,
+        pool: { overall: poolMetricsOf(poolInput(cases)), byCategory: poolByCategory },
+        stageChanges: stageChangesOf(cases, stages),
+    };
+}
+function distinctThresholds(pairs) {
+    const byKey = new Map(pairs.map(p => [`${p.value}|${p.source}`, p]));
+    return [...byKey.values()].sort((a, b) => b.value - a.value || a.source.localeCompare(b.source));
+}
+function formatThresholdConditions(pairs) {
+    return pairs.map(p => `${(0, constants_1.formatThreshold)(p.value)} (${p.source})`).join(', ') || '—';
+}
 class RetrievalEvaluator {
-    async evaluate(suite, search, inspect) {
+    async evaluate(suite, search, inspect, onCase) {
+        await checkCaseCorpora(suite.cases, p => inspect.projectDir(p));
         const cases = [];
+        const shortPool = new Map();
         const invalid = [];
         const warnings = [];
-        for (const c of suite.cases) {
+        const fetchLimits = [];
+        const efSearches = [];
+        const iterativeScans = [];
+        const thresholds = [];
+        let stages = null;
+        const total = suite.cases.length;
+        for (const [i, c] of suite.cases.entries()) {
+            const started = Date.now();
+            const report = (result, inv) => onCase?.({ index: i + 1, total, id: c.id, result, invalid: inv, ms: Date.now() - started });
             const { valid, invalid: invalidExpects } = await validateCase(c, inspect);
             if (valid.length === 0) {
-                invalid.push({ id: c.id, reason: 'no valid expected answer', invalidExpects });
+                const inv = { id: c.id, reason: 'no valid expected answer', invalidExpects };
+                invalid.push(inv);
+                report(null, inv);
                 continue;
             }
             if (invalidExpects.length > 0) {
                 warnings.push({ id: c.id, droppedExpects: invalidExpects });
             }
             const hits = await search(c.query, 10, c.project, c.threshold);
-            const { rank, matched } = rankOf(hits, valid);
-            cases.push({ id: c.id, project: c.project, category: c.category, query: c.query, rank, matched });
+            const caseStages = reportedStages(hits.stages);
+            if (stages === null) {
+                stages = caseStages;
+            }
+            else if (caseStages.join(',') !== stages.join(',')) {
+                throw new Error(`Case ${c.id} reported stages [${caseStages.join(', ')}], but the run's stages are [${stages.join(', ')}]`);
+            }
+            const ranks = {};
+            for (const stage of caseStages)
+                ranks[stage] = rankOf(hits.stages[stage], valid);
+            const result = {
+                id: c.id, project: c.project, category: c.category, query: c.query,
+                stages: ranks,
+                poolRank: rankOf(hits.pool, valid).rank,
+                poolSize: hits.pool.length,
+                rerankFailed: hits.rerankFailed,
+                corpus: c.corpus ?? null,
+            };
+            cases.push(result);
+            shortPool.set(c.id, hits.pool.length < hits.fetchLimit);
+            fetchLimits.push(hits.fetchLimit);
+            efSearches.push(hits.indexParams.efSearch);
+            iterativeScans.push(hits.indexParams.iterativeScan);
+            thresholds.push(hits.threshold);
+            report(result, null);
         }
-        const byCategory = {};
-        for (const category of ['identifier', 'behaviour', 'concept']) {
-            const subset = cases.filter(c => c.category === category);
-            if (subset.length > 0)
-                byCategory[category] = accumulate(subset);
+        const runStages = stages ?? ['vector'];
+        const figures = (subset) => runFigures(subset, runStages, shortPool);
+        const byCorpus = {};
+        for (const key of [...new Set(cases.map(c => c.corpus ?? exports.LIVE_GROUP))].sort()) {
+            byCorpus[key] = figures(cases.filter(c => (c.corpus ?? exports.LIVE_GROUP) === key));
         }
-        return { cases, invalid, warnings, metrics: { overall: accumulate(cases), byCategory } };
+        const all = figures(cases);
+        const observed = {
+            fetchLimit: sortedDistinct(fetchLimits),
+            efSearch: sortedDistinct(efSearches),
+            iterativeScan: sortedDistinct(iterativeScans),
+            thresholds: distinctThresholds(thresholds),
+        };
+        return {
+            run: {
+                cases, invalid, warnings,
+                stages: runStages,
+                metrics: all.metrics,
+                pool: all.pool,
+                stageChanges: all.stageChanges,
+                rerankFailures: cases.filter(c => c.rerankFailed).length,
+                byCorpus,
+            },
+            observed,
+        };
     }
 }
 exports.RetrievalEvaluator = RetrievalEvaluator;
@@ -170,45 +387,157 @@ function metricsDelta(baseline, current) {
         mrr10: metricDelta(baseline.mrr10, current.mrr10),
     };
 }
-/** Pure comparison of two result files; prints a warning (never refuses) on mismatched conditions. */
-function compare(baseline, current) {
-    const conditionWarnings = [];
-    if (baseline.metadata.suiteHash !== current.metadata.suiteHash) {
-        conditionWarnings.push(`suite differs: baseline ${baseline.metadata.suiteHash} vs current ${current.metadata.suiteHash}`);
+function metricsDeltaByCategory(baseline, current) {
+    const out = {};
+    for (const category of CATEGORIES) {
+        const b = baseline[category];
+        const cur = current[category];
+        if (b && cur)
+            out[category] = metricsDelta(b, cur);
+    }
+    return out;
+}
+function poolValueDelta(baseline, current) {
+    return { baseline, current, delta: baseline === null ? null : current - baseline };
+}
+function poolDelta(baseline, current) {
+    return {
+        recall: poolValueDelta(baseline?.recall ?? null, current.recall),
+        short: poolValueDelta(baseline?.short ?? null, current.short),
+    };
+}
+function isThresholdCondition(v) {
+    return typeof v === 'object' && v !== null && 'value' in v && 'source' in v;
+}
+function formatCondition(value) {
+    if (!Array.isArray(value))
+        return String(value);
+    if (value.length > 0 && value.every(isThresholdCondition))
+        return `[${formatThresholdConditions(value)}]`;
+    return `[${value.map(v => (v === null ? 'not sent' : String(v))).join(', ')}]`;
+}
+function conditionKey(value) {
+    return JSON.stringify(Array.isArray(value) ? value.map(v => JSON.stringify(v)).sort() : value);
+}
+function corpusWarningsOf(b, cur) {
+    const warnings = [];
+    if (b.corpora.length === 0)
+        warnings.push('baseline records no corpus');
+    const baseByRoot = new Map(b.corpora.map(c => [c.root, c]));
+    const curByRoot = new Map(cur.corpora.map(c => [c.root, c]));
+    for (const root of [...new Set([...baseByRoot.keys(), ...curByRoot.keys()])].sort()) {
+        const bc = baseByRoot.get(root), cc = curByRoot.get(root);
+        if (!bc) {
+            warnings.push(`corpus ${root} only in the current run`);
+            continue;
+        }
+        if (!cc) {
+            warnings.push(`corpus ${root} only in the baseline`);
+            continue;
+        }
+        if (bc.commit !== cc.commit) {
+            warnings.push(`corpus ${root} commit differs: baseline ${bc.commit} vs current ${cc.commit}`);
+        }
+        else if (bc.fingerprint !== cc.fingerprint) {
+            warnings.push(`corpus ${root} was searched on a different index build: fingerprint ${bc.fingerprint} (${bc.chunks} chunks) vs ${cc.fingerprint} (${cc.chunks} chunks)`);
+        }
+    }
+    const live = (side, n) => `${side} includes ${n} live-corpus case(s); differences may come from code changes`;
+    if (b.liveCases > 0)
+        warnings.push(live('baseline', b.liveCases));
+    if (cur.liveCases > 0)
+        warnings.push(live('current run', cur.liveCases));
+    return warnings;
+}
+function vectorIndexWarningsOf(b, cur) {
+    if (!b.vectorIndex || !cur.vectorIndex) {
+        return [...(b.vectorIndex ? [] : ['baseline records no vector index']), ...(cur.vectorIndex ? [] : ['current run records no vector index'])];
     }
-    if (baseline.metadata.embeddingModel !== current.metadata.embeddingModel) {
-        conditionWarnings.push(`embedding model differs: baseline ${baseline.metadata.embeddingModel} vs current ${current.metadata.embeddingModel}`);
+    const warnings = [];
+    if (b.vectorIndex.pgvector !== cur.vectorIndex.pgvector) {
+        warnings.push(`pgvector differs: baseline ${b.vectorIndex.pgvector ?? 'not installed'} vs current ${cur.vectorIndex.pgvector ?? 'not installed'}`);
     }
-    if (baseline.metadata.rerankerModel !== current.metadata.rerankerModel) {
-        conditionWarnings.push(`reranker differs: baseline ${baseline.metadata.rerankerModel ?? 'none'} vs current ${current.metadata.rerankerModel ?? 'none'}`);
+    if (JSON.stringify(b.vectorIndex.indexes) !== JSON.stringify(cur.vectorIndex.indexes)) {
+        warnings.push(`vector index differs: baseline ${(0, eval_vector_index_1.formatIndexes)(b.vectorIndex)} vs current ${(0, eval_vector_index_1.formatIndexes)(cur.vectorIndex)}`);
     }
-    const byCategory = {};
-    for (const category of ['identifier', 'behaviour', 'concept']) {
-        const b = baseline.run.metrics.byCategory[category];
-        const cur = current.run.metrics.byCategory[category];
-        if (b && cur)
-            byCategory[category] = metricsDelta(b, cur);
-    }
-    const baselineRanked = new Map(baseline.run.cases.map(c => [c.id, c.rank]));
-    const currentRanked = new Map(current.run.cases.map(c => [c.id, c.rank]));
-    const hit5Gained = [];
-    const hit5Lost = [];
-    const allIds = new Set([...baselineRanked.keys(), ...currentRanked.keys()]);
-    for (const id of allIds) {
-        const b = baselineRanked.get(id) ?? null;
-        const cur = currentRanked.get(id) ?? null;
-        const bHit5 = b !== null && b <= 5;
-        const curHit5 = cur !== null && cur <= 5;
-        if (!bHit5 && curHit5)
-            hit5Gained.push(id);
-        if (bHit5 && !curHit5)
-            hit5Lost.push(id);
+    const settings = [['hnsw.max_scan_tuples', 'maxScanTuples'], ['hnsw.scan_mem_multiplier', 'scanMemMultiplier']];
+    for (const [name, key] of settings) {
+        if (b.vectorIndex[key] !== cur.vectorIndex[key]) {
+            warnings.push(`${name} differs: baseline ${b.vectorIndex[key] ?? 'not defined'} vs current ${cur.vectorIndex[key] ?? 'not defined'}`);
+        }
+    }
+    return warnings;
+}
+function conditionWarningsOf(baseline, current) {
+    const warnings = [];
+    const b = baseline.metadata, cur = current.metadata;
+    if (b.suiteHash !== cur.suiteHash) {
+        warnings.push(`suite differs: baseline ${b.suiteHash} vs current ${cur.suiteHash}`);
+    }
+    if (b.embeddingModel !== cur.embeddingModel) {
+        warnings.push(`embedding model differs: baseline ${b.embeddingModel} vs current ${cur.embeddingModel}`);
+    }
+    if (b.rerankerModel !== cur.rerankerModel) {
+        warnings.push(`reranker differs: baseline ${b.rerankerModel ?? 'none'} vs current ${cur.rerankerModel ?? 'none'}`);
+    }
+    if (!b.conditions)
+        warnings.push('baseline records no search conditions');
+    if (!cur.conditions)
+        warnings.push('current run records no search conditions');
+    if (b.conditions && cur.conditions) {
+        const bc = b.conditions;
+        const cc = cur.conditions;
+        for (const key of [...new Set([...Object.keys(bc), ...Object.keys(cc)])]) {
+            if (!(key in bc))
+                warnings.push(`search condition ${key} recorded only by the current run (${formatCondition(cc[key])})`);
+            else if (!(key in cc))
+                warnings.push(`search condition ${key} recorded only by the baseline (${formatCondition(bc[key])})`);
+            else if (conditionKey(bc[key]) !== conditionKey(cc[key])) {
+                warnings.push(`${key} differs: baseline ${formatCondition(bc[key])} vs current ${formatCondition(cc[key])}`);
+            }
+        }
+    }
+    warnings.push(...vectorIndexWarningsOf(b, cur));
+    warnings.push(...corpusWarningsOf(b, cur));
+    if (baseline.run.rerankFailures > 0)
+        warnings.push(`baseline has ${baseline.run.rerankFailures} rerank failure(s)`);
+    if (current.run.rerankFailures > 0)
+        warnings.push(`current run has ${current.run.rerankFailures} rerank failure(s)`);
+    return warnings;
+}
+function compare(baseline, current) {
+    const stages = [];
+    for (const stage of current.run.stages) {
+        const b = baseline.run.metrics[stage];
+        const cur = current.run.metrics[stage];
+        if (!baseline.run.stages.includes(stage) || !b || !cur)
+            continue;
+        stages.push({
+            stage,
+            overall: metricsDelta(b.overall, cur.overall),
+            byCategory: metricsDeltaByCategory(b.byCategory, cur.byCategory),
+            change: pairedChange(rankedCases(baseline.run.cases, stage), rankedCases(current.run.cases, stage)),
+        });
+    }
+    const unmatchedStages = [
+        ...baseline.run.stages.filter(s => !current.run.stages.includes(s)).map(stage => ({ stage, side: 'baseline' })),
+        ...current.run.stages.filter(s => !baseline.run.stages.includes(s)).map(stage => ({ stage, side: 'current' })),
+    ];
+    const basePool = baseline.legacy ? null : baseline.run.pool;
+    const poolByCategory = {};
+    for (const category of CATEGORIES) {
+        const cur = current.run.pool.byCategory[category];
+        if (!cur)
+            continue;
+        if (basePool === null)
+            poolByCategory[category] = poolDelta(null, cur);
+        else if (basePool.byCategory[category])
+            poolByCategory[category] = poolDelta(basePool.byCategory[category], cur);
     }
     return {
-        overall: metricsDelta(baseline.run.metrics.overall, current.run.metrics.overall),
-        byCategory,
-        hit5Gained,
-        hit5Lost,
-        conditionWarnings,
+        stages,
+        unmatchedStages,
+        pool: { overall: poolDelta(basePool?.overall ?? null, current.run.pool.overall), byCategory: poolByCategory },
+        conditionWarnings: conditionWarningsOf(baseline, current),
     };
 }

package/dist/src/search/CallGraph.d.ts

@@ -0,0 +1,9 @@
+import type { IDatabase, ILogger } from '../interfaces';
+import type { CallerRow, ICallGraph, NoCallersCause } from '../interfaces/ICallGraph';
+export declare class CallGraph implements ICallGraph {
+    private db;
+    private logger;
+    constructor(db: IDatabase, logger: ILogger);
+    getCallers(symbol: string, project: string, calleeFile?: string | null): Promise<CallerRow[]>;
+    explainNoCallers(symbol: string, project: string): Promise<NoCallersCause>;
+}

package/dist/src/search/CallGraph.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallGraph = void 0;
+const symbol_name_1 = require("../symbol-name");
+const symbol_sql_1 = require("./symbol-sql");
+const NO_CALLERS_LIST_LIMIT = 5;
+class CallGraph {
+    db;
+    logger;
+    constructor(db, logger) {
+        this.db = db;
+        this.logger = logger;
+    }
+    async getCallers(symbol, project, calleeFile = null) {
+        const t0 = Date.now();
+        this.logger.debug('CallGraph: getCallers', { symbol, project, calleeFile });
+        const parsed = (0, symbol_name_1.parseCallerSymbol)(symbol);
+        if (!parsed)
+            throw new Error('Invalid symbol name');
+        const params = [project];
+        let nameFilter;
+        if (parsed.form === 'bare') {
+            params.push(parsed.name);
+            nameFilter = `"calleeName" = $${params.length}`;
+        }
+        else {
+            params.push(`${parsed.container}.${parsed.name}`);
+            const exactParam = params.length;
+            params.push(`%.${(0, symbol_name_1.escapeLike)(parsed.container)}.${(0, symbol_name_1.escapeLike)(parsed.name)}`);
+            const suffixParam = params.length;
+            nameFilter = `("calleeSymbol" = $${exactParam} OR "calleeSymbol" LIKE $${suffixParam} ESCAPE '\\')`;
+        }
+        let fileFilter = '';
+        if (calleeFile) {
+            params.push(calleeFile);
+            fileFilter = `AND "calleeFile" = $${params.length}`;
+        }
+        const rows = await this.db.query(`SELECT "fromFile", "fromSymbol", "calleeName", "calleeFile", line
+       FROM code_call
+       WHERE project = $1 AND ${nameFilter}
+       ${fileFilter}
+       ORDER BY "fromFile", line
+       LIMIT 200`, params);
+        this.logger.debug('CallGraph: getCallers result', { count: rows.length, ms: Date.now() - t0 });
+        return rows;
+    }
+    async explainNoCallers(symbol, project) {
+        const t0 = Date.now();
+        const parsed = (0, symbol_name_1.parseCallerSymbol)(symbol);
+        if (!parsed)
+            throw new Error('Invalid symbol name');
+        const container = parsed.form === 'qualified' ? parsed.container : null;
+        try {
+            const calls = await this.db.query(`SELECT EXISTS (SELECT 1 FROM code_call WHERE project = $1) AS present`, [project]);
+            if (!calls[0]?.present)
+                return { kind: 'no-call-graph' };
+            const params = [project];
+            const match = (0, symbol_sql_1.symbolMatch)(parsed.name, container, params);
+            params.push(NO_CALLERS_LIST_LIMIT + 1);
+            const definitions = await this.db.query(`SELECT "filePath", line, qualified
+         FROM (
+           SELECT DISTINCT "filePath", line, ${symbol_sql_1.QUALIFIED_SQL} AS qualified${match.exactRank ? `, ${match.exactRank} AS exact_rank` : ''}
+           FROM code_symbol
+           WHERE project = $1 AND ${match.filter}
+         ) AS definitions
+         ORDER BY ${match.exactRank ? 'exact_rank, ' : ''}"filePath", line, qualified COLLATE "C"
+         LIMIT $${params.length}`, params);
+            if (definitions.length > 0) {
+                return {
+                    kind: 'no-recorded-calls',
+                    definitions: definitions.slice(0, NO_CALLERS_LIST_LIMIT).map(({ qualified, filePath, line }) => ({ qualified, filePath, line })),
+                    truncated: definitions.length > NO_CALLERS_LIST_LIMIT,
+                };
+            }
+            const { names, truncated } = await (0, symbol_sql_1.similarSymbolNames)(this.db, parsed.name, project, false);
+            return { kind: 'unknown-symbol', suggestions: names, truncated };
+        }
+        catch (err) {
+            this.logger.warn('CallGraph: explainNoCallers lookup failed', { err, symbol, project, ms: Date.now() - t0 });
+            return { kind: 'lookup-failed' };
+        }
+    }
+}
+exports.CallGraph = CallGraph;

package/dist/src/search/ChunkSearch.d.ts

@@ -0,0 +1,23 @@
+import type { Config } from '../config';
+import type { IDatabase, IEmbedder, ILogger } from '../interfaces';
+import type { IChunkSearch, NeighborResult, NoResultsCause, SearchResult, StagedSearchResult } from '../interfaces/IChunkSearch';
+import type { IndexIdentityGuard } from './IndexIdentityGuard';
+export declare class ChunkSearch implements IChunkSearch {
+    private db;
+    private embedder;
+    private identityGuard;
+    private config;
+    private logger;
+    private readonly gate;
+    private readonly fetcher;
+    private readonly rerankStage;
+    constructor(db: IDatabase, embedder: IEmbedder, identityGuard: IndexIdentityGuard, config: Config, logger: ILogger);
+    prepareQuery(raw: string): Promise<{
+        query: string;
+        translated: boolean;
+    }>;
+    searchChunks(query: string, limit: number, project: string | null, threshold?: number, rerankOverride?: boolean, perFile?: number): Promise<SearchResult[]>;
+    searchChunksWithStages(query: string, limit: number, project: string | null, threshold?: number, rerankOverride?: boolean, perFile?: number): Promise<StagedSearchResult>;
+    fetchNeighbors(results: SearchResult[]): Promise<NeighborResult[]>;
+    explainNoResults(project: string | null): Promise<NoResultsCause>;
+}