codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

package/dist/src/services/http-retry.js

@@ -14,22 +14,13 @@ exports.HttpError = HttpError;
 function sleep(ms) {
     return ms > 0 ? new Promise(r => setTimeout(r, ms)) : Promise.resolve();
 }
-/** True for transient failures worth retrying (rate limit / server error / network / timeout). */
 function isRetryable(err) {
     if (err instanceof HttpError)
         return err.status === 429 || (err.status >= 500 && err.status <= 599);
-    // A request timeout (AbortSignal.timeout) rejects with a DOMException named
-    // 'TimeoutError' — the most common transient cloud failure, so retry it.
     if (err != null && typeof err === 'object' && err.name === 'TimeoutError')
         return true;
-    // Network-level errors (fetch throws) are transient too.
     return err instanceof TypeError;
 }
-/**
- * Run `fn` with bounded exponential backoff on HTTP 429/5xx and network errors.
- * Re-throws the last error once attempts are exhausted or the error is not
- * transient.
- */
 async function withRetry(fn, opts = {}) {
     const attempts = opts.attempts ?? 4;
     const base = opts.baseDelayMs ?? 500;
@@ -45,7 +36,7 @@ async function withRetry(fn, opts = {}) {
             const delay = base * Math.pow(2, attempt - 1);
             opts.logger?.warn('http-retry: transient failure, retrying', {
                 label: opts.label, attempt, attempts, delayMs: delay,
-                reason: err instanceof Error ? err.message : String(err),
+                err,
             });
             await sleep(delay);
         }

package/dist/src/services/infinity-provisioning.d.ts

@@ -1,115 +1,41 @@
 import type { Config } from '../config';
-/** Result of a shell command run, mirroring the parts of `spawnSync` we use. */
 export interface CommandResult {
     status: number | null;
     stdout?: string;
     stderr?: string;
 }
-/** Injection seams for the provisioning primitive. All optional, defaulted to the real implementations. */
 export interface ProvisioningDeps {
     fetchImpl?: typeof fetch;
-    /** Runs a shell command (docker). Defaults to `spawnSync` with captured output. */
     runCommand?: (cmd: string, args: string[]) => CommandResult;
-    /** Sleep between readiness polls (ms), capped at 5000. Defaults to 2000; tests pass 0. */
     pollIntervalMs?: number;
-    /** Readiness wait timeout (ms). Defaults to 1,800,000 (30 min); tests override to run fast. */
     readinessTimeoutMs?: number;
 }
-/**
- * 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.
- */
 export declare function serverRoot(baseURL: string): string;
-/**
- * Probe an Infinity-style `/health` endpoint. Resolves `true` when the server
- * answers with a 2xx, `false` on any error, non-2xx, or timeout.
- */
 export declare function probeInfinityHealth(baseURL: string, fetchImpl?: typeof fetch, timeoutMs?: number): Promise<boolean>;
-/**
- * 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".
- */
 export declare function listInfinityModels(baseURL: string, fetchImpl?: typeof fetch, timeoutMs?: number): Promise<string[]>;
-/**
- * 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.
- */
 export declare function sameServer(a: string, b: string): boolean;
-/**
- * "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".
- */
 export declare function isManagedInfinity(baseURL: string, composePath: string): boolean;
-/** The literal (non-`${…}`) `INFINITY_MODEL_ID` value in the compose file's `infinity` service, or null. */
 export declare function extractModelIdValue(composeContent: string): string | null;
-/** Write `content` to `targetPath` via a same-directory temp file + rename; removes the temp file on failure. */
 export declare function atomicWriteFile(targetPath: string, content: string, mode: number): void;
-/**
- * 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.
- */
 export declare function writeComposeModelSet(composePath: string, modelSet: string[]): void;
-/** True when an NVIDIA GPU + `nvidia-smi` is available on this host. */
 export declare function hasNvidiaGpu(): boolean;
-/** The `-f` file args a docker compose invocation against `composePath` should use (base, plus GPU override when present + detected). */
 export declare function composeFileArgs(composePath: string): string[];
 export type BackendAction = 'served' | 'missing-managed' | 'missing-external' | 'unreachable-managed' | 'unreachable-external';
 export interface BackendEvaluation {
     action: BackendAction;
     managed: boolean;
-    /** Required models absent from the served listing; empty for `served` or an unverifiable listing. */
     missingModels: string[];
-    /** The full served listing at evaluation time; empty for an unverifiable listing or when unreachable. */
     servedModels: string[];
 }
-/**
- * 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.
- */
 export declare function evaluateBackend(baseURL: string, composePath: string, requiredModels: string[], deps?: ProvisioningDeps): Promise<BackendEvaluation>;
-/** Human-readable manual instructions for a `missing-external`/`unreachable-external` evaluation. */
 export declare function manualInstructionMessage(evaluation: BackendEvaluation, base: string, modelSetToWrite: string[]): string;
 export interface EnsureBackendReadyOpts {
     baseURL: string;
-    /** Models that must be served for the call to succeed without a recreate/instructions. */
     requiredModels: string[];
-    /** Full model set to write into the compose file and bind at startup when a start/recreate is needed. */
     modelSetToWrite: string[];
     composePath: string;
     deps?: ProvisioningDeps;
 }
-/**
- * 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)
- */
 export declare function ensureBackendReady(opts: EnsureBackendReadyOpts): Promise<void>;
-/** `ensureBackendReady` with the full set as both the requirement and the write (rag-setup, web dashboard). */
 export declare function ensureModelSetServed(baseURL: string, composePath: string, modelSet: string[], deps?: ProvisioningDeps): Promise<void>;
-/**
- * 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`).
- */
 export declare function requiredModelSet(cfg: Config): string[];

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

@@ -51,19 +51,9 @@ 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`, {
@@ -76,11 +66,6 @@ async function probeInfinityHealth(baseURL, fetchImpl = fetch, timeoutMs = 2000)
         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`, {
@@ -96,13 +81,6 @@ async function listInfinityModels(baseURL, fetchImpl = fetch, timeoutMs = 2000)
         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));
