codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

package/dist/src/services/NxMonorepoResolver.js

@@ -37,27 +37,6 @@ exports.NxMonorepoResolver = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const file_utils_1 = require("../file-utils");
-/**
- * Nx monorepo resolver.
- *
- * Detection: presence of `nx.json` at the workspace root.
- *
- * Project discovery strategies (results deduplicated by absolute path):
- * 1. Read `workspace.json` or `angular.json` → projects map
- * 2. Scan standard Nx directories (`apps/`, `libs/`, `packages/`) for
- *    `project.json`, then `package.json` (only when strategy 1 found nothing)
- * 3. `tsconfig.base.json` `paths` — root-level libs referenced only by path
- *    alias (e.g. `contracts/`, `interfaces/`) that the directory scan misses
- * 4. Root-level fallback: treat the workspace root itself as a project
- *    (standalone Nx setup) when nothing else matched
- *
- * tsconfig resolution:
- * - Returns `tsconfig.base.json` at workspace root (Nx convention)
- * - Falls back to `tsconfig.json` at workspace root
- *
- * Cross-project import resolution is handled by the AST parser via the
- * workspace-wide tsconfig `paths` (tsconfig.base.json), so no scope map is built here.
- */
 class NxMonorepoResolver {
     logger;
     constructor(logger) {
@@ -67,15 +46,12 @@ class NxMonorepoResolver {
         return fs.existsSync(path.join(rootDir, 'nx.json'));
     }
     discoverProjects(rootDir) {
-        // Deduplicate across strategies by absolute project path.
         const byPath = new Map();
         const add = (p) => { if (p && !byPath.has(p.path))
             byPath.set(p.path, p); };
-        // Strategy 1: workspace.json / angular.json (authoritative when present)
         const workspaceProjects = this.readWorkspaceJson(rootDir);
         for (const p of workspaceProjects)
             add(p);
-        // Strategy 2 & 3: scan standard directories (only when no workspace.json map)
         if (byPath.size === 0) {
             for (const dir of ['apps', 'libs', 'packages']) {
                 const fullDir = path.join(rootDir, dir);
@@ -86,13 +62,8 @@ class NxMonorepoResolver {
                     add(p);
             }
         }
-        // Strategy 4: tsconfig.base.json `paths` — captures libs that live at the
-        // repo root (e.g. `contracts/`, `interfaces/`) referenced by path aliases,
-        // which the apps/libs/packages scan misses. Only real Nx projects (with a
-        // project.json/package.json) are added; dedup handles overlap with the scan.
         for (const p of this.discoverFromTsconfigPaths(rootDir))
             add(p);
-        // Root-level fallback (standalone Nx setup)
         if (byPath.size === 0) {
             const rootProject = this.tryReadProject(rootDir, rootDir);
             if (rootProject)
@@ -102,13 +73,6 @@ class NxMonorepoResolver {
         this.logger.debug('NxMonorepoResolver: discovered projects', { count: projects.length });
         return projects;
     }
-    /**
-     * Discover projects from `tsconfig.base.json` `compilerOptions.paths`. Each
-     * alias (e.g. `@scope/interfaces` → `interfaces/src/index.ts`) resolves to a
-     * lib root (the path before `/src/`), which for real Nx libs contains a
-     * project.json. Aliases pointing at non-projects (no project.json/package.json,
-     * e.g. `@env` → `environments/environment.ts`) are skipped.
-     */
     discoverFromTsconfigPaths(rootDir) {
         const tsconfigPath = this.getRootTsConfigPath(rootDir);
         if (!tsconfigPath)
@@ -118,7 +82,7 @@ class NxMonorepoResolver {
             json = this.parseJsonc(fs.readFileSync(tsconfigPath, 'utf-8'));
         }
         catch (err) {
-            this.logger.warn('NxMonorepoResolver: failed to parse tsconfig paths', { file: tsconfigPath, reason: err.message });
+            this.logger.warn('NxMonorepoResolver: failed to parse tsconfig paths', { file: tsconfigPath, err });
             return [];
         }
         const co = json?.compilerOptions ?? {};
@@ -134,13 +98,12 @@ class NxMonorepoResolver {
             const srcIdx = target.indexOf('/src/');
             const relRoot = srcIdx >= 0 ? target.slice(0, srcIdx) : path.dirname(target);
             const libRoot = path.resolve(rootDir, baseUrl, relRoot);
-            const project = this.tryReadProject(libRoot, rootDir); // null unless a real project marker exists
+            const project = this.tryReadProject(libRoot, rootDir);
             if (project)
                 projects.push(project);
         }
         return projects;
     }
-    /** Parse JSON that may contain comments / trailing commas (tsconfig style). */
     parseJsonc(text) {
         try {
             return JSON.parse(text);
@@ -154,17 +117,14 @@ class NxMonorepoResolver {
         }
     }
     getRootTsConfigPath(rootDir) {
-        // Nx convention: tsconfig.base.json at workspace root
         const basePath = path.join(rootDir, 'tsconfig.base.json');
         if (fs.existsSync(basePath))
             return basePath;
-        // Fallback: tsconfig.json at workspace root
         const rootPath = path.join(rootDir, 'tsconfig.json');
         if (fs.existsSync(rootPath))
             return rootPath;
         return null;
     }
-    // ── Private helpers ─────────────────────────────────────────────────────────
     readWorkspaceJson(rootDir) {
         const projects = [];
         for (const filename of ['workspace.json', 'angular.json']) {
@@ -175,9 +135,6 @@ class NxMonorepoResolver {
                 const content = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
                 const projectsMap = content.projects ?? {};
                 for (const [name, value] of Object.entries(projectsMap)) {
-                    // value can be a string (path) or an object with a `root` property.
-                    // Guard per-entry: a malformed entry (object without `root`) must not
-                    // abort discovery of the remaining projects in this file.
                     const rawRoot = typeof value === 'string'
                         ? value
                         : value?.root;
@@ -196,7 +153,7 @@ class NxMonorepoResolver {
             catch (err) {
                 this.logger.warn('NxMonorepoResolver: failed to parse workspace file', {
                     file: filePath,
-                    reason: err.message,
+                    err,
                 });
             }
         }
@@ -222,14 +179,12 @@ class NxMonorepoResolver {
                 projects.push(project);
                 continue;
             }
-            // Check for nested grouping directories (e.g. libs/shared/utils)
             const nested = this.scanDirectory(projectPath, defaultType, rootDir);
             projects.push(...nested);
         }
         return projects;
     }
     tryReadProject(projectPath, rootDir, defaultType = 'lib') {
-        // Check for project.json (Nx project marker)
         const projectJsonPath = path.join(projectPath, 'project.json');
         const packageJsonPath = path.join(projectPath, 'package.json');
         const hasProjectJson = fs.existsSync(projectJsonPath);
@@ -239,7 +194,6 @@ class NxMonorepoResolver {
         let name = path.relative(rootDir, projectPath).replace(/\\/g, '/');
         let type = defaultType;
         let packageName = null;
-        // Read project.json for name and type
         if (hasProjectJson) {
             try {
                 const projectJson = JSON.parse(fs.readFileSync(projectJsonPath, 'utf-8'));
@@ -253,14 +207,12 @@ class NxMonorepoResolver {
             catch (err) {
                 this.logger.warn('NxMonorepoResolver: failed to parse project.json', {
                     file: projectJsonPath,
-                    reason: err.message,
+                    err,
                 });
             }
         }
-        // Read package.json for npm scope
         if (hasPackageJson) {
             packageName = this.readPackageName(projectPath);
-            // If no project.json name, use package name without scope
             if (!hasProjectJson && packageName) {
                 const shortName = packageName.replace(/^@[^/]+\//, '');
                 name = shortName;
@@ -281,7 +233,6 @@ class NxMonorepoResolver {
         }
     }
     inferProjectType(projectPath, name) {
-        // Check project.json
         const projectJsonPath = path.join(projectPath, 'project.json');
         if (fs.existsSync(projectJsonPath)) {
             try {
@@ -291,15 +242,13 @@ class NxMonorepoResolver {
                 if (projectJson.projectType === 'library')
                     return 'lib';
             }
-            catch { /* fall through */ }
+            catch { }
         }
-        // Infer from path
         const rel = projectPath.replace(/\\/g, '/');
         if (rel.includes('/apps/') || rel.includes('/app/'))
             return 'app';
         if (rel.includes('/libs/') || rel.includes('/lib/') || rel.includes('/packages/'))
             return 'lib';
-        // Infer from name
         if (name.includes('lib') || name.includes('shared') || name.includes('util'))
             return 'lib';
         return 'app';

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

@@ -5,12 +5,6 @@ export interface EmbedderDeps {
     fetchImpl?: typeof fetch;
     baseDelayMs?: number;
 }
-/**
- * Embedder for any server exposing an OpenAI-style `/embeddings` endpoint:
- * OpenAI cloud, Infinity, TEI, vLLM, LM Studio, LocalAI. One request carries all
- * inputs (`{ input: string[], model, dimensions? }`) and returns
- * `{ data: [{ embedding, index }] }`, re-ordered to input order.
- */
 export declare class OpenAICompatibleEmbedder implements IEmbedder {
     protected config: Config;
     private logger;

package/dist/src/services/OpenAICompatibleEmbedder.js

@@ -6,12 +6,6 @@ const config_1 = require("../config");
 const reranker_1 = require("./reranker");
 const http_retry_1 = require("./http-retry");
 const constants_1 = require("../constants");
-/**
- * Embedder for any server exposing an OpenAI-style `/embeddings` endpoint:
- * OpenAI cloud, Infinity, TEI, vLLM, LM Studio, LocalAI. One request carries all
- * inputs (`{ input: string[], model, dimensions? }`) and returns
- * `{ data: [{ embedding, index }] }`, re-ordered to input order.
- */
 class OpenAICompatibleEmbedder {
     config;
     logger;
@@ -24,7 +18,6 @@ class OpenAICompatibleEmbedder {
         this.config = config;
         this.logger = logger;
         const base = config.embedding.baseURL.replace(/\/+$/, '');
-        // Allow a baseURL that already includes the path (…/v1) or not.
         this.url = /\/embeddings$/.test(base) ? base : `${base}/embeddings`;
         this.doFetch = deps.fetchImpl ?? fetch;
         this.baseDelayMs = deps.baseDelayMs;
@@ -40,8 +33,6 @@ class OpenAICompatibleEmbedder {
             return [];
         return (0, http_retry_1.withRetry)(async () => {
             const headers = { 'Content-Type': 'application/json' };
-            // Resolve the key lazily — an unset `env:` ref throws here (request time),
-            // not at construction, so `rag-web`/`rag-mcp` still start.
             const apiKey = (0, config_1.resolveEnvRef)(this.config.embedding.apiKey);
             if (apiKey)
                 headers['Authorization'] = `Bearer ${apiKey}`;
@@ -51,7 +42,6 @@ class OpenAICompatibleEmbedder {
             const res = await this.doFetch(this.url, {
                 method: 'POST',
                 headers,
-                // CPU inference of one batch of token-dense text (e.g. pseudo-localized strings) takes well over 2 min.
                 signal: AbortSignal.timeout(240_000),
                 body: JSON.stringify(body),
             });
@@ -60,13 +50,9 @@ class OpenAICompatibleEmbedder {
                 throw new http_retry_1.HttpError(res.status, `embeddings request failed: ${res.status} ${errBody}`);
             }
             const data = await res.json();
-            // Guard against a partial/mismatched response — a missing vector would
-            // otherwise be inserted as "[undefined]" and fail the whole file, or (with
-            // reordering + no index) silently misalign vectors to the wrong chunks.
             if (!Array.isArray(data.data) || data.data.length !== texts.length) {
                 throw new Error(`embeddings response returned ${data.data?.length ?? 0} vectors for ${texts.length} inputs`);
             }
-            // Sort by `index` so vectors line up with input order regardless of server ordering.
             return [...data.data]
                 .sort((a, b) => (a.index ?? 0) - (b.index ?? 0))
                 .map(d => d.embedding);

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

@@ -1,8 +1,4 @@
 import type { IProjectDiscovery, DiscoveredProject } from '../interfaces/IProjectDiscovery';
-/**
- * Default project discovery: finds immediate subdirectories
- * of the workspace root that contain a package.json.
- */
 export declare class ProjectDiscoveryService implements IProjectDiscovery {
     discover(rootDir: string): DiscoveredProject[];
 }

package/dist/src/services/ProjectDiscoveryService.js

@@ -37,10 +37,6 @@ exports.ProjectDiscoveryService = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const file_utils_1 = require("../file-utils");
-/**
- * Default project discovery: finds immediate subdirectories
- * of the workspace root that contain a package.json.
- */
 class ProjectDiscoveryService {
     discover(rootDir) {
         return fs.readdirSync(rootDir, { withFileTypes: true })

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

@@ -2,12 +2,6 @@ import type { Config } from '../config';
 import type { IEmbedder, InputType } from '../interfaces/IEmbedder';
 import type { ILogger } from '../interfaces/ILogger';
 import type { EmbedderDeps } from './OpenAICompatibleEmbedder';
-/**
- * Voyage AI embedder. Voyage's schema differs from OpenAI's: `input` is an array
- * of strings, `input_type` (`query` | `document`) is required for best quality,
- * and the optional `output_dimension` requests Matryoshka truncation. Response
- * is `{ data: [{ embedding, index }] }`.
- */
 export declare class VoyageEmbedder implements IEmbedder {
     private config;
     private logger;

package/dist/src/services/VoyageEmbedder.js

@@ -6,12 +6,6 @@ const config_1 = require("../config");
 const reranker_1 = require("./reranker");
 const http_retry_1 = require("./http-retry");
 const constants_1 = require("../constants");
-/**
- * Voyage AI embedder. Voyage's schema differs from OpenAI's: `input` is an array
- * of strings, `input_type` (`query` | `document`) is required for best quality,
- * and the optional `output_dimension` requests Matryoshka truncation. Response
- * is `{ data: [{ embedding, index }] }`.
- */
 class VoyageEmbedder {
     config;
     logger;

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

@@ -1,5 +1,5 @@
 import { Config } from '../config';
-import type { ISearcher } from '../interfaces';
+import type { IProjectCatalog, IDependencyGraph } from '../interfaces';
 import type { IEmbedder } from '../interfaces';
 import type { ILogger } from '../interfaces';
 import { type JsonConfig } from '../config-store';
@@ -17,47 +17,20 @@ 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 catalog;
+    private readonly dependencies;
     private readonly config;
     private readonly logger;
     private readonly embedder;
@@ -68,46 +41,22 @@ export declare class WebServer {
     private backendStatus;
     private taskInFlight;
     private pending;
-    constructor(searcher: ISearcher, config: Config, logger: ILogger, embedder: IEmbedder, deps?: WebServerDeps);
+    constructor(catalog: IProjectCatalog, dependencies: IDependencyGraph, 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,12 +79,9 @@ 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;
+    catalog;
+    dependencies;
     config;
     logger;
     embedder;
@@ -108,13 +89,12 @@ 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;
-    constructor(searcher, config, logger, embedder, deps = {}) {
-        this.searcher = searcher;
+    constructor(catalog, dependencies, config, logger, embedder, deps = {}) {
+        this.catalog = catalog;
+        this.dependencies = dependencies;
         this.config = config;
         this.logger = logger;
         this.embedder = embedder;
@@ -125,7 +105,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 +124,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 +137,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')
@@ -168,7 +147,7 @@ class WebServer {
         if (m === 'GET' && p === '/api/backend-status')
             return this.json(res, 200, this.backendStatus);
         if (m === 'GET' && p === '/api/projects')
-            return this.json(res, 200, await this.searcher.listProjects());
+            return this.json(res, 200, await this.catalog.listProjects());
         if (m === 'GET' && p === '/api/graph')
             return this.json(res, 200, await this.graphData());
         if (m === 'GET' && p === '/graph')
@@ -184,7 +163,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 +185,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 +202,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 +221,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 +244,23 @@ 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 saved = (0, config_store_1.readConfigJson)() ?? {};
+        const ctx = (0, config_1.rerankContext)(saved);
+        return {
+            ...config_store_1.CONFIG_DEFAULTS,
+            'reranker.enabled': ctx.wanted && !ctx.missingKey,
+            'reranker.model': ctx.model,
+            'search.similarityThreshold': (0, constants_1.resolveThreshold)({ model: saved.embedding?.model ?? config_store_1.CONFIG_DEFAULTS['embedding.model'] }).value,
+        };
+    }
     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 +268,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 => ({
+        const projects = (await this.catalog.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();
+        const projectEdges = await this.dependencies.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 +293,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>;