codesearch-mcp 0.3.0-alpha → 0.4.0-alpha

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,27 +1,29 @@
 "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();
-            await searcher.assertIndexMatches();
-        }
-        catch (err) {
-            startupError = err instanceof Error ? err : new Error(String(err));
-            logger.error('McpCommand: startup check failed', { err: startupError });
+        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) {
-            logger.error('McpCommand: MCP server failed to start', { err });
+            this.logger.error('McpCommand: MCP server failed to start', { err });
+            writeStartupCause(err);
+            process.exitCode = 1;
             return;
         }
         await new Promise(resolve => {
@@ -31,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,30 +4,39 @@ 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', { err });
+            this.logger.error('WebCommand: database connection failed', { err });
             console.error(`Database connection failed: ${reason}`);
         }
-        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', { err });
+            this.logger.error('WebCommand: server failed to start', { err });
             console.error(`Failed to start web server on ${host}:${this.port}: ${reason}`);
             return;
         }

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;

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

@@ -0,0 +1,75 @@
+"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.gitCommit = gitCommit;
+exports.hashContent = hashContent;
+exports.buildResultMetadata = buildResultMetadata;
+const crypto = __importStar(require("crypto"));
+const child_process_1 = require("child_process");
+function gitCommit(projectRoot) {
+    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);
+}
+function buildResultMetadata(input) {
+    const { suitePath, rawContent, config, indexMeta, observed, vectorIndex, corpusRecords, liveCases, projectRoot } = input;
+    return {
+        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(projectRoot),
+        timestamp: new Date().toISOString(),
+        conditions: {
+            thresholds: observed.thresholds,
+            overfetch: config.reranker.overfetch,
+            candidateFloor: config.reranker.candidateFloor,
+            fetchLimit: observed.fetchLimit,
+            efSearch: observed.efSearch,
+            iterativeScan: observed.iterativeScan,
+        },
+        vectorIndex,
+        corpora: corpusRecords,
+        liveCases,
+    };
+}

package/dist/src/commands/eval/index-inspector.d.ts

@@ -0,0 +1,3 @@
+import type { IDatabase } from '../../interfaces';
+import type { IndexInspector } from '../../interfaces/IRetrievalEvaluator';
+export declare function createIndexInspector(db: IDatabase, projectDirs: Map<string, string | null>): IndexInspector;

package/dist/src/commands/eval/index-inspector.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIndexInspector = createIndexInspector;
+function createIndexInspector(db, projectDirs) {
+    const knownFilesCache = new Map();
+    return {
+        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);
+        },
+        async projectDir(project) {
+            return projectDirs.get(project) ?? null;
+        },
+    };
+}

package/dist/src/commands/eval/staged-search.d.ts

@@ -0,0 +1,3 @@
+import type { IChunkSearch } from '../../interfaces';
+import type { SearchFn } from '../../interfaces/IRetrievalEvaluator';
+export declare function createStagedSearch(chunks: IChunkSearch): SearchFn;

package/dist/src/commands/eval/staged-search.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStagedSearch = createStagedSearch;
+const toHits = (rows) => rows.map(r => ({ filePath: r.filePath, ownerPath: r.ownerPath ?? null }));
+function createStagedSearch(chunks) {
+    return async (query, limit, project, threshold) => {
+        const prepared = await chunks.prepareQuery(query);
+        const r = await chunks.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,
+            threshold: r.threshold,
+        };
+    };
+}

package/dist/src/commands/eval/suite-loader.d.ts

@@ -0,0 +1,8 @@
+import type { EvalSuite, CorpusRef } from '../../interfaces/IRetrievalEvaluator';
+export interface LoadedSuite {
+    suite: EvalSuite;
+    corpora: CorpusRef[];
+    rawContent: string;
+    label: string;
+}
+export declare function loadSuite(projectRoot: string, suitePath: string): LoadedSuite;

package/dist/src/commands/eval/suite-loader.js

@@ -0,0 +1,52 @@
+"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.loadSuite = loadSuite;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const retrieval_eval_1 = require("../../retrieval-eval");
+function loadSuite(projectRoot, 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), corpora: (0, retrieval_eval_1.corporaOf)(suites), rawContent: parts.join('\n'), label: 'all' };
+    }
+    const text = fs.readFileSync(resolved, 'utf-8');
+    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') };
+}

package/dist/src/commands/index/backend-probe.d.ts

@@ -0,0 +1,2 @@
+import type { IDatabase, IEmbedder } from '../../interfaces';
+export declare function isBackendAvailable(db: IDatabase, embedder: IEmbedder): Promise<boolean>;

package/dist/src/commands/index/backend-probe.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBackendAvailable = isBackendAvailable;
+const error_record_1 = require("../../error-record");
+async function isBackendAvailable(db, embedder) {
+    try {
+        await db.query('SELECT 1');
+        await embedder.embed('probe', 'document');
+        return true;
+    }
+    catch (err) {
+        console.error(`Indexing backend unavailable: ${(0, error_record_1.rootCauseMessage)(err).replace(/\s*[\r\n]+\s*/g, ' ')}`);
+        return false;
+    }
+}

package/dist/src/commands/index/embedding-setup.d.ts

@@ -0,0 +1,3 @@
+import type { IndexerService } from '../../services/IndexerService';
+import type { IEmbedder } from '../../interfaces';
+export declare function prepareEmbedding(embedder: IEmbedder, indexer: IndexerService): Promise<boolean>;

package/dist/src/commands/index/embedding-setup.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareEmbedding = prepareEmbedding;
+async function prepareEmbedding(embedder, indexer) {
+    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;
+        return false;
+    }
+    return true;
+}

package/dist/src/commands/index/index-summary.d.ts

@@ -0,0 +1,2 @@
+import type { IndexStats } from '../../services/IndexerService';
+export declare function printIndexSummary(allStats: IndexStats[]): void;

package/dist/src/commands/index/index-summary.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printIndexSummary = printIndexSummary;
+function printIndexSummary(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));
+}

package/dist/src/commands/index/legacy-ollama-guard.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from '../../config';
+import type { IDatabase } from '../../interfaces';
+export declare function refusesLegacyOllamaIndex(db: IDatabase, config: Config): Promise<boolean>;