codesearch-mcp 0.0.17-alpha.1 → 0.1.0-alpha

package/dist/src/commands/WebCommand.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebCommand = void 0;
+const WebServerService_1 = require("../services/WebServerService");
+const DEFAULT_PORT = 4319;
+class WebCommand {
+    container;
+    port;
+    constructor(container, args = []) {
+        this.container = container;
+        this.port = parsePort(args) ?? DEFAULT_PORT;
+    }
+    async execute() {
+        const { db, searcher, config, logger, embedder } = this.container;
+        try {
+            await db.initDb();
+        }
+        catch (err) {
+            const reason = err instanceof Error ? err.message : String(err);
+            logger.error('WebCommand: database connection failed', { reason });
+            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';
+        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 });
+            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);
+            process.once('SIGTERM', shutdown);
+        });
+    }
+}
+exports.WebCommand = WebCommand;
+function parsePort(args) {
+    const i = args.indexOf('--port');
+    if (i === -1)
+        return undefined;
+    const raw = args[i + 1];
+    const n = Number(raw);
+    if (!raw || !Number.isInteger(n) || n < 1 || n > 65535) {
+        throw new Error(`Invalid --port value: ${raw ?? '(missing)'}`);
+    }
+    return n;
+}

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

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 export declare const CONFIG_DIR: string;
 export declare const CONFIG_FILE: string;
