codesearch-mcp 0.2.3-alpha → 0.3.0-alpha

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

@@ -17,45 +17,17 @@ export interface BackendStatus {
     finishedAt: string | null;
 }
 export interface WebServerDeps {
-    /** Path to the managed docker-compose.yml. Defaults to `CONFIG_DIR/docker-compose.yml`. */
     composePath?: string;
-    /** Injection seams (fetchImpl/runCommand/pollIntervalMs/readinessTimeoutMs) for the readiness primitive. */
     provisioning?: ProvisioningDeps;
-    /** Reads the just-saved config back — defaults to `() => new Config()`. Injectable for tests. */
     readSavedConfig?: () => Config;
 }
-/**
- * Per-field choice lists for the config form. `strict` → render a dropdown that
- * only accepts a listed value (e.g. the embedding model, tied to the vector
- * dimension). Non-strict → a combobox: the values are suggestions but free text
- * is still allowed (e.g. any model served by a self-hosted backend).
- */
 export interface FieldOption {
     values: string[];
     strict: boolean;
 }
-/** Placeholder shown to the browser instead of a real secret. */
 export declare const PASSWORD_MASK = "********";
-/**
- * Merge a config submitted from the browser with the stored one. Any secret
- * field (DB password, embedding/reranker API keys) still holding the mask means
- * the user did not change it — restore the stored value rather than overwrite it
- * with the placeholder. `env:` references are not masked and round-trip as-is.
- * Pure — no I/O. Exported for unit testing.
- */
 export declare function mergeConfigForSave(incoming: JsonConfig, existing: JsonConfig | null): JsonConfig;
-/**
- * Return a copy of the config with raw secrets (DB password, raw API keys)
- * replaced by the mask, so real secrets never reach the browser. `env:`
- * references are left verbatim — they are not secret and the dashboard shows
- * them as "set via <VAR>". The masked value round-trips through
- * `mergeConfigForSave`. Pure — no I/O. Exported for unit testing.
- */
 export declare function maskConfig(cfg: JsonConfig): JsonConfig;
