codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

package/dist/src/config-store.js

@@ -54,11 +54,7 @@ exports.CONFIG_DIR = path.join(os.homedir(), '.config', 'codesearch-mcp');
 exports.CONFIG_FILE = path.join(exports.CONFIG_DIR, 'config.json');
 exports.SCHEMA_FILE = path.join(exports.CONFIG_DIR, 'config.schema.json');
 exports.ENV_FILE = path.join(exports.CONFIG_DIR, '.env');
-// Relative $schema reference written into config.json so editors resolve the
-// sibling schema file for autocomplete / inline validation.
 const SCHEMA_REF = './config.schema.json';
-// All fields optional — defaults live in config.ts. The file stays minimal.
-// Descriptions surface as tooltips in schema-aware editors (VS Code, JetBrains).
 const jsonSchema = zod_1.z.object({
     db: zod_1.z.object({
         host: zod_1.z.string().describe('PostgreSQL host').optional(),
@@ -83,24 +79,23 @@ const jsonSchema = zod_1.z.object({
         chunkStrategy: zod_1.z.enum(['ast', 'character']).describe('How TS/JS files are chunked: ast = symbol-aligned boundaries, character = fixed-size recursive splitter (default ast)').optional(),
     }).optional(),
     search: zod_1.z.object({
-        similarityThreshold: zod_1.z.number().min(0).max(1).describe('Max cosine distance 0–1; lower = stricter (default 0.6)').optional(),
+        similarityThreshold: zod_1.z.number().min(0).max(1).describe('Max cosine distance 0–1, lower = stricter. Unset: recommended value for the embedding model').optional(),
         defaultLimit: zod_1.z.number().int().describe('Default result count (default 5)').optional(),
         maxLimit: zod_1.z.number().int().describe('Hard cap on results (default 20)').optional(),
     }).optional(),
     reranker: zod_1.z.object({
-        enabled: zod_1.z.boolean().describe('Enable cross-encoder reranking; requires reranker.model').optional(),
-        provider: zod_1.z.enum(['openai-compatible']).describe('Rerank backend. Only openai-compatible /rerank servers (Infinity, TEI, vLLM).').optional(),
-        baseURL: zod_1.z.string().describe('Rerank server base URL (defaults to embedding.baseURL — Infinity serves both).').optional(),
-        apiKey: zod_1.z.string().describe('API key, or env:VAR_NAME. Empty for local servers.').optional(),
-        model: zod_1.z.string().describe('Reranker model name (e.g. qllama/bge-reranker-v2-m3)').optional(),
+        enabled: zod_1.z.boolean().describe('Enable cross-encoder reranking (default true with infinity embedding or when reranker.provider/baseURL/url is set, else false)').optional(),
+        provider: zod_1.z.enum(['openai-compatible', 'voyage']).describe('Rerank backend: openai-compatible /rerank servers (Infinity, vLLM) or voyage (Voyage AI, requires reranker.apiKey) (default openai-compatible)').optional(),
+        baseURL: zod_1.z.string().describe('Rerank server base URL (default embedding.baseURL for openai-compatible — Infinity serves both; https://api.voyageai.com/v1 for voyage)').optional(),
+        apiKey: zod_1.z.string().describe('API key, or env:VAR_NAME. Empty for local servers; required for voyage.').optional(),
+        model: zod_1.z.string().describe('Reranker model name (default mixedbread-ai/mxbai-rerank-xsmall-v1 for openai-compatible, rerank-3 for voyage)').optional(),
         url: zod_1.z.string().describe('Full URL of the rerank endpoint (default derived from provider + baseURL)').optional(),
-        overfetch: zod_1.z.number().int().min(1).max(20).describe('Candidate multiplier before reranking (limit × N, default 5)').optional(),
-        candidateFloor: zod_1.z.number().int().min(1).describe('Minimum candidate pool fed to the reranker regardless of limit; fetchLimit = min(max(limit × overfetch, candidateFloor), 200) (default 80)').optional(),
+        overfetch: zod_1.z.number().int().min(1).max(20).describe('Candidate multiplier before reranking (limit × N, default 5); also sizes the pool of a search without reranking whose per-file limit is below limit').optional(),
+        candidateFloor: zod_1.z.number().int().min(1).describe('Minimum candidate pool fed to the reranker regardless of limit; fetchLimit = min(max(limit × overfetch, candidateFloor), 200) (default 80); the same pool serves a search without reranking whose per-file limit is below limit').optional(),
     }).optional(),
     logging: zod_1.z.object({
         level: zod_1.z.enum(['debug', 'info', 'warn', 'error']).describe('File log level (default error)').optional(),
         dir: zod_1.z.string().describe('Base log directory; "false" to disable file logging').optional(),
-        searchMetrics: zod_1.z.boolean().describe('Emit one structured search-tuning line (info level) per search, independent of level (default false)').optional(),
     }).optional(),
     workspaceRoot: zod_1.z.string().describe('Full path to the directory containing all your projects').optional(),
 });
@@ -134,22 +129,9 @@ const FIELD_TYPES = {
     'reranker.candidateFloor': 'number',
     'logging.level': 'string',
     'logging.dir': 'string',
-    'logging.searchMetrics': 'boolean',
     'workspaceRoot': 'string',
 };
 exports.ALL_KEYS = Object.keys(FIELD_TYPES);
-/**
- * Single source of truth for built-in defaults, keyed by raw config.json dotted
- * key. Consumed both by the web dashboard (`GET /api/defaults`) and by
- * `resolvedSchema` in `src/config.ts`, whose `.default(...)` calls reference
- * these values — so the runtime default and the dashboard-displayed default
- * cannot diverge. `as const` keeps the literal types so those `.default()`
- * lookups stay type-safe. Keys omitted here have no static default: required
- * fields (db.host/user/password) and values derived at runtime — db.name →
- * rag_<user>, and the provider-dependent URLs (embedding.baseURL,
- * reranker.baseURL, reranker.url), which are computed in the `Config`
- * constructor per provider rather than through a schema `.default(...)`.
- */
 exports.CONFIG_DEFAULTS = {
     'db.port': 5433,
     'embedding.provider': 'infinity',
@@ -161,7 +143,6 @@ exports.CONFIG_DEFAULTS = {
     'indexing.embedBatchSize': 5,
     'indexing.astBatchSize': 3000,
     'indexing.chunkStrategy': 'ast',
-    'search.similarityThreshold': 0.6,
     'search.defaultLimit': 5,
     'search.maxLimit': 20,
     'reranker.enabled': true,
@@ -171,7 +152,6 @@ exports.CONFIG_DEFAULTS = {
     'reranker.overfetch': 5,
     'reranker.candidateFloor': 80,
     'logging.level': 'error',
-    'logging.searchMetrics': false,
 };
 function readConfigJson() {
     if (!fs.existsSync(exports.CONFIG_FILE))
@@ -181,7 +161,7 @@ function readConfigJson() {
         raw = fs.readFileSync(exports.CONFIG_FILE, 'utf-8');
     }
     catch (e) {
-        throw new Error(`Cannot read ${exports.CONFIG_FILE}: ${e.message}`);
+        throw new Error(`Cannot read ${exports.CONFIG_FILE}: ${e.message}`, { cause: e });
     }
     let parsed;
     try {
@@ -189,7 +169,7 @@ function readConfigJson() {
     }
     catch (e) {
         throw new Error(`Invalid JSON in ${exports.CONFIG_FILE}: ${e.message}\n` +
-            `Fix the file manually or delete it and run: rag-setup`);
+            `Fix the file manually or delete it and run: rag-setup`, { cause: e });
     }
     return parseConfig(parsed, exports.CONFIG_FILE);
 }
@@ -198,19 +178,9 @@ const OLLAMA_MIGRATION_REMEDY = 'The "ollama" embedding provider has been remove
     'and embedding.baseURL to "http://localhost:11434/v1" — via `rag-config edit` (or by ' +
     'editing the config file directly) or by re-running `rag-setup`. After switching, rebuild ' +
     'the index with `rag-index --reindex`.';
-/** Strip a trailing `:tag` (Docker-style) from a model name, if present. */
 function stripModelTag(model) {
     return model.replace(/:[^:]*$/, '');
 }
-/**
- * Detect a raw (pre-migration) config object that still selects the removed
- * `ollama` embedding provider — explicitly, via a legacy top-level `ollama`
- * block, or implicitly (no `provider` set, but `baseURL`/`model` point at
- * Ollama's defaults) — and throw a `ConfigError` with migration guidance
- * instead of letting it validate under a silently reinterpreted provider.
- * Runs before `migrateRawConfig` so a legacy `ollama.*` block is never
- * converted into an `embedding` block first. Pure — never mutates `raw`.
- */
 function detectFormerOllamaConfig(raw) {
     if (raw == null || typeof raw !== 'object')
         return;
@@ -227,7 +197,7 @@ function detectFormerOllamaConfig(raw) {
                 try {
                     port = new URL(e.baseURL).port;
                 }
-                catch { /* unparsable — not a signal */ }
+                catch { }
                 if (port === '11434') {
                     throw new config_error_1.ConfigError(`Config's embedding.baseURL targets Ollama's default port (11434) with no embedding.provider set. ${OLLAMA_MIGRATION_REMEDY}`);
                 }
@@ -242,21 +212,6 @@ function detectFormerOllamaConfig(raw) {
         throw new config_error_1.ConfigError(`Config has a legacy "ollama" configuration block. ${OLLAMA_MIGRATION_REMEDY}`);
     }
 }
-/**
- * Migrate a legacy raw config object to the current shape, in place of a
- * versioned migration system. Pure — returns a new object, never mutates input.
- *
- * - Removed translation keys (`search.autoTranslate`, `search.translateModel`)
- *   are dropped so they neither validate-fail nor take effect.
- * - Legacy `reranker.provider: 'ollama'` (a dead value — Ollama has no rerank
- *   API) is rewritten to `openai-compatible`, and a stale `/api/rerank` URL is
- *   dropped so it re-derives to `/rerank`. Otherwise the tightened enum would
- *   fail validation on existing configs and lock the user out.
- *
- * A legacy top-level `ollama` block reaches here only when `detectFormerOllamaConfig`
- * did not already reject it (i.e. an `embedding` block is also present); it is
- * dropped rather than merged. Exported for unit testing.
- */
 function migrateRawConfig(raw) {
     if (raw == null || typeof raw !== 'object')
         return raw;
@@ -274,16 +229,6 @@ function migrateRawConfig(raw) {
     }
     return obj;
 }
-/**
- * Validate a raw (pre-migration) config object against the Zod schema: first
- * `detectFormerOllamaConfig` (a `ConfigError` on a former-Ollama config takes
- * priority over both migration and the regular Zod enum rejection), then
- * `migrateRawConfig`, then the schema itself. Unknown keys (e.g. the "$schema"
- * editor reference) are stripped. Throws with a caller-friendly message on
- * validation failure. The single entry point for both `readConfigJson` and
- * `PUT /api/config`, so both apply identical rules with an identical message.
- * Pure — no file I/O.
- */
 function parseConfig(raw, source = exports.CONFIG_FILE) {
     detectFormerOllamaConfig(raw);
     const migrated = migrateRawConfig(raw);
@@ -295,7 +240,6 @@ function parseConfig(raw, source = exports.CONFIG_FILE) {
     }
     return result.data;
 }
-/** Build the JSON Schema object generated from the Zod config schema. Pure. */
 function buildJsonSchema() {
     return {
         $id: 'https://github.com/oleksandr-antoniuk/RAG/config.schema.json',
@@ -306,15 +250,9 @@ function buildJsonSchema() {
 function writeConfigJson(data) {
     fs.mkdirSync(exports.CONFIG_DIR, { recursive: true });
     writeSchemaFile();
-    // $schema first so editors pick it up; readConfigJson strips it on validation.
     const withSchema = { $schema: SCHEMA_REF, ...data };
     fs.writeFileSync(exports.CONFIG_FILE, JSON.stringify(withSchema, null, 2) + '\n', { mode: 0o600 });
 }
-/**
- * Generate a JSON Schema from the Zod config schema and write it next to
- * config.json. Editors resolve it via the "$schema" reference and provide
- * key autocomplete, type hints, and inline validation while editing.
- */
 function writeSchemaFile() {
     fs.mkdirSync(exports.CONFIG_DIR, { recursive: true });
     fs.writeFileSync(exports.SCHEMA_FILE, JSON.stringify(buildJsonSchema(), null, 2) + '\n');

package/dist/src/config.d.ts

@@ -1,13 +1,12 @@
+import { type JsonConfig } from './config-store';
 import { ConfigError } from './config-error';
 export { ConfigError };
-/**
- * Resolve a config value that may reference an environment variable. A value of
- * the form `env:VAR_NAME` resolves to `process.env.VAR_NAME`; any other string
- * (including empty) is returned verbatim. A referenced-but-unset variable throws
- * a clear error naming the variable and the `.env` file. Pure aside from the
- * injected env map. See `src/app.ts` for how `.env` is loaded into the process.
- */
 export declare function resolveEnvRef(value: string, env?: NodeJS.ProcessEnv): string;
+export declare function rerankContext(raw: JsonConfig): {
+    wanted: boolean;
+    missingKey: boolean;
+    model: string;
+};
 export declare class Config {
     private readonly data;
     get db(): {
@@ -17,13 +16,6 @@ export declare class Config {
         password: string;
         database: string;
     };
-    /**
-     * Embedding config. `apiKey` is returned **raw** (possibly an `env:VAR` ref) —
-     * callers resolve it lazily via `resolveEnvRef` at the moment they build a
-     * request, so an unset referenced variable fails only when the key is actually
-     * needed (during embed/search) rather than crashing container construction and
-     * locking the user out of `rag-web`/`rag-mcp`.
-     */
     get embedding(): {
         provider: "openai-compatible" | "voyage" | "infinity";
         baseURL: string;
@@ -32,14 +24,14 @@ export declare class Config {
         dimensions: number | null;
         batchSize: number;
     };
-    /** Reranker config. `apiKey` is raw — resolve lazily with `resolveEnvRef`. */
     get reranker(): {
         enabled: boolean;
-        provider: "openai-compatible";
+        provider: "openai-compatible" | "voyage";
         baseURL: string;
         apiKey: string;
         model: string;
         url: string;
+        missingApiKey: boolean;
         overfetch: number;
         candidateFloor: number;
     };
@@ -51,13 +43,12 @@ export declare class Config {
         chunkStrategy: "ast" | "character";
     };
     get search(): {
-        similarityThreshold: number;
         defaultLimit: number;
         maxLimit: number;
+        similarityThreshold?: number | undefined;
     };
     get logging(): {
         level: "error" | "debug" | "info" | "warn";
-        searchMetrics: boolean;
         dir?: string | undefined;
     };
     get workspaceRoot(): string;

package/dist/src/config.js

@@ -35,18 +35,13 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Config = exports.ConfigError = void 0;
 exports.resolveEnvRef = resolveEnvRef;
+exports.rerankContext = rerankContext;
 const os = __importStar(require("os"));
 const zod_1 = require("zod");
 const config_store_1 = require("./config-store");
+const constants_1 = require("./constants");
 const config_error_1 = require("./config-error");
 Object.defineProperty(exports, "ConfigError", { enumerable: true, get: function () { return config_error_1.ConfigError; } });
-/**
- * Resolve a config value that may reference an environment variable. A value of
- * the form `env:VAR_NAME` resolves to `process.env.VAR_NAME`; any other string
- * (including empty) is returned verbatim. A referenced-but-unset variable throws
- * a clear error naming the variable and the `.env` file. Pure aside from the
- * injected env map. See `src/app.ts` for how `.env` is loaded into the process.
- */
 function resolveEnvRef(value, env = process.env) {
     if (!value.startsWith('env:'))
         return value;
@@ -66,12 +61,19 @@ const DEFAULT_BASE_URLS = {
 function defaultBaseURL(provider) {
     return DEFAULT_BASE_URLS[provider] ?? DEFAULT_BASE_URLS.infinity;
 }
-// Reranking is served only by OpenAI-compatible `/rerank` endpoints (Infinity,
-// TEI, vLLM, Jina/Cohere-shape) — a single endpoint shape. Normalize a trailing
-// `/embeddings` or `/v1` to the server root so a baseURL written with an
-// OpenAI-style suffix still yields `<root>/rerank`.
-function deriveRerankUrl(baseURL) {
-    const root = baseURL.replace(/\/+$/, '').replace(/\/(embeddings|v1)$/, '');
+function rerankContext(raw) {
+    const rr = raw.reranker;
+    const embProvider = raw.embedding?.provider ?? config_store_1.CONFIG_DEFAULTS['embedding.provider'];
+    const isVoyage = (rr?.provider ?? config_store_1.CONFIG_DEFAULTS['reranker.provider']) === 'voyage';
+    return {
+        wanted: embProvider === 'infinity' || rr?.provider != null || rr?.baseURL != null || rr?.url != null,
+        missingKey: isVoyage && !rr?.apiKey,
+        model: isVoyage ? constants_1.VOYAGE_RERANK_MODELS[0] : config_store_1.CONFIG_DEFAULTS['reranker.model'],
+    };
+}
+function deriveRerankUrl(provider, baseURL) {
+    const trimmed = baseURL.replace(/\/+$/, '');
+    const root = provider === 'voyage' ? trimmed : trimmed.replace(/\/(embeddings|v1)$/, '');
     return `${root}/rerank`;
 }
 const resolvedSchema = zod_1.z.object({
@@ -91,12 +93,13 @@ const resolvedSchema = zod_1.z.object({
         batchSize: zod_1.z.number().int().positive().default(config_store_1.CONFIG_DEFAULTS['embedding.batchSize']),
     }),
     reranker: zod_1.z.object({
-        enabled: zod_1.z.boolean().default(config_store_1.CONFIG_DEFAULTS['reranker.enabled']),
-        provider: zod_1.z.enum(['openai-compatible']).default(config_store_1.CONFIG_DEFAULTS['reranker.provider']),
+        enabled: zod_1.z.boolean(),
+        provider: zod_1.z.enum(['openai-compatible', 'voyage']).default(config_store_1.CONFIG_DEFAULTS['reranker.provider']),
         baseURL: zod_1.z.string().min(1),
         apiKey: zod_1.z.string().default(config_store_1.CONFIG_DEFAULTS['reranker.apiKey']),
-        model: zod_1.z.string().default(config_store_1.CONFIG_DEFAULTS['reranker.model']),
+        model: zod_1.z.string(),
         url: zod_1.z.string().min(1),
+        missingApiKey: zod_1.z.boolean(),
         overfetch: zod_1.z.number().int().min(1).max(20).default(config_store_1.CONFIG_DEFAULTS['reranker.overfetch']),
         candidateFloor: zod_1.z.number().int().min(1).default(config_store_1.CONFIG_DEFAULTS['reranker.candidateFloor']),
     }),
@@ -108,29 +111,20 @@ const resolvedSchema = zod_1.z.object({
         chunkStrategy: zod_1.z.enum(['ast', 'character']).default(config_store_1.CONFIG_DEFAULTS['indexing.chunkStrategy']),
     }),
     search: zod_1.z.object({
-        similarityThreshold: zod_1.z.number().min(0).max(1).default(config_store_1.CONFIG_DEFAULTS['search.similarityThreshold']),
+        similarityThreshold: zod_1.z.number().min(0).max(1).optional(),
         defaultLimit: zod_1.z.number().int().positive().default(config_store_1.CONFIG_DEFAULTS['search.defaultLimit']),
         maxLimit: zod_1.z.number().int().positive().default(config_store_1.CONFIG_DEFAULTS['search.maxLimit']),
     }),
     logging: zod_1.z.object({
         level: zod_1.z.enum(['debug', 'info', 'warn', 'error']).default(config_store_1.CONFIG_DEFAULTS['logging.level']),
         dir: zod_1.z.string().optional(),
-        searchMetrics: zod_1.z.boolean().default(config_store_1.CONFIG_DEFAULTS['logging.searchMetrics']),
     }),
     workspaceRoot: zod_1.z.string().default(''),
 });
 class Config {
     data;
     get db() { return this.data.db; }
-    /**
-     * Embedding config. `apiKey` is returned **raw** (possibly an `env:VAR` ref) —
-     * callers resolve it lazily via `resolveEnvRef` at the moment they build a
-     * request, so an unset referenced variable fails only when the key is actually
-     * needed (during embed/search) rather than crashing container construction and
-     * locking the user out of `rag-web`/`rag-mcp`.
-     */
     get embedding() { return this.data.embedding; }
-    /** Reranker config. `apiKey` is raw — resolve lazily with `resolveEnvRef`. */
     get reranker() { return this.data.reranker; }
     get indexer() { return this.data.indexer; }
     get search() { return this.data.search; }
@@ -142,8 +136,15 @@ class Config {
             throw new config_error_1.ConfigError('Config not found. Run rag-setup.');
         const embProvider = (raw.embedding?.provider ?? config_store_1.CONFIG_DEFAULTS['embedding.provider']);
         const embBaseURL = raw.embedding?.baseURL ?? defaultBaseURL(embProvider);
-        const rerankBaseURL = raw.reranker?.baseURL ?? embBaseURL;
-        const rerankUrl = raw.reranker?.url ?? deriveRerankUrl(rerankBaseURL);
+        const rr = raw.reranker;
+        const rerankProvider = (rr?.provider ?? config_store_1.CONFIG_DEFAULTS['reranker.provider']);
+        const isVoyageRerank = rerankProvider === 'voyage';
+        const rerankBaseURL = rr?.baseURL ?? (isVoyageRerank ? DEFAULT_BASE_URLS.voyage : embBaseURL);
+        const rerankUrl = rr?.url ?? deriveRerankUrl(rerankProvider, rerankBaseURL);
+        const rerankCtx = rerankContext(raw);
+        const rerankModel = rr?.model ?? rerankCtx.model;
+        const rerankWanted = rr?.enabled ?? rerankCtx.wanted;
+        const missingApiKey = rerankWanted && rerankCtx.missingKey;
         const result = resolvedSchema.safeParse({
             db: {
                 host: raw.db?.host,
@@ -161,14 +162,15 @@ class Config {
                 batchSize: raw.embedding?.batchSize,
             },
             reranker: {
-                enabled: raw.reranker?.enabled,
-                provider: raw.reranker?.provider,
+                enabled: rerankWanted && !missingApiKey,
+                provider: rr?.provider,
                 baseURL: rerankBaseURL,
-                apiKey: raw.reranker?.apiKey,
-                model: raw.reranker?.model,
+                apiKey: rr?.apiKey,
+                model: rerankModel,
                 url: rerankUrl,
-                overfetch: raw.reranker?.overfetch,
-                candidateFloor: raw.reranker?.candidateFloor,
+                missingApiKey,
+                overfetch: rr?.overfetch,
+                candidateFloor: rr?.candidateFloor,
             },
             indexer: {
                 chunkSize: raw.indexing?.chunkSize,
@@ -185,7 +187,6 @@ class Config {
             logging: {
                 level: raw.logging?.level,
                 dir: raw.logging?.dir,
-                searchMetrics: raw.logging?.searchMetrics,
             },
             workspaceRoot: raw.workspaceRoot,
         });

package/dist/src/constants.d.ts

@@ -1,42 +1,31 @@
 export type EmbeddingProvider = 'openai-compatible' | 'voyage' | 'infinity';
-/**
- * pgvector's HNSW / IVFFlat index hard limit. The effective embedding dimension
- * must not exceed this; larger cloud models must reduce via the Matryoshka
- * `dimensions` request parameter (`embedding.dimensions`).
- */
+export type RerankProvider = 'openai-compatible' | 'voyage';
+export declare const VOYAGE_RERANK_MODELS: readonly ["rerank-3", "rerank-3-lite"];
 export declare const MAX_EMBED_DIM = 2000;
 export interface ModelInfo {
     provider: EmbeddingProvider;
-    /** Native / default output width. */
     dimensions: number;
-    /** Model supports Matryoshka dimension reduction via a request parameter. */
     dimConfigurable?: boolean;
-    /** Max width that can be indexed under the pgvector cap (advisory). */
     maxIndexable?: number;
-    /** Max width the model itself can emit (advisory). */
     maxDim?: number;
+    defaultThreshold?: number;
 }
-/**
- * Advisory (NOT exhaustive) registry of known embedding models. Used to resolve
- * a model's dimension without a runtime probe and to suggest models in the
- * dashboard. Models absent here still work — their dimension is probed at index
- * time (see `resolveDimension`).
- */
 export declare const MODEL_REGISTRY: Record<string, ModelInfo>;
 export declare const DEFAULT_EMBED_MODEL = "jinaai/jina-embeddings-v2-base-code";
-/**
- * Former Ollama registry model names, kept only so config validation can
- * recognise an implicit (provider-less) config that still targets Ollama —
- * see `detectFormerOllamaConfig` in `config-store.ts`.
- */
 export declare const FORMER_OLLAMA_MODELS: readonly ["bge-m3", "nomic-embed-text", "mxbai-embed-large"];
-/** Advisory dimension for a model, or `undefined` when the model is unknown. */
 export declare function registryDimension(model: string): number | undefined;
-/**
- * Resolve the effective vector dimension: explicit override → registry → probe.
- * Validates the result is ≤ MAX_EMBED_DIM, throwing an error that names
- * `embedding.dimensions` as the fix. `probeFn` embeds a short string once and
- * returns the observed length; only called when neither override nor registry
- * yields a value. Pure aside from the injected probe.
- */
+export type ThresholdSource = 'call' | 'config' | 'model' | 'fallback';
+export interface ResolvedThreshold {
+    value: number;
+    source: ThresholdSource;
+}
+export declare const FALLBACK_THRESHOLD = 1;
+export declare function resolveThreshold({ callValue, configValue, model, registry }: {
+    callValue?: number;
+    configValue?: number;
+    model: string;
+    registry?: Record<string, ModelInfo>;
+}): ResolvedThreshold;
+export declare function formatThreshold(value: number): string;
+export declare function thresholdMismatchWarning(configValue: number | undefined, model: string, registry?: Record<string, ModelInfo>): string | null;
 export declare function resolveDimension(override: number | null | undefined, model: string, probeFn: () => Promise<number>, registry?: Record<string, ModelInfo>): Promise<number>;

package/dist/src/constants.js

@@ -1,48 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FORMER_OLLAMA_MODELS = exports.DEFAULT_EMBED_MODEL = exports.MODEL_REGISTRY = exports.MAX_EMBED_DIM = void 0;
+exports.FALLBACK_THRESHOLD = exports.FORMER_OLLAMA_MODELS = exports.DEFAULT_EMBED_MODEL = exports.MODEL_REGISTRY = exports.MAX_EMBED_DIM = exports.VOYAGE_RERANK_MODELS = void 0;
 exports.registryDimension = registryDimension;
+exports.resolveThreshold = resolveThreshold;
+exports.formatThreshold = formatThreshold;
+exports.thresholdMismatchWarning = thresholdMismatchWarning;
 exports.resolveDimension = resolveDimension;
-/**
- * pgvector's HNSW / IVFFlat index hard limit. The effective embedding dimension
- * must not exceed this; larger cloud models must reduce via the Matryoshka
- * `dimensions` request parameter (`embedding.dimensions`).
- */
+exports.VOYAGE_RERANK_MODELS = ['rerank-3', 'rerank-3-lite'];
 exports.MAX_EMBED_DIM = 2000;
-/**
- * Advisory (NOT exhaustive) registry of known embedding models. Used to resolve
- * a model's dimension without a runtime probe and to suggest models in the
- * dashboard. Models absent here still work — their dimension is probed at index
- * time (see `resolveDimension`).
- */
 exports.MODEL_REGISTRY = {
     'text-embedding-3-small': { provider: 'openai-compatible', dimensions: 1536, dimConfigurable: true },
     'text-embedding-3-large': { provider: 'openai-compatible', dimensions: 3072, dimConfigurable: true, maxIndexable: 2000 },
     'text-embedding-ada-002': { provider: 'openai-compatible', dimensions: 1536 },
-    'voyage-code-3': { provider: 'voyage', dimensions: 1024, dimConfigurable: true, maxDim: 2048 },
-    'voyage-3': { provider: 'voyage', dimensions: 1024, dimConfigurable: true },
-    'voyage-3-lite': { provider: 'voyage', dimensions: 512 },
+    'voyage-code-4': { provider: 'voyage', dimensions: 1024, dimConfigurable: true, maxDim: 2048, defaultThreshold: 0.95 },
+    'voyage-4-large': { provider: 'voyage', dimensions: 1024, dimConfigurable: true, maxDim: 2048, defaultThreshold: 0.95 },
+    'voyage-4': { provider: 'voyage', dimensions: 1024, dimConfigurable: true, maxDim: 2048, defaultThreshold: 0.95 },
+    'voyage-4-lite': { provider: 'voyage', dimensions: 1024, dimConfigurable: true, maxDim: 2048, defaultThreshold: 0.95 },
     'BAAI/bge-m3': { provider: 'infinity', dimensions: 1024 },
-    'jinaai/jina-embeddings-v2-base-code': { provider: 'infinity', dimensions: 768 },
+    'jinaai/jina-embeddings-v2-base-code': { provider: 'infinity', dimensions: 768, defaultThreshold: 0.6 },
 };
 exports.DEFAULT_EMBED_MODEL = 'jinaai/jina-embeddings-v2-base-code';
-/**
- * Former Ollama registry model names, kept only so config validation can
- * recognise an implicit (provider-less) config that still targets Ollama —
- * see `detectFormerOllamaConfig` in `config-store.ts`.
- */
 exports.FORMER_OLLAMA_MODELS = ['bge-m3', 'nomic-embed-text', 'mxbai-embed-large'];
-/** Advisory dimension for a model, or `undefined` when the model is unknown. */
 function registryDimension(model) {
     return exports.MODEL_REGISTRY[model]?.dimensions;
 }
-/**
- * Resolve the effective vector dimension: explicit override → registry → probe.
- * Validates the result is ≤ MAX_EMBED_DIM, throwing an error that names
- * `embedding.dimensions` as the fix. `probeFn` embeds a short string once and
- * returns the observed length; only called when neither override nor registry
- * yields a value. Pure aside from the injected probe.
- */
+exports.FALLBACK_THRESHOLD = 1.0;
+const THRESHOLD_MISMATCH_TOLERANCE = 0.1;
+const FLOAT_EPSILON = 1e-9;
+function resolveThreshold({ callValue, configValue, model, registry = exports.MODEL_REGISTRY }) {
+    if (callValue !== undefined)
+        return { value: callValue, source: 'call' };
+    if (configValue !== undefined)
+        return { value: configValue, source: 'config' };
+    const recommended = registry[model]?.defaultThreshold;
+    if (recommended !== undefined)
+        return { value: recommended, source: 'model' };
+    return { value: exports.FALLBACK_THRESHOLD, source: 'fallback' };
+}
+function formatThreshold(value) {
+    return Number.isInteger(value) ? value.toFixed(1) : String(value);
+}
+function thresholdMismatchWarning(configValue, model, registry = exports.MODEL_REGISTRY) {
+    const recommended = registry[model]?.defaultThreshold;
+    if (configValue === undefined || recommended === undefined)
+        return null;
+    if (Math.abs(configValue - recommended) <= THRESHOLD_MISMATCH_TOLERANCE + FLOAT_EPSILON)
+        return null;
+    return `search.similarityThreshold is ${formatThreshold(configValue)}, but the recommended value for ${model} is ${formatThreshold(recommended)}. `
+        + 'Searches may miss relevant code or return weak matches. Remove the key to follow the model, or retune it (rag-config edit).';
+}
 async function resolveDimension(override, model, probeFn, registry = exports.MODEL_REGISTRY) {
     let dim;
     if (override != null) {

package/dist/src/container.d.ts

@@ -1,19 +1,27 @@
 import { Config } from './config';
 import { IndexerService } from './services/IndexerService';
+import { type SearchServices } from './search/create-search-services';
 import { McpServer } from './services/McpServer';
+import { LoggerService } from './services/LoggerService';
 import type { IDatabase } from './interfaces';
 import type { IEmbedder } from './interfaces';
-import type { ISearcher } from './interfaces';
 import type { ILogger } from './interfaces';
 import type { IProjectDiscovery } from './interfaces';
+import type { IMcpReadiness } from './interfaces';
 export interface Container {
     config: Config;
     db: IDatabase;
     embedder: IEmbedder;
     indexer: IndexerService;
-    searcher: ISearcher;
+    search: SearchServices;
+    readiness: IMcpReadiness;
     mcp: McpServer;
     logger: ILogger;
     discovery: IProjectDiscovery;
 }
+export declare function loggerBindingsFor(loggerName?: string): Record<string, unknown> | undefined;
+export declare function createLogger(cfg: {
+    level: string;
+    dir?: string;
+}, loggerName?: string): LoggerService;
 export declare function createContainer(loggerName?: string): Container;

package/dist/src/container.js

@@ -1,27 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.loggerBindingsFor = loggerBindingsFor;
+exports.createLogger = createLogger;
 exports.createContainer = createContainer;
+const crypto_1 = require("crypto");
 const config_1 = require("./config");
 const DatabaseService_1 = require("./services/DatabaseService");
 const EmbedderFactory_1 = require("./services/EmbedderFactory");
 const AstParserService_1 = require("./services/AstParserService");
-const AstChunker_1 = require("./services/AstChunker");
+const create_chunker_1 = require("./chunking/create-chunker");
 const IndexerService_1 = require("./services/IndexerService");
-const SearcherService_1 = require("./services/SearcherService");
+const create_search_services_1 = require("./search/create-search-services");
 const McpServer_1 = require("./services/McpServer");
+const McpReadiness_1 = require("./services/McpReadiness");
 const LoggerService_1 = require("./services/LoggerService");
 const MonorepoAwareDiscoveryService_1 = require("./services/MonorepoAwareDiscoveryService");
 const NxMonorepoResolver_1 = require("./services/NxMonorepoResolver");
+function loggerBindingsFor(loggerName) {
+    return loggerName === 'mcp' ? { connectionId: (0, crypto_1.randomUUID)() } : undefined;
+}
+function createLogger(cfg, loggerName) {
+    return LoggerService_1.LoggerService.fromConfig(cfg, loggerName, loggerBindingsFor(loggerName));
+}
 function createContainer(loggerName) {
     const config = new config_1.Config();
-    const logger = LoggerService_1.LoggerService.fromConfig(config.logging, loggerName);
-    const db = new DatabaseService_1.DatabaseService(config);
+    const logger = createLogger(config.logging, loggerName);
+    const db = new DatabaseService_1.DatabaseService(config, logger);
     const embedder = (0, EmbedderFactory_1.createEmbedder)(config, logger);
     const ast = new AstParserService_1.AstParserService(logger);
-    const chunker = new AstChunker_1.AstChunker(config);
+    const chunker = (0, create_chunker_1.createChunker)(config);
     const discovery = new MonorepoAwareDiscoveryService_1.MonorepoAwareDiscoveryService([new NxMonorepoResolver_1.NxMonorepoResolver(logger)], logger);
     const indexer = new IndexerService_1.IndexerService(db, embedder, ast, chunker, config, logger);
-    const searcher = new SearcherService_1.SearcherService(db, embedder, discovery, config, logger);
-    const mcp = new McpServer_1.McpServer(searcher, config, logger);
-    return { config, db, embedder, indexer, searcher, mcp, logger, discovery };
+    const search = (0, create_search_services_1.createSearchServices)(db, embedder, discovery, config, logger);
+    const readiness = new McpReadiness_1.McpReadiness(db, search.identity, logger);
+    const mcp = new McpServer_1.McpServer(search, readiness, config, logger);
+    return { config, db, embedder, indexer, search, readiness, mcp, logger, discovery };
 }

package/dist/src/db/drizzle-types.d.ts

@@ -0,0 +1,7 @@
+import type { NodePgDatabase, NodePgTransaction } from 'drizzle-orm/node-postgres';
+import type { ExtractTablesWithRelations } from 'drizzle-orm/relations';
+import * as schema from './schema';
+type Schema = typeof schema;
+export type DrizzleDb = NodePgDatabase<Schema>;
+export type DrizzleTx = NodePgTransaction<Schema, ExtractTablesWithRelations<Schema>>;
+export {};

package/dist/src/db/drizzle-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/db/index.d.ts

@@ -1,2 +1,3 @@
 export { codeChunk, codeDependency, codeSymbol, codeCall, indexMeta } from './schema';
 export type { CodeChunkInsert } from './schema';
+export type { DrizzleDb, DrizzleTx } from './drizzle-types';