codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

package/dist/src/chunking/ImportOnlyFilter.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportOnlyFilter = void 0;
+class ImportOnlyFilter {
+    process(pieces, ctx) {
+        return pieces.filter((p) => {
+            if (!ctx.lines.isImportOnly(p.startLine, p.endLine))
+                return true;
+            ctx.removed.push({ start: p.startLine, end: p.endLine });
+            return false;
+        });
+    }
+}
+exports.ImportOnlyFilter = ImportOnlyFilter;

package/dist/src/chunking/LangchainTextSplitter.d.ts

@@ -0,0 +1,21 @@
+import type { Config } from '../config';
+import type { ChunkPiece } from '../interfaces/IChunker';
+import type { ITextSplitter, KeepWindow } from './interfaces';
+export interface SplitterOptions {
+    chunkSize: number;
+    chunkOverlap: number;
+    separators: string[];
+}
+export declare class LangchainTextSplitter implements ITextSplitter {
+    private readonly opts;
+    constructor(opts: SplitterOptions);
+    static forJs(config: Config): LangchainTextSplitter;
+    static forSchema(config: Config): LangchainTextSplitter;
+    split(text: string, firstLine: number, keep?: KeepWindow): Promise<ChunkPiece[]>;
+    private splitSpan;
+    private static splitOn;
+    private static joinKept;
+    private merge;
+    private static trim;
+    private static newlines;
+}

package/dist/src/chunking/LangchainTextSplitter.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LangchainTextSplitter = void 0;
+const textsplitters_1 = require("@langchain/textsplitters");
+class LangchainTextSplitter {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+        if (opts.chunkOverlap >= opts.chunkSize)
+            throw new Error('Cannot have chunkOverlap >= chunkSize');
+    }
+    static forJs(config) {
+        return new LangchainTextSplitter({
+            chunkSize: config.indexer.chunkSize,
+            chunkOverlap: config.indexer.chunkOverlap,
+            separators: textsplitters_1.RecursiveCharacterTextSplitter.getSeparatorsForLanguage('js'),
+        });
+    }
+    static forSchema(config) {
+        return new LangchainTextSplitter({
+            chunkSize: config.indexer.chunkSize,
+            chunkOverlap: config.indexer.chunkOverlap,
+            separators: ['\n\n', '\n', ' '],
+        });
+    }
+    async split(text, firstLine, keep = { from: 0, to: 0 }) {
+        const pieces = [];
+        let offset = 0;
+        let line = firstLine;
+        for (const span of this.splitSpan(text, { start: 0, end: text.length }, this.opts.separators, keep)) {
+            line += LangchainTextSplitter.newlines(text, offset, span.start);
+            offset = span.start;
+            const content = text.slice(span.start, span.end);
+            pieces.push({ content, startLine: line, endLine: line + LangchainTextSplitter.newlines(content, 0, content.length) });
+        }
+        return pieces;
+    }
+    splitSpan(text, span, separators, keep) {
+        const sub = text.slice(span.start, span.end);
+        let separator = separators[separators.length - 1];
+        let next;
+        for (let i = 0; i < separators.length; i++) {
+            if (separators[i] === '') {
+                separator = '';
+                break;
+            }
+            if (sub.includes(separators[i])) {
+                separator = separators[i];
+                next = separators.slice(i + 1);
+                break;
+            }
+        }
+        const out = [];
+        let good = [];
+        const splits = LangchainTextSplitter.splitOn(sub, separator, span.start);
+        for (const s of separator ? LangchainTextSplitter.joinKept(splits, keep) : splits) {
+            if (s.end - s.start < this.opts.chunkSize) {
+                good.push(s);
+                continue;
+            }
+            if (good.length) {
+                out.push(...this.merge(text, good));
+                good = [];
+            }
+            out.push(...(next ? this.splitSpan(text, s, next, keep) : [s]));
+        }
+        if (good.length)
+            out.push(...this.merge(text, good));
+        return out;
+    }
+    static splitOn(sub, separator, base) {
+        const parts = separator
+            ? sub.split(new RegExp(`(?=${separator.replace(/[/\-\\^$*+?.()|[\]{}]/g, '\\$&')})`))
+            : sub.split('');
+        const spans = [];
+        let at = base;
+        for (const p of parts) {
+            if (p !== '')
+                spans.push({ start: at, end: at + p.length });
+            at += p.length;
+        }
+        return spans;
+    }
+    static joinKept(splits, keep) {
+        const out = [];
+        for (const s of splits) {
+            if (out.length && s.start > keep.from && s.start <= keep.to)
+                out[out.length - 1] = { start: out[out.length - 1].start, end: s.end };
+            else
+                out.push(s);
+        }
+        return out;
+    }
+    merge(text, splits) {
+        const { chunkSize, chunkOverlap } = this.opts;
+        const docs = [];
+        const current = [];
+        let total = 0;
+        const flush = () => {
+            const doc = LangchainTextSplitter.trim(text, { start: current[0].start, end: current[current.length - 1].end });
+            if (doc)
+                docs.push(doc);
+        };
+        for (const d of splits) {
+            const len = d.end - d.start;
+            if (total + len > chunkSize && current.length > 0) {
+                flush();
+                while (total > chunkOverlap || (total + len > chunkSize && total > 0)) {
+                    total -= current[0].end - current[0].start;
+                    current.shift();
+                }
+            }
+            current.push(d);
+            total += len;
+        }
+        if (current.length > 0)
+            flush();
+        return docs;
+    }
+    static trim(text, span) {
+        let { start, end } = span;
+        while (start < end && /\s/.test(text[start]))
+            start++;
+        while (end > start && /\s/.test(text[end - 1]))
+            end--;
+        return start < end ? { start, end } : null;
+    }
+    static newlines(text, from, to) {
+        const count = (a, b) => (text.slice(a, b).match(/\n/g) ?? []).length;
+        return to >= from ? count(from, to) : -count(to, from);
+    }
+}
+exports.LangchainTextSplitter = LangchainTextSplitter;

