codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

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

@@ -1,9 +1,15 @@
-import type { Container } from '../container';
+import type { IndexerService } from '../services/IndexerService';
+import type { Config } from '../config';
+import type { IDatabase, IDependencyGraph, IEmbedder, IProjectDiscovery } from '../interfaces';
 import type { ICommand } from './ICommand';
 export declare class IndexCommand implements ICommand {
-    private container;
+    private db;
+    private embedder;
+    private indexer;
+    private dependencies;
+    private discovery;
+    private config;
     private argv1;
-    constructor(container: Container, argv1: string);
+    constructor(db: IDatabase, embedder: IEmbedder, indexer: IndexerService, dependencies: IDependencyGraph, discovery: IProjectDiscovery, config: Config, argv1: string);
     execute(): Promise<void>;
-    private printSummary;
 }

package/dist/src/commands/IndexCommand.js

@@ -5,186 +5,92 @@ const interrupt_1 = require("../interrupt");
 const project_selector_1 = require("../project-selector");
 const graph_1 = require("../graph");
 const MonorepoAwareDiscoveryService_1 = require("../services/MonorepoAwareDiscoveryService");
-const project_scope_1 = require("../project-scope");
 const file_utils_1 = require("../file-utils");
-const legacy_ollama_index_1 = require("../services/legacy-ollama-index");
-/** `--project`'s index in `args`; the following token is its name unless absent or itself a flag. */
-function parseProjectFlag(args) {
-    const i = args.indexOf('--project');
-    if (i === -1)
-        return { present: false };
-    const next = args[i + 1];
-    return next !== undefined && !next.startsWith('-') ? { present: true, name: next } : { present: true };
-}
+const index_args_1 = require("../index-args");
+const scan_targets_1 = require("./index/scan-targets");
+const legacy_ollama_guard_1 = require("./index/legacy-ollama-guard");
+const embedding_setup_1 = require("./index/embedding-setup");
+const prune_step_1 = require("./index/prune-step");
+const backend_probe_1 = require("./index/backend-probe");
+const index_summary_1 = require("./index/index-summary");
 class IndexCommand {
-    container;
+    db;
+    embedder;
+    indexer;
+    dependencies;
+    discovery;
+    config;
     argv1;
-    constructor(container, argv1) {
-        this.container = container;
+    constructor(db, embedder, indexer, dependencies, discovery, config, argv1) {
+        this.db = db;
+        this.embedder = embedder;
+        this.indexer = indexer;
+        this.dependencies = dependencies;
+        this.discovery = discovery;
+        this.config = config;
         this.argv1 = argv1;
     }
     async execute() {
-        const { db, indexer, searcher, config, discovery, embedder } = this.container;
-        const args = process.argv.slice(this.argv1 === 'rag-index' ? 2 : 3);
-        const force = args.includes('--reindex');
-        const forceSelect = args.includes('--select');
-        const projectFlag = parseProjectFlag(args);
-        let discovered;
-        try {
-            discovered = discovery.discover(config.workspaceRoot);
-        }
-        catch (err) {
-            console.error(`\n${err.message}`);
-            process.exitCode = 1;
+        const args = (0, index_args_1.parseIndexArgs)(process.argv.slice(this.argv1 === 'rag-index' ? 2 : 3));
+        const { force, forceSelect } = args;
+        const targets = await (0, scan_targets_1.resolveScanTargets)(this.discovery, this.config, args);
+        if (!targets)
+            return;
+        await this.db.initDbWithSchema();
+        if (!force && await (0, legacy_ollama_guard_1.refusesLegacyOllamaIndex)(this.db, this.config))
             return;
-        }
-        // Resolve --project before any database or embedding work, so a bad name
-        // (or a cancelled no-name prompt) has zero side effects.
-        let scanTargets;
-        if (projectFlag.present) {
-            let name = projectFlag.name;
-            if (name === undefined) {
-                if (discovered.length === 0) {
-                    console.error('\nNo projects available to select.');
-                    process.exitCode = 1;
-                    return;
-                }
-                name = await (0, project_selector_1.selectSingleProject)(discovered);
-                if (name === undefined) {
-                    process.exitCode = 1;
-                    return;
-                }
-            }
-            const { targets, notFound } = (0, project_scope_1.resolveProjectNames)([name], discovered);
-            if (notFound.length > 0) {
-                const available = (0, project_scope_1.listAvailableNames)(discovered).join(', ');
-                console.error(`\nProject '${notFound[0]}' not found. Available projects: ${available}`);
-                process.exitCode = 1;
-                return;
-            }
-            scanTargets = targets;
-        }
-        await db.initDbWithSchema();
-        // A former Ollama installation the config layer cannot recognise (old
-        // defaults, no `embedding`/`ollama` block) is protected here: without an
-        // explicit `--reindex`, refuse to touch an index built by `ollama` (or a
-        // pre-`index_meta` install, which is indistinguishable from one) before
-        // any backend readiness check, Docker command, or schema work.
-        if (!force) {
-            let identity;
-            try {
-                identity = await (0, legacy_ollama_index_1.resolveIndexedIdentity)(db);
-            }
-            catch (err) {
-                console.error(`\n${err.message}`);
-                process.exitCode = 1;
-                return;
-            }
-            if (identity?.provider === 'ollama') {
-                console.error(`\nThe existing index was built with ${identity.provider}/${identity.model}, but "ollama" is no ` +
-                    `longer a supported embedding provider (configured: ${config.embedding.provider}/${config.embedding.model}). ` +
-                    `Run \`rag-index --reindex\` to confirm rebuilding the index under the configured provider.`);
-                process.exitCode = 1;
-                return;
-            }
-        }
         let projects;
-        if (scanTargets) {
-            projects = scanTargets;
+        if (targets.scanTargets) {
+            projects = targets.scanTargets;
         }
         else {
-            const selected = await new project_selector_1.ProjectSelector(config.workspaceRoot).select(discovered, forceSelect);
+            const selected = await new project_selector_1.ProjectSelector(this.config.workspaceRoot).select(targets.discovered, forceSelect);
             if (selected.length === 0)
                 return;
-            // Expand any selected nested-monorepo unit (e.g. an Nx repo) into its
-            // sub-projects; ordinary projects pass through unchanged.
             projects = (0, MonorepoAwareDiscoveryService_1.toLeafProjects)(selected);
         }
-        // The post-index graph always reflects the full workspace, regardless of
-        // what this run actually scanned.
-        const fullLeafProjects = (0, MonorepoAwareDiscoveryService_1.toLeafProjects)(discovered);
-        // Ensure the local model is served (Infinity only — no-op for cloud), then
-        // resolve the active embedding dimension and reconcile it with index_meta
-        // (recreate code_chunk on a dimension change, clear rows on a model change)
-        // before scanning. A clear error here beats a mid-run vector width mismatch.
-        try {
-            await embedder.ensureModelAvailable?.();
-            const meta = await indexer.prepareEmbeddingSchema();
-            console.log(`Embedding: ${meta.provider} / ${meta.model} (${meta.dimensions} dims)`);
-        }
-        catch (err) {
-            console.error(`\nEmbedding setup failed: ${err.message}`);
-            process.exitCode = 1;
+        const fullLeafProjects = (0, MonorepoAwareDiscoveryService_1.toLeafProjects)(targets.discovered);
+        if (!await (0, embedding_setup_1.prepareEmbedding)(this.embedder, this.indexer))
             return;
-        }
         const controller = new AbortController();
         const teardown = (0, interrupt_1.setupInterrupt)(controller);
         try {
-            // --project bypasses pruning entirely — it promises "touch only this
-            // project," so nothing outside the resolved target(s) is ever removed.
-            if (!scanTargets) {
-                let pruneResult;
-                try {
-                    pruneResult = await indexer.pruneProjects(projects.map(p => p.name));
-                }
-                catch (err) {
-                    console.error(`\nPruning failed: ${err.message}`);
-                    process.exitCode = 1;
-                    return;
-                }
-                const { removed, failed } = pruneResult;
-                for (const name of removed) {
-                    console.log(`Removed project ${name} (not selected)`);
-                }
-                if (failed.length > 0) {
-                    process.exitCode = 1;
-                }
-            }
+            if (!targets.scanTargets && !await (0, prune_step_1.pruneUnselected)(this.indexer, projects))
+                return;
             const filesPerProject = projects.map(p => (0, file_utils_1.collectFiles)(p.path, (0, file_utils_1.loadIgnore)(p.path), p.path));
             const totalFiles = filesPerProject.reduce((sum, f) => sum + f.length, 0);
             console.log(`\n${projects.length} projects — ${totalFiles} files total`);
             if (force)
                 console.log('Reindex mode: all files will be re-indexed.');
-            const allStats = await indexer.scanProjects(projects, force, controller.signal, filesPerProject);
-            if (controller.signal.aborted)
+            const allStats = await this.indexer.scanProjects(projects, force, controller.signal, filesPerProject);
+            const interrupted = controller.signal.aborted;
+            if (interrupted)
                 console.log('\nIndexing interrupted.');
-            this.printSummary(allStats);
-            if (!controller.signal.aborted) {
-                // The graph is a post-index nicety — a failure here (DB dropped after a
-                // long run, unreadable dir) must not fail the whole run: indexing already
-                // succeeded and the summary is printed.
+            (0, index_summary_1.printIndexSummary)(allStats);
+            const sum = (field) => allStats.reduce((total, s) => total + s[field], 0);
+            const failed = sum('failed');
+            const total = failed + sum('indexed') + sum('skipped');
+            if (failed > 0) {
+                console.error(`Indexing finished with ${failed} of ${total} file(s) failed.`);
+            }
+            if (!interrupted) {
                 try {
-                    // Real import edges (code_dependency, just written) → intra-repo graph links.
-                    const projectEdges = await searcher.getProjectEdges();
-                    (0, graph_1.generateProjectGraph)(fullLeafProjects, projectEdges, config.workspaceRoot);
+                    const projectEdges = await this.dependencies.getProjectEdges();
+                    (0, graph_1.generateProjectGraph)(fullLeafProjects, projectEdges, this.config.workspaceRoot);
                 }
                 catch (err) {
                     console.error(`  ⚠ Could not build project graph: ${err.message}`);
                 }
             }
+            if (failed > 0) {
+                const nothingUsable = sum('skipped') === 0 && sum('chunks') === 0;
+                const alreadyFailed = interrupted || !!process.exitCode || nothingUsable;
+                process.exitCode = alreadyFailed || !(await (0, backend_probe_1.isBackendAvailable)(this.db, this.embedder)) ? 1 : 2;
+            }
         }
         finally {
             teardown();
         }
     }
-    printSummary(allStats) {
-        const cols = { name: 30, num: 8 };
-        const line = '─'.repeat(cols.name + cols.num * 5 + 5);
-        console.log('\n=== Indexing Summary ===');
-        console.log('Service'.padEnd(cols.name), 'Indexed'.padStart(cols.num), 'Skipped'.padStart(cols.num), 'Failed'.padStart(cols.num), 'Chunks'.padStart(cols.num), 'Time(s)'.padStart(cols.num));
-        console.log(line);
-        for (const s of allStats) {
-            console.log(s.serviceName.padEnd(cols.name), String(s.indexed).padStart(cols.num), String(s.skipped).padStart(cols.num), String(s.failed).padStart(cols.num), String(s.chunks).padStart(cols.num), String(s.elapsedSec).padStart(cols.num));
-        }
-        console.log(line);
-        const total = allStats.reduce((acc, s) => ({
-            indexed: acc.indexed + s.indexed,
-            skipped: acc.skipped + s.skipped,
-            failed: acc.failed + s.failed,
-            chunks: acc.chunks + s.chunks,
-            elapsedSec: acc.elapsedSec + s.elapsedSec,
-        }), { indexed: 0, skipped: 0, failed: 0, chunks: 0, elapsedSec: 0 });
-        console.log('TOTAL'.padEnd(cols.name), String(total.indexed).padStart(cols.num), String(total.skipped).padStart(cols.num), String(total.failed).padStart(cols.num), String(total.chunks).padStart(cols.num), String(total.elapsedSec.toFixed(1)).padStart(cols.num));
-    }
 }
 exports.IndexCommand = IndexCommand;

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

@@ -1,7 +1,10 @@
-import type { Container } from '../container';
 import type { ICommand } from './ICommand';
+import type { IMcpReadiness, ILogger } from '../interfaces';
+import type { McpServer } from '../services/McpServer';
 export declare class McpCommand implements ICommand {
-    private container;
-    constructor(container: Container);
+    private readiness;
+    private mcp;
+    private logger;
+    constructor(readiness: IMcpReadiness, mcp: McpServer, logger: ILogger);
     execute(): Promise<void>;
 }

package/dist/src/commands/McpCommand.js

@@ -1,35 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.McpCommand = void 0;
+const error_record_1 = require("../error-record");
 class McpCommand {
-    container;
-    constructor(container) {
-        this.container = container;
+    readiness;
+    mcp;
+    logger;
+    constructor(readiness, mcp, logger) {
+        this.readiness = readiness;
+        this.mcp = mcp;
+        this.logger = logger;
     }
     async execute() {
-        const { db, mcp, searcher, logger } = this.container;
-        let startupError;
-        try {
-            await db.initDb();
-            // Refuse to serve searches embedded into a foreign vector space — surface
-            // the mismatch through the existing startup-error plumbing so every tool
-            // call reports it clearly.
-            await searcher.assertIndexMatches();
-        }
-        catch (err) {
-            startupError = err instanceof Error ? err : new Error(String(err));
-            logger.error('McpCommand: startup check failed', { reason: startupError.message });
+        const check = await this.readiness.start();
+        if (!check.ok) {
+            this.logger.error('McpCommand: startup check failed', { err: check.err });
+            writeStartupCause(check.err);
         }
         try {
-            await mcp.start(startupError);
+            await this.mcp.start(check.ok ? undefined : check);
         }
         catch (err) {
-            const reason = err instanceof Error ? err.message : String(err);
-            logger.error('McpCommand: MCP server failed to start', { reason });
+            this.logger.error('McpCommand: MCP server failed to start', { err });
+            writeStartupCause(err);
+            process.exitCode = 1;
             return;
         }
-        // server.connect() resolves immediately after setup; keep the process alive
-        // until the MCP client disconnects (stdin closes)
         await new Promise(resolve => {
             process.stdin.once('close', resolve);
             process.stdin.once('end', resolve);
@@ -37,3 +33,6 @@ class McpCommand {
     }
 }
 exports.McpCommand = McpCommand;
+function writeStartupCause(err) {
+    process.stderr.write(`codesearch-mcp: ${(0, error_record_1.errorMessage)(err)}\n`);
+}

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

@@ -1,8 +1,14 @@
-import type { Container } from '../container';
 import type { ICommand } from './ICommand';
+import type { Config } from '../config';
+import type { IDatabase, IDependencyGraph, IEmbedder, ILogger, IProjectCatalog } from '../interfaces';
 export declare class WebCommand implements ICommand {
-    private container;
+    private db;
+    private embedder;
+    private catalog;
+    private dependencies;
+    private config;
+    private logger;
     private readonly port;
-    constructor(container: Container, args?: string[]);
+    constructor(db: IDatabase, embedder: IEmbedder, catalog: IProjectCatalog, dependencies: IDependencyGraph, config: Config, logger: ILogger, args?: string[]);
     execute(): Promise<void>;
 }

package/dist/src/commands/WebCommand.js

@@ -4,37 +4,43 @@ exports.WebCommand = void 0;
 const WebServerService_1 = require("../services/WebServerService");
 const DEFAULT_PORT = 4319;
 class WebCommand {
-    container;
+    db;
+    embedder;
+    catalog;
+    dependencies;
+    config;
+    logger;
     port;
-    constructor(container, args = []) {
-        this.container = container;
+    constructor(db, embedder, catalog, dependencies, config, logger, args = []) {
+        this.db = db;
+        this.embedder = embedder;
+        this.catalog = catalog;
+        this.dependencies = dependencies;
+        this.config = config;
+        this.logger = logger;
         this.port = parsePort(args) ?? DEFAULT_PORT;
     }
     async execute() {
-        const { db, searcher, config, logger, embedder } = this.container;
         try {
-            await db.initDb();
+            await this.db.initDb();
         }
         catch (err) {
             const reason = err instanceof Error ? err.message : String(err);
-            logger.error('WebCommand: database connection failed', { reason });
+            this.logger.error('WebCommand: database connection failed', { err });
             console.error(`Database connection failed: ${reason}`);
-            // Continue: config editing still works; project/graph tabs will error in-page.
         }
-        const server = new WebServerService_1.WebServer(searcher, config, logger, embedder);
+        const server = new WebServerService_1.WebServer(this.catalog, this.dependencies, this.config, this.logger, this.embedder);
         const host = '127.0.0.1';
         try {
             await server.start(this.port, host);
         }
         catch (err) {
             const reason = err instanceof Error ? err.message : String(err);
-            logger.error('WebCommand: server failed to start', { reason });
+            this.logger.error('WebCommand: server failed to start', { err });
             console.error(`Failed to start web server on ${host}:${this.port}: ${reason}`);
             return;
         }
         console.log(`RAG dashboard: http://${host}:${this.port}  (Ctrl+C to stop)`);
-        // Keep execute() pending until a shutdown signal, otherwise app.ts tears
-        // down the DB and exits immediately (mirrors McpCommand's keep-alive).
         await new Promise(resolve => {
             const shutdown = () => { void server.stop().then(resolve); };
             process.once('SIGINT', shutdown);

package/dist/src/commands/eval/baseline-comparison.d.ts

@@ -0,0 +1,6 @@
+import { compare } from '../../retrieval-eval';
+import type { EvalResultFile } from '../../interfaces/IRetrievalEvaluator';
+export declare function compareWithBaseline(projectRoot: string, baselinePath: string, resultFile: EvalResultFile): {
+    baselinePath: string;
+    result: ReturnType<typeof compare>;
+} | undefined;

package/dist/src/commands/eval/baseline-comparison.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareWithBaseline = compareWithBaseline;
+const path = __importStar(require("path"));
+const retrieval_eval_1 = require("../../retrieval-eval");
+const eval_results_1 = require("../../eval-results");
+function compareWithBaseline(projectRoot, baselinePath, resultFile) {
+    let comparison;
+    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 };
+        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;
+    }
+    return comparison;
+}

package/dist/src/commands/eval/eval-args.d.ts

@@ -0,0 +1,6 @@
+export interface EvalArgs {
+    suitePath: string;
+    baselinePath: string | null;
+    projectFilter: string | null;
+}
+export declare function parseEvalArgs(args: string[]): EvalArgs;

package/dist/src/commands/eval/eval-args.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEvalArgs = parseEvalArgs;
+const path = __importStar(require("path"));
+const DEFAULT_SUITE_DIR = path.join('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;
+}
+function parseEvalArgs(args) {
+    const suitePath = parseSuiteFlag(args);
+    const baselinePath = parseBaselineFlag(args);
+    const projectFilter = parseProjectFlag(args);
+    return { suitePath, baselinePath, projectFilter };
+}

package/dist/src/commands/eval/eval-corpora.d.ts

@@ -0,0 +1,6 @@
+import type { Config } from '../../config';
+import type { IDatabase } from '../../interfaces';
+import type { ICorpusInspector } from '../../interfaces/ICorpusInspector';
+import type { CorpusRef, CorpusRecord } from '../../interfaces/IRetrievalEvaluator';
+export declare function refusesMovedCorpus(runCorpora: CorpusRef[], config: Config, projectRoot: string, inspector: ICorpusInspector): Promise<boolean>;
+export declare function recordCorpora(db: IDatabase, runCorpora: CorpusRef[], projectDirs: Map<string, string | null>): Promise<CorpusRecord[]>;

package/dist/src/commands/eval/eval-corpora.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refusesMovedCorpus = refusesMovedCorpus;
+exports.recordCorpora = recordCorpora;
+const path = __importStar(require("path"));
+const eval_corpus_1 = require("../../eval-corpus");
+const retrieval_eval_1 = require("../../retrieval-eval");
+const KEPT_CORPUS_DIR = path.join('benchmarks', 'corpus');
+async function refusesMovedCorpus(runCorpora, config, projectRoot, inspector) {
+    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), inspector);
+        }
+        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 true;
+    }
+    return false;
+}
+async function recordCorpora(db, runCorpora, projectDirs) {
+    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);
+    }
+    return corpusRecords;
+}

package/dist/src/commands/eval/eval-metadata.d.ts

@@ -0,0 +1,17 @@
+import type { Config } from '../../config';
+import type { IndexMeta } from '../../interfaces/IDatabase';
+import type { ResultMetadata, ObservedSearchParams, VectorIndexRecord, CorpusRecord } from '../../interfaces/IRetrievalEvaluator';
+export declare function gitCommit(projectRoot: string): string;
+export declare function hashContent(text: string): string;
+export interface ResultMetadataInput {
+    suitePath: string;
+    rawContent: string;
+    config: Config;
+    indexMeta: IndexMeta | null;
+    observed: ObservedSearchParams;
+    vectorIndex: VectorIndexRecord;
+    corpusRecords: CorpusRecord[];
+    liveCases: number;
+    projectRoot: string;
+}
+export declare function buildResultMetadata(input: ResultMetadataInput): ResultMetadata;