@@ -120,15 +98,12 @@ function findServiceBlock(lines, serviceName) {
     }
     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)
@@ -136,7 +111,6 @@ function parsePortItem(item) {
     }
     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)
@@ -177,11 +151,6 @@ function normalizedHost(hostname) {
 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);
@@ -198,13 +167,6 @@ function sameServer(a, b) {
         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;
@@ -231,7 +193,6 @@ function isManagedInfinity(baseURL, composePath) {
         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');
@@ -246,7 +207,6 @@ function extractModelIdValue(composeContent) {
     }
     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()}`);
@@ -258,19 +218,10 @@ function atomicWriteFile(targetPath, content, mode) {
         try {
             fs.unlinkSync(tmpPath);
         }
-        catch { /* best effort cleanup */ }
+        catch { }
         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;
@@ -279,7 +230,7 @@ function writeComposeModelSet(composePath, modelSet) {
         mode = fs.statSync(composePath).mode;
     }
     catch (err) {
-        throw new Error(`Cannot read managed compose file at ${composePath}: ${err.message}`);
+        throw new Error(`Cannot read managed compose file at ${composePath}: ${err.message}`, { cause: err });
     }
     const newline = content.includes('\r\n') ? '\r\n' : '\n';
     const lines = content.split(/\r?\n/);
@@ -327,10 +278,9 @@ function writeComposeModelSet(composePath, modelSet) {
         atomicWriteFile(composePath, outLines.join(newline), mode);
     }
     catch (err) {
-        throw new Error(`Failed to write managed compose file at ${composePath}: ${err.message}`);
+        throw new Error(`Failed to write managed compose file at ${composePath}: ${err.message}`, { cause: err });
     }
 }
-/** 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;
@@ -342,7 +292,6 @@ function hasNvidiaGpu() {
 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];
@@ -354,7 +303,6 @@ function defaultRunCommand(cmd, args) {
 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();
@@ -366,7 +314,7 @@ function parseInfinityState(stdout) {
             if (obj?.Service === 'infinity')
                 return readState(obj);
         }
-        catch { /* not a JSON-lines entry — fall through to array parsing below */ }
+        catch { }
     }
     try {
         const arr = JSON.parse(stdout);
@@ -376,14 +324,9 @@ function parseInfinityState(stdout) {
                 return readState(svc);
         }
     }
-    catch { /* not an array either */ }
+    catch { }
     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;
@@ -412,7 +355,6 @@ async function waitForReady(base, files, modelSetToWrite, requiredModels, deps)
                 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}.`);
         }
@@ -438,13 +380,6 @@ async function recreateAndWait(base, composePath, modelSetToWrite, requiredModel
     }
     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);
@@ -458,7 +393,6 @@ async function evaluateBackend(baseURL, composePath, requiredModels, deps = {})
     }
     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(', ')}]. ` +
@@ -470,15 +404,6 @@ function manualInstructionMessage(evaluation, base, modelSetToWrite) {
         `    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 ?? {};
@@ -496,17 +421,9 @@ async function ensureBackendReady(opts) {
             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)) {

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

@@ -3,22 +3,6 @@ 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

@@ -3,18 +3,10 @@ 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`);
@@ -27,13 +19,6 @@ async function readIndexMetaStrict(db) {
         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`);
@@ -45,14 +30,6 @@ async function hasIndexedChunks(db) {
         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)

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