package/dist/src/chunking/MinSizeSplitPolicy.d.ts

@@ -0,0 +1,9 @@
+import type { DeclarationNode } from '../declarations/DeclarationTree';
+import type { SourceLines } from '../declarations/SourceLines';
+import type { ISplitPolicy } from './interfaces';
+export declare const MIN_MEMBER_CHARS = 200;
+export declare class MinSizeSplitPolicy implements ISplitPolicy {
+    private readonly minChars;
+    constructor(minChars?: number);
+    isSplitPoint(child: DeclarationNode, siblings: DeclarationNode[], parent: DeclarationNode | null, lines: SourceLines): boolean;
+}

package/dist/src/chunking/MinSizeSplitPolicy.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinSizeSplitPolicy = exports.MIN_MEMBER_CHARS = void 0;
+exports.MIN_MEMBER_CHARS = 200;
+class MinSizeSplitPolicy {
+    minChars;
+    constructor(minChars = exports.MIN_MEMBER_CHARS) {
+        this.minChars = minChars;
+    }
+    isSplitPoint(child, siblings, parent, lines) {
+        if (lines.length(child.start, child.end) < this.minChars)
+            return false;
+        if (parent && (child.start <= parent.nameLine || child.end >= parent.end))
+            return false;
+        return !siblings.some(s => s !== child && s.start <= child.end && child.start <= s.end);
+    }
+}
+exports.MinSizeSplitPolicy = MinSizeSplitPolicy;

package/dist/src/chunking/RunPacker.d.ts

@@ -0,0 +1,12 @@
+import type { ChunkPiece } from '../interfaces/IChunker';
+import type { DeclarationNode } from '../declarations/DeclarationTree';
+import type { LineRange, SourceLines } from '../declarations/SourceLines';
+import type { ITextSplitter } from './interfaces';
+export declare class RunPacker {
+    private readonly splitter;
+    constructor(splitter: ITextSplitter);
+    pack(run: LineRange, children: DeclarationNode[], lines: SourceLines, chunkSize: number, characterSplit?: LineRange[], owner?: DeclarationNode | null): Promise<ChunkPiece[]>;
+    private static leadWindow;
+    static units(run: LineRange, children: DeclarationNode[]): LineRange[];
+    static piece(range: LineRange, lines: SourceLines): ChunkPiece[];
+}

