codesearch-mcp 0.2.2-alpha → 0.3.0-alpha

package/dist/src/commands/EvalCommand.js

@@ -0,0 +1,264 @@
+"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.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 eval_corpus_1 = require("../eval-corpus");
+const DEFAULT_SUITE_DIR = path.join('benchmarks', 'eval');
+const RESULTS_DIR_NAME = path.join('benchmarks', 'results');
+const KEPT_CORPUS_DIR = path.join('benchmarks', 'corpus');
+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);
+}
+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 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), 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') };
+}
+class EvalCommand {
+    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);
+        let suitePath, baselinePath, projectFilter;
+        try {
+            suitePath = parseSuiteFlag(args);
+            baselinePath = parseBaselineFlag(args);
+            projectFilter = parseProjectFlag(args);
+        }
+        catch (err) {
+            console.error(`\n${err.message}`);
+            process.exitCode = 1;
+            return;
+        }
+        let suite, corpora, rawContent, label;
+        try {
+            ({ suite, corpora, rawContent, label } = loadSuite(suitePath));
+        }
+        catch (err) {
+            if (err instanceof retrieval_eval_1.EvalSuiteError) {
+                console.error(`\nInvalid suite: ${err.message}`);
+            }
+            else {
+                console.error(`\nFailed to load suite at '${suitePath}': ${err.message}`);
+            }
+            process.exitCode = 1;
+            return;
+        }
+        if (projectFilter) {
+            suite = { version: 1, cases: suite.cases.filter(c => c.project === projectFilter) };
+        }
+        if (suite.cases.length === 0) {
+            console.error('\nNo cases to evaluate (suite is empty, or --project matched nothing).');
+            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) {
+                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;
+            },
+        };
+        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 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,
+            };
+        };
+        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,
+            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(),
+            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 };
+        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 };
+                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 { 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;

package/dist/src/commands/IndexCommand.js

@@ -5,8 +5,16 @@ 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");
+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 };
+}
 class IndexCommand {
     container;
     argv1;
@@ -19,12 +27,41 @@ class IndexCommand {
         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;
+            return;
+        }
+        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 {
@@ -43,37 +80,17 @@ class IndexCommand {
                 return;
             }
         }
-        const discovered = discovery.discover(config.workspaceRoot);
-        const selected = await new project_selector_1.ProjectSelector(config.workspaceRoot).select(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.
-        const projects = (0, MonorepoAwareDiscoveryService_1.toLeafProjects)(selected);
-        // A project indexed before member extraction mixes old-format rows (no
-        // members, bare calleeSymbol) with new ones if left to an incremental run.
-        // Refuse before any backend readiness check, Docker command, or schema
-        // work — the same pattern as the legacy-Ollama guard above.
-        if (!force) {
-            let outdated;
-            try {
-                outdated = await db.listOutdatedProjects(projects.map(p => p.name));
-            }
-            catch (err) {
-                console.error(`\n${err.message}`);
-                process.exitCode = 1;
-                return;
-            }
-            if (outdated.length > 0) {
-                console.error(`\nIndexed before member indexing: ${[...outdated].sort().join(', ')} — run \`rag-index --reindex\`.`);
-                process.exitCode = 1;
+        let projects;
+        if (scanTargets) {
+            projects = scanTargets;
+        }
+        else {
+            const selected = await new project_selector_1.ProjectSelector(config.workspaceRoot).select(discovered, forceSelect);
+            if (selected.length === 0)
                 return;
-            }
+            projects = (0, MonorepoAwareDiscoveryService_1.toLeafProjects)(selected);
         }
-        // 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.
+        const fullLeafProjects = (0, MonorepoAwareDiscoveryService_1.toLeafProjects)(discovered);
         try {
             await embedder.ensureModelAvailable?.();
             const meta = await indexer.prepareEmbeddingSchema();
@@ -87,50 +104,37 @@ class IndexCommand {
         const controller = new AbortController();
         const teardown = (0, interrupt_1.setupInterrupt)(controller);
         try {
-            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 (!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;
+                }
             }
             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 = [];
-            for (let i = 0; i < projects.length; i++) {
-                if (controller.signal.aborted)
-                    break;
-                const stats = await indexer.scanAndIndex(projects[i].path, projects[i].name, force, controller.signal, filesPerProject[i], { rootTsConfigPath: projects[i].rootTsConfigPath ?? undefined });
-                allStats.push(stats);
-                const remaining = projects.length - allStats.length;
-                if (remaining > 0 && !controller.signal.aborted) {
-                    const leftFiles = filesPerProject.slice(allStats.length).reduce((sum, f) => sum + f.length, 0);
-                    console.log(`  ${allStats.length}/${projects.length} projects — done in ${stats.elapsedSec}s — ${leftFiles} files left`);
-                }
-            }
+            const allStats = await indexer.scanProjects(projects, force, controller.signal, filesPerProject);
             if (controller.signal.aborted)
                 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.
                 try {
-                    // Real import edges (code_dependency, just written) → intra-repo graph links.
                     const projectEdges = await searcher.getProjectEdges();
-                    (0, graph_1.generateProjectGraph)(projects, projectEdges, config.workspaceRoot);
+                    (0, graph_1.generateProjectGraph)(fullLeafProjects, projectEdges, config.workspaceRoot);
                 }
                 catch (err) {
                     console.error(`  ⚠ Could not build project graph: ${err.message}`);

package/dist/src/commands/McpCommand.js

@@ -11,25 +11,19 @@ class McpCommand {
         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 });
+            logger.error('McpCommand: startup check failed', { err: startupError });
         }
         try {
             await mcp.start(startupError);
         }
         catch (err) {
-            const reason = err instanceof Error ? err.message : String(err);
-            logger.error('McpCommand: MCP server failed to start', { reason });
+            logger.error('McpCommand: MCP server failed to start', { err });
             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);

package/dist/src/commands/WebCommand.js

@@ -17,9 +17,8 @@ class WebCommand {
         }
         catch (err) {
             const reason = err instanceof Error ? err.message : String(err);
-            logger.error('WebCommand: database connection failed', { reason });
+            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 host = '127.0.0.1';
@@ -28,13 +27,11 @@ class WebCommand {
         }
         catch (err) {
             const reason = err instanceof Error ? err.message : String(err);
-            logger.error('WebCommand: server failed to start', { reason });
+            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/config-error.d.ts

@@ -1,7 +1,3 @@
-/**
- * Own module (not `config.ts`) so `config-store.ts` can throw it too without
- * an import cycle — `config.ts` imports from `config-store.ts`.
- */
 export declare class ConfigError extends Error {
     constructor(message: string);
 }

package/dist/src/config-error.js

@@ -1,10 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigError = void 0;
-/**
- * Own module (not `config.ts`) so `config-store.ts` can throw it too without
- * an import cycle — `config.ts` imports from `config-store.ts`.
- */
 class ConfigError extends Error {
     constructor(message) {
         super(message);

package/dist/src/config-store.d.ts

@@ -42,6 +42,7 @@ declare const jsonSchema: z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
         provider: z.ZodOptional<z.ZodEnum<{
             "openai-compatible": "openai-compatible";
+            voyage: "voyage";
         }>>;
         baseURL: z.ZodOptional<z.ZodString>;
         apiKey: z.ZodOptional<z.ZodString>;
@@ -58,24 +59,11 @@ declare const jsonSchema: z.ZodObject<{
             warn: "warn";
         }>>;
         dir: z.ZodOptional<z.ZodString>;
-        searchMetrics: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
     workspaceRoot: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type JsonConfig = z.infer<typeof jsonSchema>;
 export declare const ALL_KEYS: string[];
-/**
- * Single source of truth for built-in defaults, keyed by raw config.json dotted
- * key. Consumed both by the web dashboard (`GET /api/defaults`) and by
- * `resolvedSchema` in `src/config.ts`, whose `.default(...)` calls reference
- * these values — so the runtime default and the dashboard-displayed default
- * cannot diverge. `as const` keeps the literal types so those `.default()`
- * lookups stay type-safe. Keys omitted here have no static default: required
- * fields (db.host/user/password) and values derived at runtime — db.name →
- * rag_<user>, and the provider-dependent URLs (embedding.baseURL,
- * reranker.baseURL, reranker.url), which are computed in the `Config`
- * constructor per provider rather than through a schema `.default(...)`.
- */
 export declare const CONFIG_DEFAULTS: {
     readonly 'db.port': 5433;
     readonly 'embedding.provider': "infinity";
@@ -97,54 +85,13 @@ export declare const CONFIG_DEFAULTS: {
     readonly 'reranker.overfetch': 5;
     readonly 'reranker.candidateFloor': 80;
     readonly 'logging.level': "error";
-    readonly 'logging.searchMetrics': false;
 };
 export declare function readConfigJson(): JsonConfig | null;
-/**
- * Detect a raw (pre-migration) config object that still selects the removed
- * `ollama` embedding provider — explicitly, via a legacy top-level `ollama`
- * block, or implicitly (no `provider` set, but `baseURL`/`model` point at
- * Ollama's defaults) — and throw a `ConfigError` with migration guidance
- * instead of letting it validate under a silently reinterpreted provider.
- * Runs before `migrateRawConfig` so a legacy `ollama.*` block is never
- * converted into an `embedding` block first. Pure — never mutates `raw`.
- */
 export declare function detectFormerOllamaConfig(raw: unknown): void;
-/**
- * Migrate a legacy raw config object to the current shape, in place of a
- * versioned migration system. Pure — returns a new object, never mutates input.
- *
- * - Removed translation keys (`search.autoTranslate`, `search.translateModel`)
- *   are dropped so they neither validate-fail nor take effect.
- * - Legacy `reranker.provider: 'ollama'` (a dead value — Ollama has no rerank
- *   API) is rewritten to `openai-compatible`, and a stale `/api/rerank` URL is
- *   dropped so it re-derives to `/rerank`. Otherwise the tightened enum would
- *   fail validation on existing configs and lock the user out.
- *
- * A legacy top-level `ollama` block reaches here only when `detectFormerOllamaConfig`
- * did not already reject it (i.e. an `embedding` block is also present); it is
- * dropped rather than merged. Exported for unit testing.
- */
 export declare function migrateRawConfig(raw: unknown): unknown;
-/**
- * Validate a raw (pre-migration) config object against the Zod schema: first
- * `detectFormerOllamaConfig` (a `ConfigError` on a former-Ollama config takes
- * priority over both migration and the regular Zod enum rejection), then
- * `migrateRawConfig`, then the schema itself. Unknown keys (e.g. the "$schema"
- * editor reference) are stripped. Throws with a caller-friendly message on
- * validation failure. The single entry point for both `readConfigJson` and
- * `PUT /api/config`, so both apply identical rules with an identical message.
- * Pure — no file I/O.
- */
 export declare function parseConfig(raw: unknown, source?: string): JsonConfig;
-/** Build the JSON Schema object generated from the Zod config schema. Pure. */
 export declare function buildJsonSchema(): Record<string, unknown>;
 export declare function writeConfigJson(data: JsonConfig): void;
-/**
- * Generate a JSON Schema from the Zod config schema and write it next to
- * config.json. Editors resolve it via the "$schema" reference and provide
- * key autocomplete, type hints, and inline validation while editing.
- */
 export declare function writeSchemaFile(): void;
 export declare function getNestedValue(cfg: JsonConfig, key: string): unknown;
 export declare function setNestedValue(cfg: JsonConfig, key: string, raw: string): JsonConfig;