codesearch-mcp 0.2.3-alpha → 0.3.0-alpha

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/chunking/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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,11 @@
 import type { Container } from '../container';
 import type { ICommand } from './ICommand';
+import type { ICorpusInspector } from '../interfaces/ICorpusInspector';
 export declare class EvalCommand implements ICommand {
     private container;
     private argv1;
-    constructor(container: Container, argv1: string);
+    private corpusInspector;
+    private resultsDir;
+    constructor(container: Container, argv1: string, corpusInspector?: ICorpusInspector, resultsDir?: string);
     execute(): Promise<void>;
-    private printSummary;
-    private printComparison;
 }

package/dist/src/commands/EvalCommand.js

@@ -40,10 +40,10 @@ 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 eval_corpus_1 = require("../eval-corpus");
 const DEFAULT_SUITE_DIR = path.join('benchmarks', 'eval');
 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 KEPT_CORPUS_DIR = path.join('benchmarks', 'corpus');
 const _projectRoot = fs.existsSync(path.join(__dirname, '..', '..', 'package.json'))
     ? path.join(__dirname, '..', '..')
     : path.join(__dirname, '..', '..', '..');
@@ -58,7 +58,6 @@ function gitCommit() {
 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)
@@ -86,7 +85,6 @@ function parseProjectFlag(args) {
         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);
@@ -94,21 +92,26 @@ function loadSuite(suitePath) {
         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' };
+        return { suite: (0, retrieval_eval_1.mergeSuites)(suites), corpora: (0, retrieval_eval_1.corporaOf)(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') };
+    const suite = (0, retrieval_eval_1.parseSuite)(JSON.parse(text));
+    return { suite, corpora: (0, retrieval_eval_1.corporaOf)([suite]), rawContent: text, label: path.basename(resolved, '.json') };
 }
 class EvalCommand {
     container;
     argv1;
-    constructor(container, argv1) {
+    corpusInspector;
+    resultsDir;
+    constructor(container, argv1, corpusInspector = new eval_corpus_1.GitCorpusInspector(), resultsDir = path.join(_projectRoot, RESULTS_DIR_NAME)) {
         this.container = container;
         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);
@@ -120,9 +123,9 @@ class EvalCommand {
             process.exitCode = 1;
             return;
         }
-        let suite, rawContent, label;
+        let suite, corpora, rawContent, label;
         try {
-            ({ suite, rawContent, label } = loadSuite(suitePath));
+            ({ suite, corpora, rawContent, label } = loadSuite(suitePath));
         }
         catch (err) {
             if (err instanceof retrieval_eval_1.EvalSuiteError) {
@@ -142,7 +145,30 @@ class EvalCommand {
             process.exitCode = 1;
             return;
         }
+        const runCorpora = corpora.filter(c => suite.cases.some(k => k.corpus === c.root));
+        let refused = false;
+        for (const corpus of runCorpora) {
+            let failures;
+            try {
+                failures = await (0, eval_corpus_1.checkCorpus)(corpus, path.join(config.workspaceRoot, corpus.root), path.join(_projectRoot, KEPT_CORPUS_DIR, corpus.root), this.corpusInspector);
+            }
+            catch (err) {
+                failures = [`cannot inspect the checkout: ${err.message}`];
+            }
+            if (failures.length === 0)
+                continue;
+            refused = true;
+            console.error(`\nCorpus ${corpus.root} does not match ${corpus.commit}:`);
+            for (const f of failures)
+                console.error(`  - ${f}`);
+        }
+        if (refused) {
+            console.error('\nNo search was run and no result file was written.');
+            process.exitCode = 1;
+            return;
+        }
         await db.initDbWithSchema();
+        const projectDirs = new Map((await searcher.listProjects()).map(p => [p.serviceName, p.relPath ?? null]));
         const knownFilesCache = new Map();
         const inspect = {
             async isFileIndexed(project, file) {
@@ -155,13 +181,44 @@ class EvalCommand {
                 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);
             },
+            async projectDir(project) {
+                return projectDirs.get(project) ?? null;
+            },
         };
+        const toHits = (rows) => rows.map(r => ({ filePath: r.filePath, ownerPath: r.ownerPath ?? null }));
         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 r = await searcher.searchChunksWithStages(prepared.query, limit, project, threshold, undefined, limit);
+            return {
+                pool: toHits(r.pool),
+                stages: r.stages.reranked
+                    ? { vector: toHits(r.stages.vector), reranked: toHits(r.stages.reranked) }
+                    : { vector: toHits(r.stages.vector) },
+                rerankFailed: r.rerankFailed,
+                fetchLimit: r.fetchLimit,
+                indexParams: r.indexParams,
+            };
         };
-        const run = await new retrieval_eval_1.RetrievalEvaluator().evaluate(suite, search, inspect);
+        let outcome;
+        try {
+            outcome = await new retrieval_eval_1.RetrievalEvaluator().evaluate(suite, search, inspect, p => console.error((0, eval_results_1.renderProgress)(p)));
+        }
+        catch (err) {
+            if (!(err instanceof retrieval_eval_1.EvalSuiteError))
+                throw err;
+            console.error(`\nInvalid suite: ${err.message}`);
+            process.exitCode = 1;
+            return;
+        }
+        const { run, observed } = outcome;
+        const corpusRecords = [];
+        for (const corpus of runCorpora) {
+            const projects = [...projectDirs].filter(([, dir]) => dir !== null && (0, retrieval_eval_1.isUnderRoot)(dir, corpus.root)).map(([name]) => name).sort();
+            const started = Date.now();
+            const record = { ...corpus, projects, ...(await (0, eval_corpus_1.fingerprintCorpus)(db, projects)) };
+            console.log(`Corpus ${corpus.root}: ${record.chunks} chunks in ${projects.length} project(s), fingerprint ${record.fingerprint} (${((Date.now() - started) / 1000).toFixed(1)}s)`);
+            corpusRecords.push(record);
+        }
         const indexMeta = await db.readIndexMeta();
         const metadata = {
             suitePath,
@@ -172,60 +229,36 @@ class EvalCommand {
             indexMeta: indexMeta ? { provider: indexMeta.provider, model: indexMeta.model, dimensions: indexMeta.dimensions } : null,
             gitCommit: gitCommit(),
             timestamp: new Date().toISOString(),
+            conditions: {
+                similarityThreshold: config.search.similarityThreshold,
+                overfetch: config.reranker.overfetch,
+                candidateFloor: config.reranker.candidateFloor,
+                fetchLimit: observed.fetchLimit,
+                efSearch: observed.efSearch,
+                iterativeScan: observed.iterativeScan,
+            },
+            corpora: corpusRecords,
+            liveCases: suite.cases.filter(c => !c.corpus).length,
         };
         const resultFile = { metadata, run };
-        this.printSummary(resultFile);
+        for (const line of (0, eval_results_1.renderSummary)(resultFile))
+            console.log(line);
         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);
+                for (const line of (0, eval_results_1.renderComparison)(baselinePath, cmp))
+                    console.log(line);
             }
             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);
+        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)}`);
     }
-    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(', ')}`);
-        }
-    }
-    printComparison(baselinePath, cmp) {
-        console.log(`\nComparison against ${baselinePath}:`);
-        if (cmp.conditionWarnings.length > 0) {
-            for (const w of cmp.conditionWarnings)
-                console.log(`  ⚠ ${w}`);
-        }
-        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(', ')}`);
-    }
 }
 exports.EvalCommand = EvalCommand;