package/dist/src/chunking/RunPacker.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunPacker = void 0;
+class RunPacker {
+    splitter;
+    constructor(splitter) {
+        this.splitter = splitter;
+    }
+    async pack(run, children, lines, chunkSize, characterSplit = [], owner = null) {
+        const pieces = [];
+        let current = null;
+        const flush = () => {
+            if (current)
+                pieces.push(...RunPacker.piece(current, lines));
+            current = null;
+        };
+        for (const unit of RunPacker.units(run, children)) {
+            if (lines.length(unit.start, unit.end) > chunkSize) {
+                flush();
+                characterSplit.push(unit);
+                const keep = RunPacker.leadWindow(unit, [owner, ...children], lines, chunkSize);
+                pieces.push(...await this.splitter.split(lines.slice(unit.start, unit.end), unit.start, keep));
+                continue;
+            }
+            if (current && lines.length(current.start, unit.end) <= chunkSize) {
+                current.end = unit.end;
+                continue;
+            }
+            flush();
+            current = { ...unit };
+        }
+        flush();
+        return pieces;
+    }
+    static leadWindow(unit, nodes, lines, chunkSize) {
+        const lead = nodes.find(n => n !== null && n.start === unit.start && n.nameLine > unit.start);
+        if (!lead)
+            return undefined;
+        const to = lines.length(unit.start, lead.nameLine - 1);
+        if (lines.length(unit.start, lead.nameLine) < chunkSize)
+            return { from: 0, to };
+        let first = unit.start;
+        while (first < lead.nameLine && (lines.isBlank(first) || lines.isCommentOnly(first)))
+            first++;
+        if (first === lead.nameLine || 1 + lines.length(first, lead.nameLine) >= chunkSize)
+            return undefined;
+        return { from: lines.length(unit.start, first - 1), to };
+    }
+    static units(run, children) {
+        const inside = children
+            .filter(c => c.end >= run.start && c.start <= run.end)
+            .sort((a, b) => a.start - b.start);
+        const units = [];
+        let cursor = run.start;
+        for (let i = 0; i < inside.length;) {
+            const start = Math.max(inside[i].start, run.start);
+            let end = Math.min(inside[i].end, run.end);
+            let j = i + 1;
+            while (j < inside.length && inside[j].start <= end) {
+                end = Math.min(Math.max(end, inside[j].end), run.end);
+                j++;
+            }
+            if (cursor < start)
+                units.push({ start: cursor, end: start - 1 });
+            units.push({ start, end });
+            cursor = end + 1;
+            i = j;
+        }
+        if (cursor <= run.end)
+            units.push({ start: cursor, end: run.end });
+        return units;
+    }
+    static piece(range, lines) {
+        let { start, end } = range;
+        while (start <= end && lines.isBlank(start))
+            start++;
+        while (end >= start && lines.isBlank(end))
+            end--;
+        if (start > end)
+            return [];
+        return [{ content: lines.slice(start, end), startLine: start, endLine: end }];
+    }
+}
+exports.RunPacker = RunPacker;

package/dist/src/chunking/create-chunker.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from '../config';
+import { AstChunker } from './AstChunker';
+export declare function createChunker(config: Config): AstChunker;

package/dist/src/chunking/create-chunker.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createChunker = createChunker;
+const AstChunker_1 = require("./AstChunker");
+const CharacterChunkStrategy_1 = require("./CharacterChunkStrategy");
+const DeclarationChunkStrategy_1 = require("./DeclarationChunkStrategy");
+const FragmentMerger_1 = require("./FragmentMerger");
+const ImportOnlyFilter_1 = require("./ImportOnlyFilter");
+const LangchainTextSplitter_1 = require("./LangchainTextSplitter");
+const MinSizeSplitPolicy_1 = require("./MinSizeSplitPolicy");
+const RunPacker_1 = require("./RunPacker");
+function createChunker(config) {
+    const jsSplitter = LangchainTextSplitter_1.LangchainTextSplitter.forJs(config);
+    return new AstChunker_1.AstChunker(new DeclarationChunkStrategy_1.DeclarationChunkStrategy(new MinSizeSplitPolicy_1.MinSizeSplitPolicy(), new RunPacker_1.RunPacker(jsSplitter)), new CharacterChunkStrategy_1.CharacterChunkStrategy(jsSplitter, LangchainTextSplitter_1.LangchainTextSplitter.forSchema(config)), [new ImportOnlyFilter_1.ImportOnlyFilter()], [new FragmentMerger_1.FragmentMerger()], config);
+}

package/dist/src/chunking/interfaces.d.ts