+export declare const SCHEMA_FILE: string;
+export declare const ENV_FILE: string;
 declare const jsonSchema: z.ZodObject<{
     db: z.ZodOptional<z.ZodObject<{
         host: z.ZodOptional<z.ZodString>;
@@ -9,25 +11,41 @@ declare const jsonSchema: z.ZodObject<{
         password: z.ZodOptional<z.ZodString>;
         name: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
-    ollama: z.ZodOptional<z.ZodObject<{
-        host: z.ZodOptional<z.ZodString>;
+    embedding: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodOptional<z.ZodEnum<{
+            ollama: "ollama";
+            "openai-compatible": "openai-compatible";
+            voyage: "voyage";
+            infinity: "infinity";
+        }>>;
+        baseURL: z.ZodOptional<z.ZodString>;
+        apiKey: z.ZodOptional<z.ZodString>;
         model: z.ZodOptional<z.ZodString>;
+        dimensions: z.ZodOptional<z.ZodNumber>;
+        batchSize: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     indexing: z.ZodOptional<z.ZodObject<{
         chunkSize: z.ZodOptional<z.ZodNumber>;
         chunkOverlap: z.ZodOptional<z.ZodNumber>;
         embedBatchSize: z.ZodOptional<z.ZodNumber>;
         astBatchSize: z.ZodOptional<z.ZodNumber>;
+        chunkStrategy: z.ZodOptional<z.ZodEnum<{
+            ast: "ast";
+            character: "character";
+        }>>;
     }, z.core.$strip>>;
     search: z.ZodOptional<z.ZodObject<{
         similarityThreshold: z.ZodOptional<z.ZodNumber>;
         defaultLimit: z.ZodOptional<z.ZodNumber>;
         maxLimit: z.ZodOptional<z.ZodNumber>;
-        autoTranslate: z.ZodOptional<z.ZodBoolean>;
-        translateModel: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     reranker: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
+        provider: z.ZodOptional<z.ZodEnum<{
+            "openai-compatible": "openai-compatible";
+        }>>;
+        baseURL: z.ZodOptional<z.ZodString>;
+        apiKey: z.ZodOptional<z.ZodString>;
         model: z.ZodOptional<z.ZodString>;
         url: z.ZodOptional<z.ZodString>;
         overfetch: z.ZodOptional<z.ZodNumber>;
@@ -45,8 +63,71 @@ declare const jsonSchema: z.ZodObject<{
 }, 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': "ollama";
+    readonly 'embedding.apiKey': "";
+    readonly 'embedding.model': "bge-m3";
+    readonly 'embedding.batchSize': 32;
+    readonly 'indexing.chunkSize': 1500;
+    readonly 'indexing.chunkOverlap': 200;
+    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': false;
+    readonly 'reranker.provider': "openai-compatible";
+    readonly 'reranker.apiKey': "";
+    readonly 'reranker.model': "";
+    readonly 'reranker.overfetch': 3;
+    readonly 'logging.level': "error";
+};
 export declare function readConfigJson(): JsonConfig | null;
+/**
+ * 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.
+ *
+ * - Legacy `ollama.host`/`ollama.model` → `embedding.{baseURL,model}` with
+ *   `provider: 'ollama'` (only when `embedding` is not already present).
+ * - 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.
+ *
+ * `ollama` itself is left for the schema to strip. Exported for unit testing.
+ */
+export declare function migrateRawConfig(raw: unknown): unknown;
+/**
+ * Validate a parsed config object against the Zod schema. Unknown keys (e.g.
+ * the "$schema" editor reference) are stripped. Throws with a caller-friendly
+ * message on validation failure. 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;
 export declare function deleteNestedValue(cfg: JsonConfig, key: string): JsonConfig;

package/dist/src/config-store.js

@@ -33,9 +33,13 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ALL_KEYS = exports.CONFIG_FILE = exports.CONFIG_DIR = void 0;
+exports.CONFIG_DEFAULTS = exports.ALL_KEYS = exports.ENV_FILE = exports.SCHEMA_FILE = exports.CONFIG_FILE = exports.CONFIG_DIR = void 0;
 exports.readConfigJson = readConfigJson;
+exports.migrateRawConfig = migrateRawConfig;
+exports.parseConfig = parseConfig;
+exports.buildJsonSchema = buildJsonSchema;
 exports.writeConfigJson = writeConfigJson;
+exports.writeSchemaFile = writeSchemaFile;
 exports.getNestedValue = getNestedValue;
 exports.setNestedValue = setNestedValue;
 exports.deleteNestedValue = deleteNestedValue;
@@ -43,45 +47,58 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const zod_1 = require("zod");
+const constants_1 = require("./constants");
 exports.CONFIG_DIR = path.join(os.homedir(), '.config', 'codesearch-mcp');
 exports.CONFIG_FILE = path.join(exports.CONFIG_DIR, 'config.json');
+exports.SCHEMA_FILE = path.join(exports.CONFIG_DIR, 'config.schema.json');
+exports.ENV_FILE = path.join(exports.CONFIG_DIR, '.env');
+// Relative $schema reference written into config.json so editors resolve the
+// sibling schema file for autocomplete / inline validation.
+const SCHEMA_REF = './config.schema.json';
 // All fields optional — defaults live in config.ts. The file stays minimal.
+// Descriptions surface as tooltips in schema-aware editors (VS Code, JetBrains).
 const jsonSchema = zod_1.z.object({
     db: zod_1.z.object({
-        host: zod_1.z.string().optional(),
-        port: zod_1.z.number().optional(),
-        user: zod_1.z.string().optional(),
-        password: zod_1.z.string().optional(),
-        name: zod_1.z.string().optional(),
+        host: zod_1.z.string().describe('PostgreSQL host').optional(),
+        port: zod_1.z.number().int().describe('PostgreSQL port (default 5433)').optional(),
+        user: zod_1.z.string().describe('PostgreSQL user').optional(),
+        password: zod_1.z.string().describe('PostgreSQL password').optional(),
+        name: zod_1.z.string().describe('Database name; defaults to rag_<os-username>, auto-created on first run').optional(),
     }).optional(),
-    ollama: zod_1.z.object({
-        host: zod_1.z.string().optional(),
-        model: zod_1.z.string().optional(),
+    embedding: zod_1.z.object({
+        provider: zod_1.z.enum(['ollama', 'openai-compatible', 'voyage', 'infinity']).describe('Embedding backend (default ollama)').optional(),
+        baseURL: zod_1.z.string().describe('Backend base URL. ollama: http://localhost:11434 · OpenAI: https://api.openai.com/v1 · Infinity/TEI/vLLM: http://localhost:7997 · Voyage: https://api.voyageai.com/v1').optional(),
+        apiKey: zod_1.z.string().describe('API key. Use env:VAR_NAME to read from ~/.config/codesearch-mcp/.env or the environment (recommended). Empty for local servers.').optional(),
+        model: zod_1.z.string().describe('Embedding model (default bge-m3)').optional(),
+        dimensions: zod_1.z.number().int().describe('Vector width override; required for models whose native width exceeds 2000 (Matryoshka reduction). Omit to derive from the model/registry/probe.').optional(),
+        batchSize: zod_1.z.number().int().describe('Texts per batch embedding request (default 32)').optional(),
     }).optional(),
     indexing: zod_1.z.object({
-        chunkSize: zod_1.z.number().optional(),
-        chunkOverlap: zod_1.z.number().optional(),
-        embedBatchSize: zod_1.z.number().optional(),
-        astBatchSize: zod_1.z.number().optional(),
+        chunkSize: zod_1.z.number().int().describe('Max chars per chunk (default 1500)').optional(),
+        chunkOverlap: zod_1.z.number().int().describe('Overlap between chunks (default 200)').optional(),
+        embedBatchSize: zod_1.z.number().int().describe('Rows per DB-insert batch when writing chunks (default 5). Embedding request size is embedding.batchSize.').optional(),
+        astBatchSize: zod_1.z.number().int().describe('Max files per ts-morph batch; larger projects skip dependency resolution (default 3000)').optional(),
+        chunkStrategy: zod_1.z.enum(['ast', 'character']).describe('How TS/JS files are chunked: ast = symbol-aligned boundaries, character = fixed-size recursive splitter (default ast)').optional(),
     }).optional(),
     search: zod_1.z.object({
-        similarityThreshold: zod_1.z.number().optional(),
-        defaultLimit: zod_1.z.number().optional(),
-        maxLimit: zod_1.z.number().optional(),
-        autoTranslate: zod_1.z.boolean().optional(),
-        translateModel: zod_1.z.string().optional(),
+        similarityThreshold: zod_1.z.number().min(0).max(1).describe('Max cosine distance 0–1; lower = stricter (default 0.6)').optional(),
+        defaultLimit: zod_1.z.number().int().describe('Default result count (default 5)').optional(),
+        maxLimit: zod_1.z.number().int().describe('Hard cap on results (default 20)').optional(),
     }).optional(),
     reranker: zod_1.z.object({
-        enabled: zod_1.z.boolean().optional(),
-        model: zod_1.z.string().optional(),
-        url: zod_1.z.string().optional(),
-        overfetch: zod_1.z.number().int().min(1).max(20).optional(),
+        enabled: zod_1.z.boolean().describe('Enable cross-encoder reranking; requires reranker.model').optional(),
+        provider: zod_1.z.enum(['openai-compatible']).describe('Rerank backend. Only openai-compatible /rerank servers (Infinity, TEI, vLLM) — Ollama has no rerank API.').optional(),
+        baseURL: zod_1.z.string().describe('Rerank server base URL (defaults to embedding.baseURL — Infinity serves both).').optional(),
+        apiKey: zod_1.z.string().describe('API key, or env:VAR_NAME. Empty for local servers.').optional(),
+        model: zod_1.z.string().describe('Reranker model name (e.g. qllama/bge-reranker-v2-m3)').optional(),
+        url: zod_1.z.string().describe('Full URL of the rerank endpoint (default derived from provider + baseURL)').optional(),
+        overfetch: zod_1.z.number().int().min(1).max(20).describe('Candidate multiplier before reranking (limit × N, default 3)').optional(),
     }).optional(),
     logging: zod_1.z.object({
-        level: zod_1.z.enum(['debug', 'info', 'warn', 'error']).optional(),
-        dir: zod_1.z.string().optional(),
+        level: zod_1.z.enum(['debug', 'info', 'warn', 'error']).describe('File log level (default error)').optional(),
+        dir: zod_1.z.string().describe('Base log directory; "false" to disable file logging').optional(),
     }).optional(),
-    workspaceRoot: zod_1.z.string().optional(),
+    workspaceRoot: zod_1.z.string().describe('Full path to the directory containing all your projects').optional(),
 });
 const FIELD_TYPES = {
     'db.host': 'string',
@@ -89,18 +106,24 @@ const FIELD_TYPES = {
     'db.user': 'string',
     'db.password': 'string',
     'db.name': 'string',
-    'ollama.host': 'string',
-    'ollama.model': 'string',
+    'embedding.provider': 'string',
+    'embedding.baseURL': 'string',
+    'embedding.apiKey': 'string',
+    'embedding.model': 'string',
+    'embedding.dimensions': 'number',
+    'embedding.batchSize': 'number',
     'indexing.chunkSize': 'number',
     'indexing.chunkOverlap': 'number',
     'indexing.embedBatchSize': 'number',
     'indexing.astBatchSize': 'number',
+    'indexing.chunkStrategy': 'string',
     'search.similarityThreshold': 'number',
     'search.defaultLimit': 'number',
     'search.maxLimit': 'number',
-    'search.autoTranslate': 'boolean',
-    'search.translateModel': 'string',
     'reranker.enabled': 'boolean',
+    'reranker.provider': 'string',
+    'reranker.baseURL': 'string',
+    'reranker.apiKey': 'string',
     'reranker.model': 'string',
     'reranker.url': 'string',
     'reranker.overfetch': 'number',
@@ -109,6 +132,39 @@ const FIELD_TYPES = {
     'workspaceRoot': 'string',
 };
 exports.ALL_KEYS = Object.keys(FIELD_TYPES);
+/**
+ * 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(...)`.
+ */
+exports.CONFIG_DEFAULTS = {
+    'db.port': 5433,
+    'embedding.provider': 'ollama',
+    'embedding.apiKey': '',
+    'embedding.model': constants_1.DEFAULT_EMBED_MODEL,
+    'embedding.batchSize': 32,
+    'indexing.chunkSize': 1500,
+    'indexing.chunkOverlap': 200,
+    'indexing.embedBatchSize': 5,
+    'indexing.astBatchSize': 3000,
+    'indexing.chunkStrategy': 'ast',
+    'search.similarityThreshold': 0.6,
+    'search.defaultLimit': 5,
+    'search.maxLimit': 20,
+    'reranker.enabled': false,
+    'reranker.provider': 'openai-compatible',
+    'reranker.apiKey': '',
+    'reranker.model': '',
+    'reranker.overfetch': 3,
+    'logging.level': 'error',
+};
 function readConfigJson() {
     if (!fs.existsSync(exports.CONFIG_FILE))
         return null;
@@ -127,17 +183,86 @@ function readConfigJson() {
         throw new Error(`Invalid JSON in ${exports.CONFIG_FILE}: ${e.message}\n` +
             `Fix the file manually or delete it and run: rag-setup`);
     }
-    const result = jsonSchema.safeParse(parsed);
+    return parseConfig(migrateRawConfig(parsed), exports.CONFIG_FILE);
+}
+/**
+ * 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.
+ *
+ * - Legacy `ollama.host`/`ollama.model` → `embedding.{baseURL,model}` with
+ *   `provider: 'ollama'` (only when `embedding` is not already present).
+ * - 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.
+ *
+ * `ollama` itself is left for the schema to strip. Exported for unit testing.
+ */
+function migrateRawConfig(raw) {
+    if (raw == null || typeof raw !== 'object')
+        return raw;
+    const obj = JSON.parse(JSON.stringify(raw));
+    const legacyOllama = obj.ollama;
+    if (!obj.embedding && legacyOllama && typeof legacyOllama === 'object') {
+        const embedding = { provider: 'ollama' };
+        if (typeof legacyOllama.host === 'string')
+            embedding.baseURL = legacyOllama.host;
+        if (typeof legacyOllama.model === 'string')
+            embedding.model = legacyOllama.model;
+        obj.embedding = embedding;
+    }
+    delete obj.ollama;
+    if (obj.search && typeof obj.search === 'object') {
+        delete obj.search.autoTranslate;
+        delete obj.search.translateModel;
+    }
+    if (obj.reranker && typeof obj.reranker === 'object') {
+        if (obj.reranker.provider === 'ollama')
+            obj.reranker.provider = 'openai-compatible';
+        if (typeof obj.reranker.url === 'string' && /\/api\/rerank\/?(\?.*)?$/.test(obj.reranker.url))
+            delete obj.reranker.url;
+    }
+    return obj;
+}
+/**
+ * Validate a parsed config object against the Zod schema. Unknown keys (e.g.
+ * the "$schema" editor reference) are stripped. Throws with a caller-friendly
+ * message on validation failure. Pure — no file I/O.
+ */
+function parseConfig(raw, source = exports.CONFIG_FILE) {
+    const result = jsonSchema.safeParse(raw);
     if (!result.success) {
         const issues = result.error.issues.map(i => `  ${i.path.join('.')}: ${i.message}`).join('\n');
-        throw new Error(`Invalid config in ${exports.CONFIG_FILE}:\n${issues}\n` +
+        throw new Error(`Invalid config in ${source}:\n${issues}\n` +
             `Fix with: rag-config set <key> <value>`);
     }
     return result.data;
 }
+/** Build the JSON Schema object generated from the Zod config schema. Pure. */
+function buildJsonSchema() {
+    return {
+        $id: 'https://github.com/oleksandr-antoniuk/RAG/config.schema.json',
+        title: 'codesearch-mcp config',
+        ...zod_1.z.toJSONSchema(jsonSchema),
+    };
+}
 function writeConfigJson(data) {
     fs.mkdirSync(exports.CONFIG_DIR, { recursive: true });
-    fs.writeFileSync(exports.CONFIG_FILE, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
+    writeSchemaFile();
+    // $schema first so editors pick it up; readConfigJson strips it on validation.
+    const withSchema = { $schema: SCHEMA_REF, ...data };
+    fs.writeFileSync(exports.CONFIG_FILE, JSON.stringify(withSchema, null, 2) + '\n', { mode: 0o600 });
+}
+/**
+ * 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.
+ */
+function writeSchemaFile() {
+    fs.mkdirSync(exports.CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(exports.SCHEMA_FILE, JSON.stringify(buildJsonSchema(), null, 2) + '\n');
 }
 function getNestedValue(cfg, key) {
     const parts = key.split('.');

package/dist/src/config.d.ts

@@ -1,6 +1,14 @@
 export declare class ConfigError extends Error {
     constructor(message: string);
 }
+/**
+ * Resolve a config value that may reference an environment variable. A value of
+ * the form `env:VAR_NAME` resolves to `process.env.VAR_NAME`; any other string
+ * (including empty) is returned verbatim. A referenced-but-unset variable throws
+ * a clear error naming the variable and the `.env` file. Pure aside from the
+ * injected env map. See `src/app.ts` for how `.env` is loaded into the process.
+ */
+export declare function resolveEnvRef(value: string, env?: NodeJS.ProcessEnv): string;
 export declare class Config {
     private readonly data;
     get db(): {
@@ -10,26 +18,42 @@ export declare class Config {
         password: string;
         database: string;
     };
-    get ollama(): {
-        host: string;
+    /**
+     * Embedding config. `apiKey` is returned **raw** (possibly an `env:VAR` ref) —
+     * callers resolve it lazily via `resolveEnvRef` at the moment they build a
+     * request, so an unset referenced variable fails only when the key is actually
+     * needed (during embed/search) rather than crashing container construction and
+     * locking the user out of `rag-web`/`rag-mcp`.
+     */
+    get embedding(): {
+        provider: "ollama" | "openai-compatible" | "voyage" | "infinity";
+        baseURL: string;
+        apiKey: string;
+        model: string;
+        dimensions: number | null;
+        batchSize: number;
+    };
+    /** Reranker config. `apiKey` is raw — resolve lazily with `resolveEnvRef`. */
+    get reranker(): {
+        enabled: boolean;
+        provider: "openai-compatible";
+        baseURL: string;
+        apiKey: string;
         model: string;
-        rerankerModel: string;
-        rerankerUrl: string;
+        url: string;
+        overfetch: number;
     };
     get indexer(): {
         chunkSize: number;
         chunkOverlap: number;
         batchSize: number;
         astBatchSize: number;
+        chunkStrategy: "ast" | "character";
     };
     get search(): {
         similarityThreshold: number;
         defaultLimit: number;
         maxLimit: number;
-        autoTranslate: boolean;
-        translateModel: string;
-        rerankerEnabled: boolean;
-        rerankerOverfetch: number;
     };
     get logging(): {
         level: "error" | "debug" | "info" | "warn";