@@ -1,14 +1,5 @@
 import type { Config } from '../config';
 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). 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?: {
     fetchImpl?: typeof fetch;
     baseDelayMs?: number;

package/dist/src/services/reranker.js

@@ -3,17 +3,42 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeReranker = makeReranker;
 const config_1 = require("../config");
 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). 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 indexList(items) {
+    if (!Array.isArray(items))
+        return null;
+    const out = [];
+    for (const item of items) {
+        const index = item?.index;
+        if (typeof index !== 'number')
+            return null;
+        out.push(index);
+    }
+    return out;
+}
+const WIRES = {
+    'openai-compatible': {
+        body: (model, query, documents, topN) => ({ model, query, documents, top_n: topN, truncate: true }),
+        indices: json => indexList(json?.results),
+    },
+    voyage: {
+        body: (model, query, documents, topN) => ({ model, query, documents, top_k: topN, truncation: true }),
+        indices: (json) => {
+            const data = json?.data;
+            if (!Array.isArray(data))
+                return null;
+            if (data.some(d => typeof d?.relevance_score !== 'number'))
+                return null;
+            const sorted = [...data].sort((a, b) => b.relevance_score - a.relevance_score);
+            return indexList(sorted);
+        },
+    },
+};
 function makeReranker(config, logger, deps = {}) {
     const r = config.reranker;
+    if (r.missingApiKey) {
+        logger.warn('reranker: reranker.provider is voyage but reranker.apiKey is not set — reranking disabled. Set reranker.apiKey or reranker.enabled: false');
+        return undefined;
+    }
     if (!r.enabled)
         return undefined;
     if (!r.model) {
@@ -21,6 +46,7 @@ function makeReranker(config, logger, deps = {}) {
         return undefined;
     }
     const doFetch = deps.fetchImpl ?? fetch;
+    const wire = WIRES[r.provider] ?? WIRES['openai-compatible'];
     return async (query, documents, topN) => {
         return (0, http_retry_1.withRetry)(async () => {
             const headers = { 'Content-Type': 'application/json' };
@@ -31,14 +57,22 @@ function makeReranker(config, logger, deps = {}) {
                 method: 'POST',
                 headers,
                 signal: AbortSignal.timeout(30_000),
-                body: JSON.stringify({ model: r.model, query, documents, top_n: topN, truncate: true }),
+                body: JSON.stringify(wire.body(r.model, query, documents, topN)),
             });
             if (!res.ok) {
                 const body = (await res.text().catch(() => res.statusText)).slice(0, 200);
                 throw new http_retry_1.HttpError(res.status, `rerank failed: ${res.status} ${body}`);
             }
-            const data = await res.json();
-            return data.results.map(x => x.index);
+            const json = await res.json().catch((err) => {
+                if (err instanceof SyntaxError)
+                    return null;
+                throw err;
+            });
+            const indices = wire.indices(json);
+            if (!indices || indices.some(i => !Number.isInteger(i) || i < 0 || i >= documents.length)) {
+                throw new Error(`rerank failed: unexpected response from ${r.url}`);
+            }
+            return indices;
         }, { logger, baseDelayMs: deps.baseDelayMs, label: 'rerank' });
     };
 }

package/dist/src/setup.d.ts

@@ -1,45 +1,45 @@
 import { type EmbeddingProvider } from './constants';
+import { type JsonConfig } from './config-store';
 import { Config } from './config';
 import { type ProvisioningDeps } from './services/infinity-provisioning';
 import type { LoggerService } from './services/LoggerService';
-type SetupStep = {
+export 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 function recordedStep(question: string, raw: string): SetupStep;
+export declare function setupStepLogger(logger: LoggerService | undefined, steps: SetupStep[]): (question: string, raw: string) => void;
+type NonVoyageProvider = Exclude<EmbeddingProvider, 'voyage'>;
 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';
+export type RerankerChoice = 'infinity' | 'voyage' | 'openai-compatible' | 'none';
+type RerankerBlock = NonNullable<JsonConfig['reranker']>;
+type EmbeddingBlock = NonNullable<JsonConfig['embedding']>;
+export interface SetupPromptIO {
+    prompt(label: string, def: string): Promise<string>;
+    ask(question: string): Promise<string>;
+    writeEnvKey(name: string, value: string): void;
+    log(message: string): void;
+}
+export declare function rerankerChoices(embProvider: NonVoyageProvider): RerankerChoice[];
+export declare function voyageEmbeddingModels(): string[];
+export declare function promptModelChoice(io: SetupPromptIO, label: string, models: readonly string[]): Promise<string>;
+export declare function promptVoyageSetup(io: SetupPromptIO): Promise<{
+    embedding: EmbeddingBlock;
+    reranker: RerankerBlock;
+}>;
+export declare function promptSearchThreshold(io: SetupPromptIO, model: string): Promise<number | undefined>;
+export declare function searchThresholdBlock(threshold: number | undefined): Pick<JsonConfig, 'search'>;
+export declare function promptReranker(embProvider: NonVoyageProvider, embBaseURL: string, io: SetupPromptIO): Promise<RerankerBlock>;
 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 {};