@@ -0,0 +1,27 @@
+import type { ChunkOpts, ChunkPiece } from '../interfaces/IChunker';
+import type { DeclarationNode, DeclarationTree } from '../declarations/DeclarationTree';
+import type { LineRange, SourceLines } from '../declarations/SourceLines';
+export interface ChunkContext {
+    lines: SourceLines;
+    declarations: DeclarationTree;
+    chunkSize: number;
+    removed: LineRange[];
+    splitPoints: LineRange[];
+    characterSplit: LineRange[];
+}
+export interface IChunkStrategy {
+    chunk(ctx: ChunkContext, opts: ChunkOpts): Promise<ChunkPiece[]>;
+}
+export interface ISplitPolicy {
+    isSplitPoint(child: DeclarationNode, siblings: DeclarationNode[], parent: DeclarationNode | null, lines: SourceLines): boolean;
+}
+export interface KeepWindow {
+    from: number;
+    to: number;
+}
+export interface ITextSplitter {
+    split(text: string, firstLine: number, keep?: KeepWindow): Promise<ChunkPiece[]>;
+}
+export interface IChunkPostProcessor {
+    process(pieces: ChunkPiece[], ctx: ChunkContext): ChunkPiece[];
+}

package/dist/src/commands/ConfigCommand.js

@@ -72,7 +72,6 @@ class ConfigCommand {
             console.log(`No config found at ${config_store_1.CONFIG_FILE}. Run rag-setup.`);
             return;
         }
-        // redact password for display
         const display = JSON.parse(JSON.stringify(cfg));
         if (display.db?.password !== undefined)
             display.db.password = '***';
