codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

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>;

package/dist/src/commands/index/legacy-ollama-guard.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refusesLegacyOllamaIndex = refusesLegacyOllamaIndex;
+const legacy_ollama_index_1 = require("../../services/legacy-ollama-index");
+async function refusesLegacyOllamaIndex(db, config) {
+    let identity;
+    try {
+        identity = await (0, legacy_ollama_index_1.resolveIndexedIdentity)(db);
+    }
+    catch (err) {
+        console.error(`\n${err.message}`);
+        process.exitCode = 1;
+        return true;
+    }
+    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 true;
+    }
+    return false;
+}

package/dist/src/commands/index/prune-step.d.ts

@@ -0,0 +1,3 @@
+import type { IndexerService } from '../../services/IndexerService';
+import type { DiscoveredProject } from '../../interfaces';
+export declare function pruneUnselected(indexer: IndexerService, projects: DiscoveredProject[]): Promise<boolean>;

package/dist/src/commands/index/prune-step.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pruneUnselected = pruneUnselected;
+async function pruneUnselected(indexer, projects) {
+    let pruneResult;
+    try {
+        pruneResult = await indexer.pruneProjects(projects.map(p => p.name));
+    }
+    catch (err) {
+        console.error(`\nPruning failed: ${err.message}`);
+        process.exitCode = 1;
+        return false;
+    }
+    const { removed, failed } = pruneResult;
+    for (const name of removed) {
+        console.log(`Removed project ${name} (not selected)`);
+    }
+    if (failed.length > 0) {
+        process.exitCode = 1;
+    }
+    return true;
+}

package/dist/src/commands/index/scan-targets.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from '../../config';
+import type { IndexArgs } from '../../index-args';
+import type { DiscoveredProject, IProjectDiscovery } from '../../interfaces';
+export interface ScanTargets {
+    discovered: DiscoveredProject[];
+    scanTargets?: DiscoveredProject[];
+}
+export declare function resolveScanTargets(discovery: IProjectDiscovery, config: Config, args: IndexArgs): Promise<ScanTargets | null>;

package/dist/src/commands/index/scan-targets.js

@@ -0,0 +1,107 @@
+"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.resolveScanTargets = resolveScanTargets;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const project_selector_1 = require("../../project-selector");
+const project_scope_1 = require("../../project-scope");
+async function resolveScanTargets(discovery, config, args) {
+    const { projectFlag, requireCwd } = args;
+    let discovered;
+    try {
+        discovered = discovery.discover(config.workspaceRoot);
+    }
+    catch (err) {
+        console.error(`\n${err.message}`);
+        process.exitCode = 1;
+        return null;
+    }
+    if (requireCwd && projectFlag.name === undefined) {
+        console.error('\n--require-cwd needs --project <name>.');
+        process.exitCode = 1;
+        return null;
+    }
+    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 null;
+            }
+            name = await (0, project_selector_1.selectSingleProject)(discovered);
+            if (name === undefined) {
+                process.exitCode = 1;
+                return null;
+            }
+        }
+        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 null;
+        }
+        if (requireCwd && !isInProjectDir(config, name, discovered)) {
+            process.exitCode = 1;
+            return null;
+        }
+        scanTargets = targets;
+    }
+    return { discovered, scanTargets };
+}
+function isInProjectDir(config, name, discovered) {
+    const { workspaceRoot } = config;
+    if (!path.isAbsolute(workspaceRoot)) {
+        console.error(`\nworkspaceRoot '${workspaceRoot}' is relative, so it moves with the current directory and --require-cwd cannot tell checkouts apart.`);
+        return false;
+    }
+    let cwd;
+    let projectDir;
+    try {
+        cwd = fs.realpathSync.native(process.cwd());
+        projectDir = fs.realpathSync.native((0, project_scope_1.matchedProjectDir)(name, discovered));
+    }
+    catch (err) {
+        console.error(`\n${err.message}`);
+        return false;
+    }
+    if (cwd === projectDir)
+        return true;
+    console.error(`\nCurrent directory ${cwd} is not the directory of project '${name}' (${projectDir}).`);
+    return false;
+}

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";
@@ -87,7 +75,6 @@ export declare const CONFIG_DEFAULTS: {
     readonly 'indexing.embedBatchSize': 5;
     readonly 'indexing.astBatchSize': 3000;
     readonly 'indexing.chunkStrategy': "ast";
-    readonly 'search.similarityThreshold': 0.6;
     readonly 'search.defaultLimit': 5;
     readonly 'search.maxLimit': 20;
     readonly 'reranker.enabled': true;
@@ -97,54 +84,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;