-/**
- * Local HTTP dashboard. Serves a schema-driven config editor, a project
- * overview, and the dependency graph. Bind to 127.0.0.1 only — no auth.
- */
 export declare class WebServer {
     private readonly searcher;
     private readonly config;
@@ -71,43 +43,19 @@ export declare class WebServer {
     constructor(searcher: ISearcher, config: Config, logger: ILogger, embedder: IEmbedder, deps?: WebServerDeps);
     start(port: number, host: string): Promise<void>;
     stop(): Promise<void>;
-    /** The bound address once started (e.g. `.port` after listen(0)); null otherwise. */
     address(): {
         port: number;
     } | null;
     private handle;
     private maskedConfig;
     private saveConfig;
-    /**
-     * After a successful config write, decide the Infinity backend action per
-     * the first-match decision table (`local-backend-provisioning`). Computes
-     * the required set from the SAVED config (a fresh `Config` re-read from the
-     * file just written — never the server's startup config/embedder). Never
-     * throws — an unexpected error becomes `{ action: 'failed', message }`; the
-     * saved config and `GET /api/backend-status` are unaffected either way.
-     */
     private evaluateBackendAfterSave;
-    /** Kick off (or continue, via a follow-up) a background Infinity recreate. */
     private startBackgroundTask;
-    /**
-     * Choice lists for model fields. Both are non-strict comboboxes (free text
-     * allowed): the embedding model suggests the known registry models plus any
-     * locally-installed models; the reranker model suggests installed models.
-     * Backends beyond the registry (e.g. arbitrary HuggingFace models on Infinity)
-     * still work — their dimension is probed at index time.
-     */
+    private defaults;
     private fieldOptions;
     private installedModels;
-    /** Tabbed graph views (Workspace + one per nested Nx repo). */
     private graphViews;
-    /** `/api/graph` — the Workspace view's raw `{ nodes, edges }` (back-compat). */
     private graphData;
-    /**
-     * The full interactive graph page — the same HTML as the standalone
-     * `project-graph.html` (inner tabs, filters, legend, project toggles). The
-     * dashboard's Graph tab embeds this via an iframe rather than re-implementing
-     * vis-network.
-     */
     private graphPage;
     private readBody;
     private json;

package/dist/src/services/WebServerService.js

@@ -47,20 +47,11 @@ const infinity_provisioning_1 = require("./infinity-provisioning");
 function sameModelSet(a, b) {
     return a.join(';') === b.join(';');
 }
-/** Placeholder shown to the browser instead of a real secret. */
 exports.PASSWORD_MASK = '********';
-const MAX_BODY = 1_000_000; // 1 MB — config payloads are tiny
-/** A secret worth masking: a non-empty string that is not an `env:` reference. */
+const MAX_BODY = 1_000_000;
 function isRawSecret(v) {
     return typeof v === 'string' && v !== '' && !v.startsWith('env:');
 }
-/**
- * Merge a config submitted from the browser with the stored one. Any secret
- * field (DB password, embedding/reranker API keys) still holding the mask means
- * the user did not change it — restore the stored value rather than overwrite it
- * with the placeholder. `env:` references are not masked and round-trip as-is.
- * Pure — no I/O. Exported for unit testing.
- */
 function mergeConfigForSave(incoming, existing) {
     const merged = JSON.parse(JSON.stringify(incoming ?? {}));
     const restore = (grp, field) => {
@@ -78,13 +69,6 @@ function mergeConfigForSave(incoming, existing) {
     restore('reranker', 'apiKey');
     return merged;
 }
-/**
- * Return a copy of the config with raw secrets (DB password, raw API keys)
- * replaced by the mask, so real secrets never reach the browser. `env:`
- * references are left verbatim — they are not secret and the dashboard shows
- * them as "set via <VAR>". The masked value round-trips through
- * `mergeConfigForSave`. Pure — no I/O. Exported for unit testing.
- */
 function maskConfig(cfg) {
     const clone = JSON.parse(JSON.stringify(cfg ?? {}));
     if (clone.db?.password)
@@ -95,10 +79,6 @@ function maskConfig(cfg) {
         clone.reranker.apiKey = exports.PASSWORD_MASK;
     return clone;
 }
-/**
- * Local HTTP dashboard. Serves a schema-driven config editor, a project
- * overview, and the dependency graph. Bind to 127.0.0.1 only — no auth.
- */
 class WebServer {
     searcher;
     config;
@@ -108,8 +88,6 @@ class WebServer {
     composePath;
     provisioningDeps;
     readSavedConfig;
-    // Background Infinity-recreate task state (D6). In-memory, per-process — see
-    // `GET /api/backend-status`. `pending` holds at most one queued follow-up.
     backendStatus = { state: 'idle', message: null, startedAt: null, finishedAt: null };
     taskInFlight = false;
     pending = null;
@@ -125,7 +103,7 @@ class WebServer {
     async start(port, host) {
         this.server = http.createServer((req, res) => {
             this.handle(req, res).catch(err => {
-                this.logger.error('WebServer: request failed', { reason: err instanceof Error ? err.message : String(err) });
+                this.logger.error('WebServer: request failed', { err });
                 if (!res.headersSent) {
                     res.writeHead(500);
                     res.end('Internal error');
@@ -144,7 +122,6 @@ class WebServer {
         await new Promise(resolve => this.server.close(() => resolve()));
         this.server = undefined;
     }
-    /** The bound address once started (e.g. `.port` after listen(0)); null otherwise. */
     address() {
         const a = this.server?.address();
         return a && typeof a === 'object' ? { port: a.port } : null;
@@ -158,7 +135,7 @@ class WebServer {
         if (m === 'GET' && p === '/api/schema')
             return this.json(res, 200, (0, config_store_1.buildJsonSchema)());
         if (m === 'GET' && p === '/api/defaults')
-            return this.json(res, 200, config_store_1.CONFIG_DEFAULTS);
+            return this.json(res, 200, this.defaults());
         if (m === 'GET' && p === '/api/field-options')
             return this.json(res, 200, await this.fieldOptions());
         if (m === 'GET' && p === '/api/config')
@@ -184,7 +161,6 @@ class WebServer {
             body = await this.readBody(req);
         }
         catch (e) {
-            // Distinguish the size limit from other stream errors.
             return this.json(res, 413, { error: e instanceof Error ? e.message : 'Request body too large' });
         }
         let incoming;
@@ -207,14 +183,6 @@ class WebServer {
         const backend = await this.evaluateBackendAfterSave(validated);
         this.json(res, 200, { ok: true, backend });
     }
-    /**
-     * After a successful config write, decide the Infinity backend action per
-     * the first-match decision table (`local-backend-provisioning`). Computes
-     * the required set from the SAVED config (a fresh `Config` re-read from the
-     * file just written — never the server's startup config/embedder). Never
-     * throws — an unexpected error becomes `{ action: 'failed', message }`; the
-     * saved config and `GET /api/backend-status` are unaffected either way.
-     */
     async evaluateBackendAfterSave(saved) {
         const provider = saved.embedding?.provider ?? config_store_1.CONFIG_DEFAULTS['embedding.provider'];
         if (provider !== 'infinity') {
@@ -232,7 +200,6 @@ class WebServer {
                     this.pending = { modelSet, baseURL, composePath };
                     return { action: 'already-running', message: 'A backend recreate is already in progress; this configuration will be applied next.' };
                 }
-                // No longer targets the managed container the in-flight task owns.
                 this.pending = null;
             }
             const evaluation = await (0, infinity_provisioning_1.evaluateBackend)(baseURL, composePath, modelSet, this.provisioningDeps);
@@ -252,7 +219,6 @@ class WebServer {
             return { action: 'failed', message: err instanceof Error ? err.message : String(err) };
         }
     }
-    /** Kick off (or continue, via a follow-up) a background Infinity recreate. */
     startBackgroundTask(baseURL, composePath, modelSet) {
         this.taskInFlight = true;
         this.backendStatus = { state: 'recreating', message: null, startedAt: new Date().toISOString(), finishedAt: null };
@@ -276,19 +242,17 @@ class WebServer {
             }
         });
     }
-    /**
-     * Choice lists for model fields. Both are non-strict comboboxes (free text
-     * allowed): the embedding model suggests the known registry models plus any
-     * locally-installed models; the reranker model suggests installed models.
-     * Backends beyond the registry (e.g. arbitrary HuggingFace models on Infinity)
-     * still work — their dimension is probed at index time.
-     */
+    defaults() {
+        const ctx = (0, config_1.rerankContext)((0, config_store_1.readConfigJson)() ?? {});
+        return { ...config_store_1.CONFIG_DEFAULTS, 'reranker.enabled': ctx.wanted && !ctx.missingKey, 'reranker.model': ctx.model };
+    }
     async fieldOptions() {
         const installed = await this.installedModels();
         const registryModels = Object.keys(constants_1.MODEL_REGISTRY);
+        const rerankModels = (0, config_store_1.readConfigJson)()?.reranker?.provider === 'voyage' ? [...constants_1.VOYAGE_RERANK_MODELS] : installed;
         return {
             'embedding.model': { values: [...new Set([...registryModels, ...installed])], strict: false },
-            'reranker.model': { values: installed, strict: false },
+            'reranker.model': { values: rerankModels, strict: false },
         };
     }
     async installedModels() {
@@ -296,32 +260,22 @@ class WebServer {
             return (await this.embedder.listModels?.()) ?? [];
         }
         catch (err) {
-            this.logger.warn('WebServer: could not list models', { reason: err instanceof Error ? err.message : String(err) });
+            this.logger.warn('WebServer: could not list models', { err });
             return [];
         }
     }
-    /** Tabbed graph views (Workspace + one per nested Nx repo). */
     async graphViews() {
         const projects = (await this.searcher.listProjects()).map(p => ({
             name: p.serviceName,
-            // Real project root (resolved via discovery — handles nested-monorepo
-            // names). Fall back to the flat assumption if listProjects omits it.
             path: p.path ?? path.join(this.config.workspaceRoot, p.serviceName),
         }));
         const projectEdges = await this.searcher.getProjectEdges();
         return (0, graph_1.buildGraphViews)(projects, projectEdges, this.config.workspaceRoot);
     }
-    /** `/api/graph` — the Workspace view's raw `{ nodes, edges }` (back-compat). */
     async graphData() {
         const views = await this.graphViews();
         return { nodes: views[0].nodes, edges: views[0].edges };
     }
-    /**
-     * The full interactive graph page — the same HTML as the standalone
-     * `project-graph.html` (inner tabs, filters, legend, project toggles). The
-     * dashboard's Graph tab embeds this via an iframe rather than re-implementing
-     * vis-network.
-     */
     async graphPage() {
         return (0, graph_1.buildHtml)(await this.graphViews());
     }
@@ -331,7 +285,7 @@ class WebServer {
             let tooLarge = false;
             req.on('data', chunk => {
                 if (tooLarge)
-                    return; // stop growing `data`; keep the socket alive so the 413 flushes
+                    return;
                 data += chunk;
                 if (data.length > MAX_BODY) {
                     tooLarge = true;

package/dist/src/services/http-retry.d.ts

@@ -4,16 +4,9 @@ export declare class HttpError extends Error {
     constructor(status: number, message: string);
 }
 export interface RetryOpts {
-    /** Total attempts including the first (default 4). */
     attempts?: number;
-    /** Base backoff in ms; grows exponentially (default 500). Set 0 in tests. */
     baseDelayMs?: number;
     logger?: ILogger;
     label?: string;
 }
-/**
- * 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.
- */
 export declare function withRetry<T>(fn: () => Promise<T>, opts?: RetryOpts): Promise<T>;

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