@@ -131,24 +130,18 @@ class ConfigCommand {
         }
     }
     edit() {
-        // Ensure config + schema exist so the editor has something to open and
-        // resolve the schema against.
         try {
             if (!fs.existsSync(config_store_1.CONFIG_FILE)) {
                 (0, config_store_1.writeConfigJson)({});
             }
             else {
                 (0, config_store_1.writeSchemaFile)();
-                // Migrate existing configs: re-add the "$schema" reference if absent
-                // (rewrite through writeConfigJson) so editors bind to the schema.
-                // Skip silently if the file is currently invalid — the user will fix
-                // it in the editor and validation runs on save.
                 try {
                     const cfg = (0, config_store_1.readConfigJson)();
                     if (cfg)
                         (0, config_store_1.writeConfigJson)(cfg);
                 }
-                catch { /* invalid file — leave as-is for the user to edit */ }
+                catch { }
             }
         }
         catch (e) {
@@ -164,7 +157,6 @@ class ConfigCommand {
             console.error('Set $EDITOR or edit the file directly: ' + config_store_1.CONFIG_FILE);
             process.exit(1);
         }
-        // Validate what the user saved; readConfigJson throws with a helpful message.
         try {
             (0, config_store_1.readConfigJson)();
             console.log('Config OK');

package/dist/src/commands/EvalCommand.d.ts

@@ -1,10 +1,15 @@
-import type { Container } from '../container';
+import type { Config } from '../config';
+import type { IDatabase, IChunkSearch, IProjectCatalog } from '../interfaces';
 import type { ICommand } from './ICommand';
+import type { ICorpusInspector } from '../interfaces/ICorpusInspector';
 export declare class EvalCommand implements ICommand {
-    private container;
+    private db;
+    private chunks;
+    private catalog;
+    private config;
     private argv1;
-    constructor(container: Container, argv1: string);
+    private corpusInspector;
+    private resultsDir;
+    constructor(db: IDatabase, chunks: IChunkSearch, catalog: IProjectCatalog, config: Config, argv1: string, corpusInspector?: ICorpusInspector, resultsDir?: string);
     execute(): Promise<void>;
-    private printSummary;
-    private printComparison;
 }

package/dist/src/commands/EvalCommand.js

@@ -36,93 +36,53 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EvalCommand = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const crypto = __importStar(require("crypto"));
-const child_process_1 = require("child_process");
 const retrieval_eval_1 = require("../retrieval-eval");
 const eval_results_1 = require("../eval-results");
-const DEFAULT_SUITE_DIR = path.join('benchmarks', 'eval');
+const eval_corpus_1 = require("../eval-corpus");
+const eval_vector_index_1 = require("../eval-vector-index");
+const constants_1 = require("../constants");
+const eval_args_1 = require("./eval/eval-args");
+const suite_loader_1 = require("./eval/suite-loader");
+const eval_corpora_1 = require("./eval/eval-corpora");
+const index_inspector_1 = require("./eval/index-inspector");
+const staged_search_1 = require("./eval/staged-search");
+const eval_metadata_1 = require("./eval/eval-metadata");
+const baseline_comparison_1 = require("./eval/baseline-comparison");
 const RESULTS_DIR_NAME = path.join('benchmarks', 'results');
-// Resolves to the repo root in both `ts-node app.ts` (one level above `src/`) and
-// the compiled `dist/` layout (two levels above `dist/src/commands/`).
 const _projectRoot = fs.existsSync(path.join(__dirname, '..', '..', 'package.json'))
     ? path.join(__dirname, '..', '..')
     : path.join(__dirname, '..', '..', '..');
-function gitCommit() {
-    try {
-        return (0, child_process_1.execFileSync)('git', ['rev-parse', 'HEAD'], { cwd: _projectRoot, encoding: 'utf-8' }).trim();
-    }
-    catch {
-        return 'unknown';
-    }
-}
-function hashContent(text) {
-    return crypto.createHash('sha256').update(text).digest('hex').slice(0, 16);
-}
-/** `--suite <path>` — a file or a directory of `*.json` suite files (default: `benchmarks/eval/`). */
-function parseSuiteFlag(args) {
-    const i = args.indexOf('--suite');
-    if (i === -1)
-        return DEFAULT_SUITE_DIR;
-    const next = args[i + 1];
-    if (next === undefined || next.startsWith('-'))
-        throw new Error('--suite requires a path');
-    return next;
-}
-function parseBaselineFlag(args) {
-    const i = args.indexOf('--baseline');
-    if (i === -1)
-        return null;
-    const next = args[i + 1];
-    if (next === undefined || next.startsWith('-'))
-        throw new Error('--baseline requires a path');
-    return next;
-}
-function parseProjectFlag(args) {
-    const i = args.indexOf('--project');
-    if (i === -1)
-        return null;
-    const next = args[i + 1];
-    if (next === undefined || next.startsWith('-'))
-        throw new Error('--project requires a name');
-    return next;
-}
-/** Loads one suite file, or every `*.json` file directly under a directory, merged into one. */
-function loadSuite(suitePath) {
-    const resolved = path.resolve(_projectRoot, suitePath);
-    const stat = fs.statSync(resolved);
-    if (stat.isDirectory()) {
-        const files = fs.readdirSync(resolved).filter(f => f.endsWith('.json')).sort();
-        const parts = files.map(f => fs.readFileSync(path.join(resolved, f), 'utf-8'));
-        const suites = parts.map(text => (0, retrieval_eval_1.parseSuite)(JSON.parse(text)));
-        return { suite: (0, retrieval_eval_1.mergeSuites)(suites), rawContent: parts.join('\n'), label: 'all' };
-    }
-    const text = fs.readFileSync(resolved, 'utf-8');
-    return { suite: (0, retrieval_eval_1.parseSuite)(JSON.parse(text)), rawContent: text, label: path.basename(resolved, '.json') };
-}
 class EvalCommand {
-    container;
+    db;
+    chunks;
+    catalog;
+    config;
     argv1;
-    constructor(container, argv1) {
-        this.container = container;
+    corpusInspector;
+    resultsDir;
+    constructor(db, chunks, catalog, config, argv1, corpusInspector = new eval_corpus_1.GitCorpusInspector(), resultsDir = path.join(_projectRoot, RESULTS_DIR_NAME)) {
+        this.db = db;
+        this.chunks = chunks;
+        this.catalog = catalog;
+        this.config = config;
         this.argv1 = argv1;
+        this.corpusInspector = corpusInspector;
+        this.resultsDir = resultsDir;
     }
     async execute() {
-        const { db, searcher, config } = this.container;
-        const args = process.argv.slice(this.argv1 === 'rag-index' ? 3 : 4); // after `rag-index eval` / `index eval`
+        const args = process.argv.slice(this.argv1 === 'rag-index' ? 3 : 4);
         let suitePath, baselinePath, projectFilter;
         try {
-            suitePath = parseSuiteFlag(args);
-            baselinePath = parseBaselineFlag(args);
-            projectFilter = parseProjectFlag(args);
+            ({ suitePath, baselinePath, projectFilter } = (0, eval_args_1.parseEvalArgs)(args));
         }
         catch (err) {
             console.error(`\n${err.message}`);
             process.exitCode = 1;
             return;
         }
-        let suite, rawContent, label;
+        let suite, corpora, rawContent, label;
         try {
-            ({ suite, rawContent, label } = loadSuite(suitePath));
+            ({ suite, corpora, rawContent, label } = (0, suite_loader_1.loadSuite)(_projectRoot, suitePath));
         }
         catch (err) {
             if (err instanceof retrieval_eval_1.EvalSuiteError) {
@@ -142,90 +102,41 @@ class EvalCommand {
             process.exitCode = 1;
             return;
         }
-        await db.initDbWithSchema();
-        const knownFilesCache = new Map();
-        const inspect = {
-            async isFileIndexed(project, file) {
-                if (!knownFilesCache.has(project))
-                    knownFilesCache.set(project, db.listKnownFiles(project));
-                const files = await knownFilesCache.get(project);
-                return files.includes(file);
-            },
-            async ownerPathsOfFile(project, file) {
-                const rows = await db.query(`SELECT DISTINCT "ownerPath" FROM code_chunk WHERE "serviceName" = $1 AND "filePath" = $2 AND "ownerPath" IS NOT NULL`, [project, file]);
-                return rows.map(r => r.ownerPath);
-            },
-        };
-        const search = async (query, limit, project, threshold) => {
-            const prepared = await searcher.prepareQuery(query);
-            const results = await searcher.searchChunks(prepared.query, limit, project, threshold);
-            return results.map(r => ({ filePath: r.filePath, ownerPath: r.ownerPath ?? null }));
-        };
-        const run = await new retrieval_eval_1.RetrievalEvaluator().evaluate(suite, search, inspect);
-        const indexMeta = await db.readIndexMeta();
-        const metadata = {
-            suitePath,
-            suiteHash: hashContent(rawContent),
-            embeddingProvider: config.embedding.provider,
-            embeddingModel: config.embedding.model,
-            rerankerModel: config.reranker.enabled ? config.reranker.model : null,
-            indexMeta: indexMeta ? { provider: indexMeta.provider, model: indexMeta.model, dimensions: indexMeta.dimensions } : null,
-            gitCommit: gitCommit(),
-            timestamp: new Date().toISOString(),
-        };
-        const resultFile = { metadata, run };
-        this.printSummary(resultFile);
-        let comparison;
-        if (baselinePath) {
-            try {
-                const baseline = (0, eval_results_1.readResultFile)(path.resolve(_projectRoot, baselinePath));
-                const cmp = (0, retrieval_eval_1.compare)(baseline, resultFile);
-                comparison = { baselinePath, result: cmp };
-                this.printComparison(baselinePath, cmp);
-            }
-            catch (err) {
-                console.error(`\nFailed to read baseline '${baselinePath}': ${err.message}`);
-                process.exitCode = 1;
-            }
-        }
-        const resultsDir = path.join(_projectRoot, RESULTS_DIR_NAME);
-        const { jsonPath, mdPath } = (0, eval_results_1.writeResultFiles)(resultsDir, label, resultFile, new Date(), comparison);
-        console.log(`\nResults written to:\n  ${path.relative(_projectRoot, jsonPath)}\n  ${path.relative(_projectRoot, mdPath)}`);
-    }
-    printSummary(result) {
-        const { run, metadata } = result;
-        console.log(`\nEvaluated ${run.cases.length} case(s) (${run.invalid.length} invalid) against ${metadata.embeddingProvider}/${metadata.embeddingModel}`);
-        const o = run.metrics.overall;
-        console.log(`  Overall — hit@1: ${(o.hit1 * 100).toFixed(1)}%  hit@5: ${(o.hit5 * 100).toFixed(1)}%  MRR@10: ${o.mrr10.toFixed(4)}`);
-        for (const category of ['identifier', 'behaviour', 'concept']) {
-            const m = run.metrics.byCategory[category];
-            if (m)
-                console.log(`  ${category.padEnd(10)} — hit@1: ${(m.hit1 * 100).toFixed(1)}%  hit@5: ${(m.hit5 * 100).toFixed(1)}%  MRR@10: ${m.mrr10.toFixed(4)}  (${m.count})`);
-        }
-        if (run.invalid.length > 0) {
-            console.log(`\nInvalid cases:`);
-            for (const c of run.invalid)
-                console.log(`  ${c.id}: ${c.reason} — ${c.invalidExpects.map(e => e.file).join(', ')}`);
-        }
-        if (run.warnings.length > 0) {
-            console.log(`\nWarnings (scored on remaining valid answers):`);
-            for (const w of run.warnings)
-                console.log(`  ${w.id}: dropped ${w.droppedExpects.map(e => e.file).join(', ')}`);
+        const runCorpora = corpora.filter(c => suite.cases.some(k => k.corpus === c.root));
+        if (await (0, eval_corpora_1.refusesMovedCorpus)(runCorpora, this.config, _projectRoot, this.corpusInspector))
+            return;
+        await this.db.initDbWithSchema();
+        const projectDirs = new Map((await this.catalog.listProjects()).map(p => [p.serviceName, p.relPath ?? null]));
+        const inspect = (0, index_inspector_1.createIndexInspector)(this.db, projectDirs);
+        const search = (0, staged_search_1.createStagedSearch)(this.chunks);
+        const thresholdWarning = (0, constants_1.thresholdMismatchWarning)(this.config.search.similarityThreshold, this.config.embedding.model);
+        if (thresholdWarning)
+            console.warn(`\n⚠ ${thresholdWarning}\n`);
+        const vectorIndex = await (0, eval_vector_index_1.describeVectorIndex)(this.db);
+        let outcome;
+        try {
+            outcome = await new retrieval_eval_1.RetrievalEvaluator().evaluate(suite, search, inspect, p => console.error((0, eval_results_1.renderProgress)(p)));
         }
-    }
-    printComparison(baselinePath, cmp) {
-        console.log(`\nComparison against ${baselinePath}:`);
-        if (cmp.conditionWarnings.length > 0) {
-            for (const w of cmp.conditionWarnings)
-                console.log(`  ⚠ ${w}`);
+        catch (err) {
+            if (!(err instanceof retrieval_eval_1.EvalSuiteError))
+                throw err;
+            console.error(`\nInvalid suite: ${err.message}`);
+            process.exitCode = 1;
+            return;
         }
-        const sign = (n) => (n >= 0 ? '+' : '') + n.toFixed(4);
-        console.log(`  MRR@10: ${cmp.overall.mrr10.baseline.toFixed(4)} → ${cmp.overall.mrr10.current.toFixed(4)} (${sign(cmp.overall.mrr10.delta)})`);
-        console.log(`  hit@5:  ${(cmp.overall.hit5.baseline * 100).toFixed(1)}% → ${(cmp.overall.hit5.current * 100).toFixed(1)}%`);
-        if (cmp.hit5Lost.length > 0)
-            console.log(`  Lost hit@5: ${cmp.hit5Lost.join(', ')}`);
-        if (cmp.hit5Gained.length > 0)
-            console.log(`  Gained hit@5: ${cmp.hit5Gained.join(', ')}`);
+        const { run, observed } = outcome;
+        const corpusRecords = await (0, eval_corpora_1.recordCorpora)(this.db, runCorpora, projectDirs);
+        const indexMeta = await this.db.readIndexMeta();
+        const metadata = (0, eval_metadata_1.buildResultMetadata)({
+            suitePath, rawContent, config: this.config, indexMeta, observed, vectorIndex, corpusRecords,
+            liveCases: suite.cases.filter(c => !c.corpus).length, projectRoot: _projectRoot,
+        });
+        const resultFile = { metadata, run };
+        for (const line of (0, eval_results_1.renderSummary)(resultFile))
+            console.log(line);
+        const comparison = baselinePath ? (0, baseline_comparison_1.compareWithBaseline)(_projectRoot, baselinePath, resultFile) : undefined;
+        const { jsonPath, mdPath } = (0, eval_results_1.writeResultFiles)(this.resultsDir, label, resultFile, new Date(), comparison);
+        console.log(`\nResults written to:\n  ${path.relative(_projectRoot, jsonPath)}\n  ${path.relative(_projectRoot, mdPath)}`);
     }
 }
 exports.EvalCommand = EvalCommand;