codesearch-mcp 0.1.0-alpha → 0.2.1-alpha

package/dist/src/services/infinity-provisioning.js

@@ -0,0 +1,516 @@
+"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.serverRoot = serverRoot;
+exports.probeInfinityHealth = probeInfinityHealth;
+exports.listInfinityModels = listInfinityModels;
+exports.sameServer = sameServer;
+exports.isManagedInfinity = isManagedInfinity;
+exports.extractModelIdValue = extractModelIdValue;
+exports.atomicWriteFile = atomicWriteFile;
+exports.writeComposeModelSet = writeComposeModelSet;
+exports.hasNvidiaGpu = hasNvidiaGpu;
+exports.composeFileArgs = composeFileArgs;
+exports.evaluateBackend = evaluateBackend;
+exports.manualInstructionMessage = manualInstructionMessage;
+exports.ensureBackendReady = ensureBackendReady;
+exports.ensureModelSetServed = ensureModelSetServed;
+exports.requiredModelSet = requiredModelSet;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+/**
+ * Strip trailing slashes and a trailing `/embeddings` or `/v1` to get the server
+ * root — Infinity serves `/health`, `/models`, `/rerank`, `/embeddings` from the
+ * root, so a baseURL written with an OpenAI-style suffix must be normalized here
+ * to keep the probe/models URLs aligned with the embeddings URL.
+ */
+function serverRoot(baseURL) {
+    return baseURL.replace(/\/+$/, '').replace(/\/(embeddings|v1)$/, '');
+}
+/**
+ * Probe an Infinity-style `/health` endpoint. Resolves `true` when the server
+ * answers with a 2xx, `false` on any error, non-2xx, or timeout.
+ */
+async function probeInfinityHealth(baseURL, fetchImpl = fetch, timeoutMs = 2000) {
+    try {
+        const res = await fetchImpl(`${serverRoot(baseURL)}/health`, {
+            method: 'GET',
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * List the model ids an Infinity server currently serves via its OpenAI-style
+ * `/models` listing (`{ data: [{ id }] }`). Returns `[]` on any error, non-2xx,
+ * or timeout — callers treat an empty/unverifiable listing as "served".
+ */
+async function listInfinityModels(baseURL, fetchImpl = fetch, timeoutMs = 2000) {
+    try {
+        const res = await fetchImpl(`${serverRoot(baseURL)}/models`, {
+            method: 'GET',
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!res.ok)
+            return [];
+        const data = await res.json();
+        return (data.data ?? []).map(m => m.id).filter((id) => Boolean(id));
+    }
+    catch {
+        return [];
+    }
+}
+// ---------------------------------------------------------------------------
+// Compose-file parsing — deliberately line-based, not a YAML library: we only
+// ever make targeted, well-anchored edits to our own shipped template, and
+// need "every other byte unchanged" — a round-trip through a YAML AST would
+// not guarantee that.
+// ---------------------------------------------------------------------------
+/** [start, end) line range of a top-level `services:` entry (2-space indent), or null if absent. */
+function findServiceBlock(lines, serviceName) {
+    const headerRe = new RegExp(`^  ${serviceName}:\\s*$`);
+    const start = lines.findIndex(l => headerRe.test(l));
+    if (start === -1)
+        return null;
+    let end = lines.length;
+    for (let i = start + 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.trim() === '')
+            continue;
+        if (/^\S/.test(line) || /^  \S/.test(line)) {
+            end = i;
+            break;
+        }
+    }
+    return [start, end];
+}
+/** Extract a published host port from one `ports:` list item's raw line(s), or null if unrecognised. */
+function parsePortItem(item) {
+    if (item.length === 1) {
+        const raw = item[0].replace(/^["']|["']$/g, '').trim();
+        // Short form: "HOST:CONTAINER" or "IP:HOST:CONTAINER" (optional /tcp|/udp).
+        const m = raw.match(/^(?:(?:\[[0-9a-fA-F:]+\]|[0-9.]+):)?(\d+):(\d+)(?:\/(?:tcp|udp))?$/);
+        return m ? m[1] : null;
+    }
+    // Long form block ("- target: 7997\n  published: 7997\n  protocol: tcp").
+    for (const line of item) {
+        const m = line.match(/published:\s*["']?(\d+)["']?/);
+        if (m)
+            return m[1];
+    }
+    return null;
+}
+/** Published host port of a service's `ports:` entries within `serviceLines`, or null if none/unrecognised. */
+function extractPublishedPort(serviceLines) {
+    const portsIdx = serviceLines.findIndex(l => /^\s*ports:\s*$/.test(l));
+    if (portsIdx === -1)
+        return null;
+    const portsIndent = serviceLines[portsIdx].match(/^(\s*)/)[1].length;
+    const items = [];
+    let cur = null;
+    for (let i = portsIdx + 1; i < serviceLines.length; i++) {
+        const line = serviceLines[i];
+        if (line.trim() === '')
+            continue;
+        const indent = line.match(/^(\s*)/)[1].length;
+        if (indent <= portsIndent)
+            break;
+        const itemStart = line.match(/^(\s*)-\s?(.*)$/);
+        if (itemStart && itemStart[1].length === indent) {
+            cur = [itemStart[2]];
+            items.push(cur);
+        }
+        else if (cur) {
+            cur.push(line.trim());
+        }
+    }
+    for (const item of items) {
+        const port = parsePortItem(item);
+        if (port != null)
+            return port;
+    }
+    return null;
+}
+function loopbackHost(hostname) {
+    const h = hostname.replace(/^\[|\]$/g, '');
+    return h === 'localhost' || h === '127.0.0.1' || h === '::1';
+}
+function normalizedHost(hostname) {
+    return loopbackHost(hostname) ? '\0loopback' : hostname.toLowerCase();
+}
+function schemeDefaultPort(protocol) {
+    return protocol === 'https:' ? '443' : '80';
+}
+/**
+ * Two URLs target the same server when scheme, (loopback-normalised) host, and
+ * port (explicit or scheme default) all match; path is ignored. An unparsable
+ * URL is never the same server as another.
+ */
+function sameServer(a, b) {
+    try {
+        const ua = new URL(a);
+        const ub = new URL(b);
+        if (ua.protocol !== ub.protocol)
+            return false;
+        if (normalizedHost(ua.hostname) !== normalizedHost(ub.hostname))
+            return false;
+        const pa = ua.port || schemeDefaultPort(ua.protocol);
+        const pb = ub.port || schemeDefaultPort(ub.protocol);
+        return pa === pb;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * "Managed" per the managed-vs-external requirement: the compose file exists,
+ * declares an `infinity` service, the base URL host is loopback, and its port
+ * (explicit or scheme default) equals the service's published host port.
+ * Never throws — an unreadable/unparsable file or an unrecognised port form
+ * is simply "external".
+ */
+function isManagedInfinity(baseURL, composePath) {
+    try {
+        let url;
+        try {
+            url = new URL(baseURL);
+        }
+        catch {
+            return false;
+        }
+        if (!loopbackHost(url.hostname))
+            return false;
+        const content = fs.readFileSync(composePath, 'utf-8');
+        const lines = content.split(/\r?\n/);
+        const block = findServiceBlock(lines, 'infinity');
+        if (!block)
+            return false;
+        const publishedPort = extractPublishedPort(lines.slice(block[0] + 1, block[1]));
+        if (publishedPort == null)
+            return false;
+        const effectivePort = url.port || schemeDefaultPort(url.protocol);
+        return effectivePort === publishedPort;
+    }
+    catch {
+        return false;
+    }
+}
+/** The literal (non-`${…}`) `INFINITY_MODEL_ID` value in the compose file's `infinity` service, or null. */
+function extractModelIdValue(composeContent) {
+    const lines = composeContent.split(/\r?\n/);
+    const block = findServiceBlock(lines, 'infinity');
+    if (!block)
+        return null;
+    for (let i = block[0] + 1; i < block[1]; i++) {
+        const m = lines[i].match(/^\s*INFINITY_MODEL_ID:\s*(.*)\s*$/);
+        if (m) {
+            const v = m[1].trim().replace(/^["']|["']$/g, '');
+            return v && !v.startsWith('${') ? v : null;
+        }
+    }
+    return null;
+}
+/** Write `content` to `targetPath` via a same-directory temp file + rename; removes the temp file on failure. */
+function atomicWriteFile(targetPath, content, mode) {
+    const dir = path.dirname(targetPath);
+    const tmpPath = path.join(dir, `.${path.basename(targetPath)}.tmp-${process.pid}-${Date.now()}`);
+    try {
+        fs.writeFileSync(tmpPath, content, { mode });
+        fs.renameSync(tmpPath, targetPath);
+    }
+    catch (err) {
+        try {
+            fs.unlinkSync(tmpPath);
+        }
+        catch { /* best effort cleanup */ }
+        throw err;
+    }
+}
+/**
+ * Write `modelSet` (embedding model first) as the literal `INFINITY_MODEL_ID`
+ * of the compose file's `infinity` service, and remove a `profiles:` entry of
+ * that service if present (a file written by an earlier version). At most
+ * those two targeted edits — every other byte unchanged. Atomic (temp file +
+ * rename), keeps the original file's mode. Throws (no write, original file
+ * unchanged) when the file cannot be read, has no `infinity` service, has no
+ * `INFINITY_MODEL_ID:` line, or the write itself fails.
+ */
+function writeComposeModelSet(composePath, modelSet) {
+    let content;
+    let mode;
+    try {
+        content = fs.readFileSync(composePath, 'utf-8');
+        mode = fs.statSync(composePath).mode;
+    }
+    catch (err) {
+        throw new Error(`Cannot read managed compose file at ${composePath}: ${err.message}`);
+    }
+    const newline = content.includes('\r\n') ? '\r\n' : '\n';
+    const lines = content.split(/\r?\n/);
+    const block = findServiceBlock(lines, 'infinity');
+    if (!block)
+        throw new Error(`No "infinity" service found in ${composePath}; cannot write the model set.`);
+    const [start, end] = block;
+    let modelIdLineIdx = -1;
+    for (let i = start + 1; i < end; i++) {
+        if (/^\s*INFINITY_MODEL_ID:/.test(lines[i])) {
+            modelIdLineIdx = i;
+            break;
+        }
+    }
+    if (modelIdLineIdx === -1) {
+        throw new Error(`No "INFINITY_MODEL_ID:" line found in the infinity service of ${composePath}; cannot write the model set.`);
+    }
+    const indent = lines[modelIdLineIdx].match(/^(\s*)/)[1];
+    lines[modelIdLineIdx] = `${indent}INFINITY_MODEL_ID: "${modelSet.join(';')}"`;
+    let profilesStart = -1;
+    for (let i = start + 1; i < end; i++) {
+        if (/^\s*profiles:\s*$/.test(lines[i])) {
+            profilesStart = i;
+            break;
+        }
+    }
+    let outLines = lines;
+    if (profilesStart !== -1) {
+        const profIndent = lines[profilesStart].match(/^(\s*)/)[1].length;
+        let profilesEnd = profilesStart + 1;
+        while (profilesEnd < end) {
+            const l = lines[profilesEnd];
+            if (l.trim() === '') {
+                profilesEnd++;
+                continue;
+            }
+            const ind = l.match(/^(\s*)/)[1].length;
+            if (ind <= profIndent)
+                break;
+            profilesEnd++;
+        }
+        outLines = [...lines.slice(0, profilesStart), ...lines.slice(profilesEnd)];
+    }
+    try {
+        atomicWriteFile(composePath, outLines.join(newline), mode);
+    }
+    catch (err) {
+        throw new Error(`Failed to write managed compose file at ${composePath}: ${err.message}`);
+    }
+}
+/** True when an NVIDIA GPU + `nvidia-smi` is available on this host. */
+function hasNvidiaGpu() {
+    try {
+        return (0, child_process_1.spawnSync)('nvidia-smi', ['-L'], { stdio: 'ignore' }).status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+function gpuOverridePath(composePath) {
+    return path.join(path.dirname(composePath), 'docker-compose.infinity-gpu.yml');
+}
+/** The `-f` file args a docker compose invocation against `composePath` should use (base, plus GPU override when present + detected). */
+function composeFileArgs(composePath) {
+    const gpu = gpuOverridePath(composePath);
+    return (fs.existsSync(gpu) && hasNvidiaGpu()) ? ['-f', composePath, '-f', gpu] : ['-f', composePath];
+}
+function defaultRunCommand(cmd, args) {
+    const r = (0, child_process_1.spawnSync)(cmd, args, { encoding: 'utf-8' });
+    return { status: r.status, stdout: r.stdout ?? undefined, stderr: r.stderr ?? undefined };
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/** Parse `docker compose ps --all --format json` output (JSON-lines, or an array) for the `infinity` service's state. */
+function parseInfinityState(stdout) {
+    const readState = (obj) => {
+        const s = String(obj?.State ?? '').toLowerCase();
+        return (s === 'running' || s === 'exited' || s === 'dead' || s === 'restarting') ? s : 'other';
+    };
+    for (const line of stdout.split(/\r?\n/).map(l => l.trim()).filter(Boolean)) {
+        try {
+            const obj = JSON.parse(line);
+            if (obj?.Service === 'infinity')
+                return readState(obj);
+        }
+        catch { /* not a JSON-lines entry — fall through to array parsing below */ }
+    }
+    try {
+        const arr = JSON.parse(stdout);
+        if (Array.isArray(arr)) {
+            const svc = arr.find((o) => o?.Service === 'infinity');
+            if (svc)
+                return readState(svc);
+        }
+    }
+    catch { /* not an array either */ }
+    return 'missing';
+}
+/**
+ * Wait for `/health` after a start/recreate, failing fast on a crashed or
+ * restart-looping container instead of waiting out the full timeout, then
+ * re-check the models listing once more. Poll interval capped at 5s.
+ */
+async function waitForReady(base, files, modelSetToWrite, requiredModels, deps) {
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const runCommand = deps.runCommand ?? defaultRunCommand;
+    const pollIntervalMs = Math.min(deps.pollIntervalMs ?? 2000, 5000);
+    const timeoutMs = deps.readinessTimeoutMs ?? 1_800_000;
+    const deadline = Date.now() + timeoutMs;
+    let consecutiveRestarting = 0;
+    for (;;) {
+        if (await probeInfinityHealth(base, fetchImpl, 2000))
+            break;
+        const ps = runCommand('docker', ['compose', ...files, 'ps', '--all', '--format', 'json']);
+        if (ps.status === 0) {
+            const state = parseInfinityState(ps.stdout ?? '');
+            if (state === 'exited' || state === 'dead' || state === 'missing') {
+                throw new Error(`Infinity container ${state === 'missing' ? 'is no longer listed' : `crashed (state: ${state})`} while loading ` +
+                    `model set [${modelSetToWrite.join(', ')}]. Check: docker compose logs infinity`);
+            }
+            if (state === 'restarting') {
+                consecutiveRestarting++;
+                if (consecutiveRestarting >= 2) {
+                    throw new Error(`Infinity container is restart-looping while loading model set [${modelSetToWrite.join(', ')}] ` +
+                        `(a model id is likely invalid or unloadable). Check: docker compose logs infinity`);
+                }
+            }
+            else {
+                consecutiveRestarting = 0;
+            }
+        }
+        // A failing `ps` is ignored — neither counts toward nor resets the restarting streak.
+        if (Date.now() >= deadline) {
+            throw new Error(`Infinity did not become ready within ${Math.round(timeoutMs / 1000)}s at ${base}.`);
+        }
+        await sleep(pollIntervalMs);
+    }
+    const served = await listInfinityModels(base, fetchImpl, 2000);
+    const missing = served.length > 0 ? requiredModels.filter(m => !served.includes(m)) : [];
+    if (missing.length > 0) {
+        throw new Error(`Infinity at ${base} became ready but its listing [${served.join(', ')}] still omits required model(s) ` +
+            `[${missing.join(', ')}]. Check the model id(s) — the container is still running.`);
+    }
+}
+async function recreateAndWait(base, composePath, modelSetToWrite, requiredModels, deps) {
+    writeComposeModelSet(composePath, modelSetToWrite);
+    const files = composeFileArgs(composePath);
+    const runCommand = deps.runCommand ?? defaultRunCommand;
+    const result = runCommand('docker', ['compose', ...files, 'up', '-d', '--force-recreate', 'infinity']);
+    if (result.status !== 0) {
+        const cause = result.status === null
+            ? 'the "docker" binary was not found'
+            : `docker compose exited with status ${result.status}${result.stderr ? `: ${result.stderr.trim()}` : ''}`;
+        throw new Error(`Failed to start the managed Infinity container (${cause}). Ensure Docker is installed and running.`);
+    }
+    await waitForReady(base, files, modelSetToWrite, requiredModels, deps);
+}
+/**
+ * Classify the backend against `requiredModels` without touching Docker:
+ * reachable+served (or unverifiable listing) → `served`; reachable+missing →
+ * `missing-managed`/`missing-external`; unreachable → `unreachable-managed`/
+ * `unreachable-external`. Shared by `ensureBackendReady`, the web-dashboard
+ * decision table, and `rag-setup`'s declined-Docker branch.
+ */
+async function evaluateBackend(baseURL, composePath, requiredModels, deps = {}) {
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const base = serverRoot(baseURL);
+    const managed = isManagedInfinity(baseURL, composePath);
+    if (await probeInfinityHealth(base, fetchImpl, 2000)) {
+        const served = await listInfinityModels(base, fetchImpl, 2000);
+        const missingModels = served.length === 0 ? [] : requiredModels.filter(m => !served.includes(m));
+        if (missingModels.length === 0)
+            return { action: 'served', managed, missingModels: [], servedModels: served };
+        return { action: managed ? 'missing-managed' : 'missing-external', managed, missingModels, servedModels: served };
+    }
+    return { action: managed ? 'unreachable-managed' : 'unreachable-external', managed, missingModels: [], servedModels: [] };
+}
+/** Human-readable manual instructions for a `missing-external`/`unreachable-external` evaluation. */
+function manualInstructionMessage(evaluation, base, modelSetToWrite) {
+    if (evaluation.action === 'missing-external') {
+        return `Infinity at ${base} serves [${evaluation.servedModels.join(', ')}] but is missing [${evaluation.missingModels.join(', ')}]. ` +
+            `Restart the external server with the missing model(s) as additional --model-id arguments, e.g.:\n` +
+            `  --model-id ${modelSetToWrite.join(' --model-id ')}`;
+    }
+    return `Infinity is not reachable at ${base} and no managed container is configured. Start it manually, e.g.:\n` +
+        `  docker run -it --gpus all -p 7997:7997 michaelf34/infinity:latest \\\n` +
+        `    v2 --model-id ${modelSetToWrite.join(';')} --port 7997\n` +
+        `(drop --gpus all to run on CPU), or re-run rag-setup to provision it.`;
+}
+/**
+ * Bring the Infinity backend to a state serving `requiredModels`, per the
+ * managed-vs-external decision tree:
+ *   served                → return (no Docker)
+ *   missing-managed       → recreate (writes modelSetToWrite) + wait
+ *   missing-external      → throw (manual --model-id instructions)
+ *   unreachable-managed   → (re)create + wait
+ *   unreachable-external  → throw (manual launch instructions)
+ */
+async function ensureBackendReady(opts) {
+    const { baseURL, requiredModels, modelSetToWrite, composePath } = opts;
+    const deps = opts.deps ?? {};
+    const base = serverRoot(baseURL);
+    const evaluation = await evaluateBackend(baseURL, composePath, requiredModels, deps);
+    switch (evaluation.action) {
+        case 'served':
+            return;
+        case 'missing-external':
+        case 'unreachable-external':
+            throw new Error(manualInstructionMessage(evaluation, base, modelSetToWrite));
+        case 'missing-managed':
+        case 'unreachable-managed':
+            await recreateAndWait(base, composePath, modelSetToWrite, requiredModels, deps);
+            return;
+    }
+}
+/** `ensureBackendReady` with the full set as both the requirement and the write (rag-setup, web dashboard). */
+async function ensureModelSetServed(baseURL, composePath, modelSet, deps) {
+    return ensureBackendReady({ baseURL, requiredModels: modelSet, modelSetToWrite: modelSet, composePath, deps });
+}
+/**
+ * The model set a managed Infinity container must serve, computed from a
+ * `Config`: the embedding model, followed by the reranker model only when
+ * reranking is enabled with a model on the same server as embeddings (the
+ * effective `reranker.url`, which `Config` has already resolved from an
+ * explicit value or derived from `reranker.baseURL`).
+ */
+function requiredModelSet(cfg) {
+    const set = [cfg.embedding.model];
+    if (cfg.reranker.enabled && cfg.reranker.model && sameServer(cfg.reranker.url, cfg.embedding.baseURL)) {
+        set.push(cfg.reranker.model);
+    }
+    return set;
+}

package/dist/src/services/legacy-ollama-index.d.ts

@@ -0,0 +1,24 @@
+import type { IDatabase } from '../interfaces/IDatabase';
+export interface IndexedIdentity {
+    provider: string;
+    model: string;
+}
+/** A pre-`index_meta` install (populated `code_chunk`, no `index_meta` row) is always this. */
+export declare const LEGACY_OLLAMA_IDENTITY: IndexedIdentity;
+/**
+ * Whether `code_chunk` has at least one row, tolerant only of a missing
+ * table (→ false). Any other database error propagates. Exported so
+ * `SearcherService.assertIndexMatches` can reuse the same strict count
+ * (it reads `index_meta` via the existing lenient `IDatabase.readIndexMeta()`,
+ * but the chunk count must fail loudly on a real DB error).
+ */
+export declare function hasIndexedChunks(db: IDatabase): Promise<boolean>;
+/**
+ * Resolve the "indexed identity" under the shared legacy interpretation used
+ * both by the `rag-index` legacy-Ollama guard and the search-refusal check:
+ * an `index_meta` row wins; absent a row, a populated `code_chunk` is
+ * `ollama`/`bge-m3`; an empty (or altogether absent) DB is `null` — not
+ * Ollama-built, no refusal. Missing tables count as absent/empty; any other
+ * database error propagates rather than being read as "not Ollama-built".
+ */
+export declare function resolveIndexedIdentity(db: IDatabase): Promise<IndexedIdentity | null>;

package/dist/src/services/legacy-ollama-index.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEGACY_OLLAMA_IDENTITY = void 0;
+exports.hasIndexedChunks = hasIndexedChunks;
+exports.resolveIndexedIdentity = resolveIndexedIdentity;
+/** A pre-`index_meta` install (populated `code_chunk`, no `index_meta` row) is always this. */
+exports.LEGACY_OLLAMA_IDENTITY = { provider: 'ollama', model: 'bge-m3' };
+function isMissingTableError(err) {
+    return /does not exist/i.test(err?.message ?? '');
+}
+/**
+ * Read `index_meta`'s (provider, model), tolerant only of a missing table
+ * (→ null, un-migrated DB). Any other database error propagates — unlike
+ * `IDatabase.readIndexMeta()`, which swallows every error into `null`, this
+ * is used where a genuine DB error must fail the caller loudly rather than
+ * be misread as "no row".
+ */
+async function readIndexMetaStrict(db) {
+    try {
+        const rows = await db.query(`SELECT provider, model FROM index_meta LIMIT 1`);
+        const row = rows[0];
+        return row ? { provider: row.provider, model: row.model } : null;
+    }
+    catch (err) {
+        if (isMissingTableError(err))
+            return null;
+        throw err;
+    }
+}
+/**
+ * Whether `code_chunk` has at least one row, tolerant only of a missing
+ * table (→ false). Any other database error propagates. Exported so
+ * `SearcherService.assertIndexMatches` can reuse the same strict count
+ * (it reads `index_meta` via the existing lenient `IDatabase.readIndexMeta()`,
+ * but the chunk count must fail loudly on a real DB error).
+ */
+async function hasIndexedChunks(db) {
+    try {
+        const rows = await db.query(`SELECT COUNT(*)::int AS n FROM code_chunk`);
+        return Number(rows[0]?.n ?? 0) > 0;
+    }
+    catch (err) {
+        if (isMissingTableError(err))
+            return false;
+        throw err;
+    }
+}
+/**
+ * Resolve the "indexed identity" under the shared legacy interpretation used
+ * both by the `rag-index` legacy-Ollama guard and the search-refusal check:
+ * an `index_meta` row wins; absent a row, a populated `code_chunk` is
+ * `ollama`/`bge-m3`; an empty (or altogether absent) DB is `null` — not
+ * Ollama-built, no refusal. Missing tables count as absent/empty; any other
+ * database error propagates rather than being read as "not Ollama-built".
+ */
+async function resolveIndexedIdentity(db) {
+    const meta = await readIndexMetaStrict(db);
+    if (meta)
+        return meta;
+    return (await hasIndexedChunks(db)) ? exports.LEGACY_OLLAMA_IDENTITY : null;
+}

package/dist/src/services/reranker.d.ts

@@ -4,9 +4,9 @@ import type { ILogger } from '../interfaces/ILogger';
  * Build a rerank function from `config.reranker`, or return `undefined` when
  * reranking is disabled / unconfigured. Targets an OpenAI-compatible `/rerank`
  * endpoint returning `{ results: [{ index }] }` (Infinity, TEI, vLLM,
- * Jina/Cohere-shape). Ollama has NO rerank API, so it is not a valid backend
- * here — the embedding provider is independent of the rerank server
- * (`reranker.baseURL`), so Ollama embeddings + an Infinity reranker is fine.
+ * Jina/Cohere-shape). The embedding provider is independent of the rerank
+ * server (`reranker.baseURL`), so e.g. Voyage embeddings + an Infinity
+ * reranker is fine.
  * Returns original indices into `documents`, best-first.
  */
 export declare function makeReranker(config: Config, logger: ILogger, deps?: {

package/dist/src/services/reranker.js

@@ -7,9 +7,9 @@ const http_retry_1 = require("./http-retry");
  * Build a rerank function from `config.reranker`, or return `undefined` when
  * reranking is disabled / unconfigured. Targets an OpenAI-compatible `/rerank`
  * endpoint returning `{ results: [{ index }] }` (Infinity, TEI, vLLM,
- * Jina/Cohere-shape). Ollama has NO rerank API, so it is not a valid backend
- * here — the embedding provider is independent of the rerank server
- * (`reranker.baseURL`), so Ollama embeddings + an Infinity reranker is fine.
+ * Jina/Cohere-shape). The embedding provider is independent of the rerank
+ * server (`reranker.baseURL`), so e.g. Voyage embeddings + an Infinity
+ * reranker is fine.
  * Returns original indices into `documents`, best-first.
  */
 function makeReranker(config, logger, deps = {}) {

package/dist/src/setup.d.ts

@@ -1,8 +1,45 @@
+import { type EmbeddingProvider } from './constants';
+import { Config } from './config';
+import { type ProvisioningDeps } from './services/infinity-provisioning';
 import type { LoggerService } from './services/LoggerService';
+type SetupStep = {
+    q: string;
+    a: string;
+};
+/** Providers the wizard offers, in prompt order; the first is the preselected default. Exported for unit testing. */
+export declare const EMBEDDING_PROVIDER_CHOICES: readonly EmbeddingProvider[];
 /**
  * Default answer for the "start Docker containers?" prompt: no only when both
  * the database and the embedding backend are already reachable. Pure — exported
  * for unit testing.
  */
 export declare function dockerPromptDefault(dbReachable: boolean, embReachable: boolean): 'y' | 'n';
+interface DbDockerOpts {
+    dbPort: string;
+    dbUser: string;
+    dbPass: string;
+    /** Bring up the local db container (skip when a remote db is already reachable). */
+    startDb: boolean;
+    logger?: LoggerService;
+    steps?: SetupStep[];
+}
+/**
+ * Regenerate `CONFIG_DIR/docker-compose.yml` from the shipped template
+ * (carrying over an existing literal `INFINITY_MODEL_ID`, written atomically),
+ * copy the GPU override, and start the DB container when requested. Runs
+ * BEFORE the config file is written — its failure aborts setup unsaved,
+ * matching the existing "abort without saving" behavior of the DB step. Does
+ * NOT touch Infinity provisioning (moved after `writeConfigJson` — see D6a).
+ */
+export declare function prepareComposeAndStartDb(opts: DbDockerOpts): Promise<void>;
+/**
+ * Infinity provisioning (D6a) — runs AFTER the config file is written, so no
+ * outcome here can leave the config unsaved. `savedConfig` is a fresh read of
+ * the just-written file (never the process's own startup config). Exit-status
+ * rules: 0 for served / timeout (warning) / external instructions / declined
+ * Docker; 1 for any other provisioning failure — the cause is printed and the
+ * remaining setup steps (DB schema init) still run.
+ */
+export declare function provisionInfinity(savedConfig: Config, startDocker: boolean, logger?: LoggerService, deps?: ProvisioningDeps, composePathOverride?: string): Promise<void>;
 export declare function runSetup(logger?: LoggerService): Promise<void>;
+export {};