codesearch-mcp 0.2.3-alpha → 0.3.0-alpha

package/dist/src/services/DatabaseService.js

@@ -40,6 +40,8 @@ const drizzle_orm_1 = require("drizzle-orm");
 const schema = __importStar(require("../db/schema"));
 const db_1 = require("../db");
 const MIN_PG_VERSION_NUM = 150000;
+const SETTING_NAME = /^[a-z_]+(\.[a-z_]+)*$/;
+const SETTING_VALUE = /^[A-Za-z0-9_]+$/;
 class DatabaseService {
     config;
     pool;
@@ -52,6 +54,41 @@ class DatabaseService {
         const result = await this.pool.query(sql, params);
         return result.rows;
     }
+    async queryWithLocalSettings(settings, sql, params) {
+        const setStatements = Object.entries(settings).map(([name, value]) => {
+            if (!SETTING_NAME.test(name) || !SETTING_VALUE.test(String(value))) {
+                throw new Error(`DatabaseService: invalid local setting ${JSON.stringify(name)} = ${JSON.stringify(value)}`);
+            }
+            return `SET LOCAL ${name} = ${value}`;
+        });
+        const client = await this.pool.connect();
+        let began = false;
+        let broken;
+        const onError = (err) => { broken ??= err; };
+        client.on('error', onError);
+        try {
+            await client.query('BEGIN');
+            began = true;
+            for (const statement of setStatements)
+                await client.query(statement);
+            const result = await client.query(sql, params);
+            await client.query('COMMIT');
+            return result.rows;
+        }
+        catch (err) {
+            if (began)
+                await client.query('ROLLBACK').catch((e) => { broken ??= e; });
+            throw err;
+        }
+        finally {
+            client.removeListener('error', onError);
+            client.release(broken);
+        }
+    }
+    async pgvectorVersion() {
+        const rows = await this.query(`SELECT extversion FROM pg_extension WHERE extname = 'vector'`);
+        return rows[0]?.extversion ?? null;
+    }
     transaction(fn) {
         return this._db.transaction(fn);
     }
@@ -69,17 +106,8 @@ class DatabaseService {
     async initDbWithSchema() {
         await this.ensureDatabaseExists();
         await this.initDb();
-        // Read as the very first statement on the application database, before any
-        // CREATE TABLE / CREATE INDEX / ALTER TABLE / DROP — `NULLS NOT DISTINCT`
-        // (used below) requires PostgreSQL 15+, and the DROP/CREATE pair must never
-        // run against an older server (it would fail after the DROP and leave
-        // code_symbol without a unique index).
         await this.assertMinPostgresVersion();
-        // code_chunk table — created at the legacy default width (1024) so search
-        // tools always have a table. IndexerService recreates it at the resolved
-        // width before indexing when the active model's dimension differs.
         await this.ensureChunkTable(1024);
-        // index_meta table — source of truth for the model that built the index.
         await this.query(`
       CREATE TABLE IF NOT EXISTS index_meta (
         id          BOOLEAN PRIMARY KEY DEFAULT true,
@@ -89,7 +117,6 @@ class DatabaseService {
         "indexedAt" TIMESTAMPTZ NOT NULL DEFAULT now()
       )
     `);
-        // code_dependency table
         const [{ existsDep }] = await this.query(`
       SELECT EXISTS (
         SELECT 1 FROM information_schema.tables
@@ -114,7 +141,6 @@ class DatabaseService {
         await this.query(`DROP INDEX IF EXISTS idx_dep_from`);
         await this.query(`DROP INDEX IF EXISTS idx_dep_to`);
         await this.query(`DROP INDEX IF EXISTS idx_dep_project`);
-        // code_symbol table
         const [{ existsSym }] = await this.query(`
       SELECT EXISTS (
         SELECT 1 FROM information_schema.tables
@@ -140,16 +166,11 @@ class DatabaseService {
         await this.query(`ALTER TABLE code_symbol ADD COLUMN IF NOT EXISTS container TEXT`);
         await this.query(`ALTER TABLE code_symbol ADD COLUMN IF NOT EXISTS "isStatic" BOOLEAN NOT NULL DEFAULT false`);
         await this.query(`ALTER TABLE code_symbol ADD COLUMN IF NOT EXISTS "target" TEXT`);
-        // DDL is transactional in PostgreSQL — either both statements apply or
-        // neither does, so a failure here never leaves code_symbol without a
-        // unique index (the old idx_symbol_unique is dropped only once the new
-        // one is confirmed to exist).
         await this.transaction(async (tx) => {
             await tx.execute('DROP INDEX IF EXISTS idx_symbol_unique');
             await tx.execute('CREATE UNIQUE INDEX IF NOT EXISTS idx_symbol_unique_v2 ' +
                 'ON code_symbol (project, "filePath", container, name, kind, line) NULLS NOT DISTINCT');
         });
-        // code_call table
         await this.query(`
       CREATE TABLE IF NOT EXISTS code_call (
         id             UUID PRIMARY KEY DEFAULT gen_random_uuid(),
@@ -167,11 +188,6 @@ class DatabaseService {
         await this.query(`CREATE INDEX IF NOT EXISTS idx_call_callee_file ON code_call (project, "calleeFile")`);
         await this.query(`CREATE INDEX IF NOT EXISTS idx_call_from        ON code_call (project, "fromFile")`);
     }
-    /**
-     * Create `code_chunk` at `dimensions` if it does not exist, plus its HNSW and
-     * (serviceName, filePath) indexes and the additive `contentHash`/`ownerPath`
-     * columns for pre-existing tables. Idempotent — safe to call repeatedly.
-     */
     async ensureChunkTable(dimensions) {
         const dim = this.assertDim(dimensions);
         await this.query(`
@@ -184,15 +200,16 @@ class DatabaseService {
         embedding     vector(${dim}) NOT NULL,
         "lastModified" DOUBLE PRECISION,
         "contentHash"  VARCHAR(64),
-        "ownerPath"    VARCHAR
+        "ownerPath"    VARCHAR,
+        "endLine"      INT
       )
     `);
         await this.query(`ALTER TABLE code_chunk ADD COLUMN IF NOT EXISTS "contentHash" varchar(64) NULL`);
         await this.query(`ALTER TABLE code_chunk ADD COLUMN IF NOT EXISTS "ownerPath" varchar NULL`);
+        await this.query(`ALTER TABLE code_chunk ADD COLUMN IF NOT EXISTS "endLine" integer NULL`);
         await this.query(`CREATE INDEX IF NOT EXISTS idx_code_chunk_embedding ON code_chunk USING hnsw (embedding vector_cosine_ops)`);
         await this.query(`CREATE INDEX IF NOT EXISTS idx_code_chunk_service_file ON code_chunk ("serviceName", "filePath")`);
     }
-    /** Drop and recreate `code_chunk` at `dimensions` — used on a dimension change. */
     async recreateChunkTable(dimensions) {
         const dim = this.assertDim(dimensions);
         await this.query(`DROP TABLE IF EXISTS code_chunk`);
@@ -205,7 +222,6 @@ class DatabaseService {
             return row ? { provider: row.provider, model: row.model, dimensions: Number(row.dimensions) } : null;
         }
         catch {
-            // Table absent (un-migrated DB) — treat as "no metadata".
             return null;
         }
     }
@@ -231,8 +247,6 @@ class DatabaseService {
     async deleteFiles(project, filePaths) {
         if (filePaths.length === 0)
             return;
-        // PostgreSQL limits ~32 767 bind params per statement; OR queries bind the
-        // array twice (fromFile + calleeFile), so cap each batch at 10 000 entries.
         const BATCH = 10_000;
         await this.transaction(async (tx) => {
             for (let i = 0; i < filePaths.length; i += BATCH) {
@@ -262,7 +276,6 @@ class DatabaseService {
             await tx.delete(db_1.codeDependency).where((0, drizzle_orm_1.eq)(db_1.codeDependency.project, name));
         });
     }
-    /** Guard against SQL injection — the dimension is interpolated into DDL. */
     assertDim(dimensions) {
         if (!Number.isInteger(dimensions) || dimensions <= 0 || dimensions > 2000) {
             throw new Error(`Invalid vector dimension: ${dimensions} (must be an integer 1–2000)`);
@@ -276,7 +289,7 @@ class DatabaseService {
             versionNum = Number(rows[0]?.v);
         }
         catch (err) {
-            throw new Error(`Failed to read PostgreSQL server_version_num (requires PostgreSQL 15+): ${err.message}`);
+            throw new Error(`Failed to read PostgreSQL server_version_num (requires PostgreSQL 15+): ${err.message}`, { cause: err });
         }
         if (!Number.isFinite(versionNum) || versionNum < MIN_PG_VERSION_NUM) {
             throw new Error(`PostgreSQL 15+ is required (server_version_num=${versionNum}) — ` +
@@ -310,7 +323,7 @@ class DatabaseService {
         catch (err) {
             await client.end().catch(() => { });
             const msg = err instanceof Error ? err.message : String(err);
-            throw new Error(`Failed to ensure database "${database}" exists: ${msg}`);
+            throw new Error(`Failed to ensure database "${database}" exists: ${msg}`, { cause: err });
         }
     }
 }

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

@@ -2,8 +2,4 @@ import type { Config } from '../config';
 import type { IEmbedder } from '../interfaces/IEmbedder';
 import type { ILogger } from '../interfaces/ILogger';
 import { type EmbedderDeps } from './OpenAICompatibleEmbedder';
-/**
- * Construct the `IEmbedder` implementation selected by `config.embedding.provider`.
- * The default (`infinity`) is the recommended local backend.
- */
 export declare function createEmbedder(config: Config, logger?: ILogger, deps?: EmbedderDeps): IEmbedder;

package/dist/src/services/EmbedderFactory.js

@@ -5,10 +5,6 @@ const LoggerService_1 = require("./LoggerService");
 const OpenAICompatibleEmbedder_1 = require("./OpenAICompatibleEmbedder");
 const InfinityEmbedder_1 = require("./InfinityEmbedder");
 const VoyageEmbedder_1 = require("./VoyageEmbedder");
-/**
- * Construct the `IEmbedder` implementation selected by `config.embedding.provider`.
- * The default (`infinity`) is the recommended local backend.
- */
 function createEmbedder(config, logger = LoggerService_1.LoggerService.silent(), deps = {}) {
     switch (config.embedding.provider) {
         case 'openai-compatible':
@@ -18,7 +14,6 @@ function createEmbedder(config, logger = LoggerService_1.LoggerService.silent(),
         case 'voyage':
             return new VoyageEmbedder_1.VoyageEmbedder(config, logger, deps);
         default: {
-            // The Zod enum should already reject this; guard anyway for a clear message.
             const p = config.embedding.provider;
             throw new Error(`Unknown embedding provider: "${p}". Expected one of: openai-compatible, voyage, infinity.`);
         }

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

@@ -23,16 +23,6 @@ export declare class IndexerService {
     private config;
     private logger;
     constructor(db: IDatabase, embedder: IEmbedder, ast: IAstParser, chunker: IChunker, config: Config, logger?: ILogger);
-    /**
-     * Resolve the active embedding dimension (config override → registry → probe),
-     * reconcile it against `index_meta`, and prepare `code_chunk` accordingly:
-     * a dimension change drops+recreates the table; a same-dimension model/provider
-     * change clears its rows (vector spaces are not comparable across models); an
-     * unchanged model keeps the rows for incremental indexing. Back-compat: an
-     * existing populated table with no `index_meta` row is treated as the legacy
-     * `ollama`/`bge-m3`/1024 index. Writes `index_meta` to reflect the active model.
-     * Call once per run, before the scan loop.
-     */
     prepareEmbeddingSchema(): Promise<IndexMeta>;
     private reconcileIndex;
     private countChunks;
@@ -40,12 +30,6 @@ export declare class IndexerService {
     scanAndIndex(dir: string, serviceName: string, force?: boolean, signal?: AbortSignal, preCollectedFiles?: string[], opts?: {
         rootTsConfigPath?: string;
     }): Promise<IndexStats>;
-    /**
-     * Scan several leaf projects in one call, each with its own `rootTsConfigPath`
-     * (a unit's children may belong to different monorepos). No pruning, no
-     * console output — callers (CLI or a future hook) own reporting. A rejecting
-     * `scanAndIndex` call stops the loop before the next target and propagates.
-     */
     scanProjects(targets: DiscoveredProject[], force: boolean, signal: AbortSignal, filesPerProject: string[][]): Promise<IndexStats[]>;
     pruneProjects(keep: string[]): Promise<{
         removed: string[];

package/dist/src/services/IndexerService.js

@@ -40,13 +40,17 @@ const crypto_1 = require("crypto");
 const cli_progress_1 = require("cli-progress");
 const drizzle_orm_1 = require("drizzle-orm");
 const owner_path_1 = require("../owner-path");
+const DeclarationTree_1 = require("../declarations/DeclarationTree");
+const SourceLines_1 = require("../declarations/SourceLines");
 const enriched_prompt_1 = require("../enriched-prompt");
 const symbol_rows_1 = require("../symbol-rows");
 const db_1 = require("../db");
 const file_utils_1 = require("../file-utils");
 const LoggerService_1 = require("./LoggerService");
 const constants_1 = require("../constants");
+const error_record_1 = require("../error-record");
 const SCHEMA_EXTENSIONS = /\.(prisma|graphql|gql)$/;
+const JSX_EXTENSIONS = /\.(tsx|jsx|js)$/;
 class IndexerService {
     db;
     embedder;
@@ -62,16 +66,6 @@ class IndexerService {
         this.config = config;
         this.logger = logger;
     }
-    /**
-     * Resolve the active embedding dimension (config override → registry → probe),
-     * reconcile it against `index_meta`, and prepare `code_chunk` accordingly:
-     * a dimension change drops+recreates the table; a same-dimension model/provider
-     * change clears its rows (vector spaces are not comparable across models); an
-     * unchanged model keeps the rows for incremental indexing. Back-compat: an
-     * existing populated table with no `index_meta` row is treated as the legacy
-     * `ollama`/`bge-m3`/1024 index. Writes `index_meta` to reflect the active model.
-     * Call once per run, before the scan loop.
-     */
     async prepareEmbeddingSchema() {
         const { provider, model, dimensions: override } = this.config.embedding;
         const next = {
@@ -86,13 +80,11 @@ class IndexerService {
         if (!meta) {
             const chunkCount = await this.countChunks();
             if (chunkCount === 0) {
-                // Fresh index — create the table at the resolved width and record it.
                 await this.db.recreateChunkTable(next.dimensions);
                 await this.db.writeIndexMeta(next);
                 this.logger.debug('IndexerService: prepared fresh index', { ...next });
                 return next;
             }
-            // Legacy index (pre-index_meta): assume the historical default model.
             await this.reconcileIndex({ provider: 'ollama', model: 'bge-m3', dimensions: 1024 }, next);
             return next;
         }
@@ -118,9 +110,6 @@ class IndexerService {
             return Number(rows[0]?.n ?? 0);
         }
         catch (err) {
-            // A missing table means a fresh install → 0. Any other (transient) error
-            // must propagate — returning 0 here could wrongly recreate/drop a populated
-            // table on the `!meta` path.
             if (/does not exist/i.test(err.message))
                 return 0;
             throw err;
@@ -142,9 +131,6 @@ class IndexerService {
         const startTime = Date.now();
         this.logger.debug('IndexerService: scanAndIndex start', { serviceName, dir, force });
         if (force) {
-            // Reset incremental state and clear the project's symbol/call rows in one
-            // transaction: a file whose re-ingestion later fails must hold no rows at
-            // all, never rows in the previous (pre-member-extraction) format.
             await this.db.transaction(async (tx) => {
                 await tx.update(db_1.codeChunk)
                     .set({ lastModified: null, contentHash: null })
@@ -250,7 +236,7 @@ class IndexerService {
                 ]);
             }
             catch (err) {
-                this.logger.error('IndexerService: mtime refresh batch failed', { reason: err.message });
+                this.logger.error('IndexerService: mtime refresh batch failed', { err });
             }
         }
         this.ast.clearCache(dir);
@@ -265,12 +251,6 @@ class IndexerService {
         });
         return stats;
     }
-    /**
-     * Scan several leaf projects in one call, each with its own `rootTsConfigPath`
-     * (a unit's children may belong to different monorepos). No pruning, no
-     * console output — callers (CLI or a future hook) own reporting. A rejecting
-     * `scanAndIndex` call stops the loop before the next target and propagates.
-     */
     async scanProjects(targets, force, signal, filesPerProject) {
         const allStats = [];
         for (let i = 0; i < targets.length; i++) {
@@ -296,7 +276,7 @@ class IndexerService {
             }
             catch (err) {
                 console.error(`Failed to prune project ${name}: ${err.message}`);
-                this.logger.error('IndexerService: pruneProject failed', { name, reason: err.message });
+                this.logger.error('IndexerService: pruneProject failed', { name, err });
                 failed.push(name);
             }
         }
@@ -313,21 +293,17 @@ class IndexerService {
                 .from(db_1.codeChunk)
                 .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(db_1.codeChunk.serviceName, serviceName), (0, drizzle_orm_1.eq)(db_1.codeChunk.filePath, relFilePath)))
                 .limit(1);
-            // Fast path: mtime unchanged — skip without reading file
             if (existing?.lastModified === mtimeMs) {
                 return { status: 'skipped', chunks: 0 };
             }
             const t0 = Date.now();
             const code = fs.readFileSync(filePath, 'utf-8');
             const hash = IndexerService.hashContent(code);
-            // Content unchanged (mtime drifted — DB transfer, git clone, touch)
             if (existing !== undefined && existing.contentHash !== null && existing.contentHash === hash) {
                 return { status: 'skipped', chunks: 0, pendingMtimeRefresh: relFilePath };
             }
             const tAst = Date.now();
-            const { edges: rawEdges, symbols: rawSymbols, members: rawMembers = [], calls: rawCalls, ownerRanges: rawOwnerRanges = [], graphqlNames: rawGraphqlNames = [], } = analysis ?? { edges: [], symbols: [], calls: [] };
-            // astMs is near-zero — actual AST time is spent upfront in analyzeProject()
-            // Normalize edges to workspace-relative paths
+            const { edges: rawEdges, symbols: rawSymbols, members: rawMembers = [], calls: rawCalls, graphqlNames: rawGraphqlNames = [], } = analysis ?? { edges: [], symbols: [], calls: [] };
             const edges = rawEdges
                 .filter(e => e.toFile.startsWith(this.config.workspaceRoot))
                 .map(e => ({
@@ -335,7 +311,6 @@ class IndexerService {
                 fromFile: path.relative(this.config.workspaceRoot, e.fromFile),
                 toFile: path.relative(this.config.workspaceRoot, e.toFile),
             }));
-            // Normalize call edges to workspace-relative paths; keep only resolved internal calls
             const calls = rawCalls
                 .filter(c => c.calleeFile.startsWith(this.config.workspaceRoot))
                 .map(c => ({
@@ -348,23 +323,19 @@ class IndexerService {
                 line: c.line,
                 col: c.col,
             }));
-            // symbols ∪ members ∪ graphqlNames → code_symbol rows: overload sets
-            // collapse to their representative row (graphqlNames bypass the
-            // collapse), then a final dedup by (container, name, kind, line).
             const symbolRows = (0, symbol_rows_1.buildSymbolRows)(rawSymbols, rawMembers, rawGraphqlNames).map(s => ({ ...s, filePath: relFilePath }));
-            // Side-effect imports bind no name, so they stay out of the Dependencies: line.
             const promptEdges = edges.filter(e => e.depType !== 'import-side-effect');
             const astMs = Date.now() - tAst;
+            const jsx = JSX_EXTENSIONS.test(filePath);
             const chunks = await this.chunker.chunk(code, {
                 strategy: this.config.indexer.chunkStrategy,
                 isSchemaFile: SCHEMA_EXTENSIONS.test(filePath),
-                symbols: rawSymbols,
+                declarations: analysis?.declarations,
+                jsx,
             });
             const relPath = path.relative(projectRoot, filePath);
-            // Ownership ranges (decorator-inclusive, symbols ∪ members minus
-            // method_signature) are built by AstParserService — the deepest range
-            // containing a chunk's start line wins.
-            const ownerRanges = rawOwnerRanges;
+            const sourceLines = new SourceLines_1.SourceLines(code, { jsx });
+            const ownerTree = analysis?.declarations ?? DeclarationTree_1.DeclarationTree.EMPTY;
             const t2 = Date.now();
             const records = [];
             const embedBatchSize = this.config.embedding.batchSize;
@@ -380,7 +351,8 @@ class IndexerService {
                         embedding: `[${vectors[j]}]`,
                         lastModified: mtimeMs,
                         contentHash: hash,
-                        ownerPath: (0, owner_path_1.resolveOwnerPath)(piece.startLine, ownerRanges),
+                        ownerPath: (0, owner_path_1.ownerOf)(piece, ownerTree, sourceLines),
+                        endLine: piece.startLine + (piece.content.match(/\n/g)?.length ?? 0),
                     });
                 }
             }
@@ -411,9 +383,8 @@ class IndexerService {
             return { status: 'indexed', chunks: chunks.length };
         }
         catch (err) {
-            const reason = err.message;
-            console.error(`\n[indexer] Failed: ${filePath} — ${reason}`);
-            this.logger.error('IndexerService: failed to index file', { file: filePath, reason });
+            console.error(`\n[indexer] Failed: ${filePath} — ${(0, error_record_1.rootCauseMessage)(err)}`);
+            this.logger.error('IndexerService: failed to index file', { file: filePath, err });
             return { status: 'failed', chunks: 0 };
         }
     }

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

@@ -4,35 +4,14 @@ import { OpenAICompatibleEmbedder, type EmbedderDeps } from './OpenAICompatibleE
 import { serverRoot, probeInfinityHealth, listInfinityModels, type ProvisioningDeps } from './infinity-provisioning';
 export { serverRoot, probeInfinityHealth, listInfinityModels };
 export type { CommandResult } from './infinity-provisioning';
-/** Extra injection seams for `InfinityEmbedder` beyond the shared `EmbedderDeps`. */
 export interface InfinityDeps extends EmbedderDeps, ProvisioningDeps {
-    /**
-     * Path to the managed docker-compose.yml. Defaults to the file `rag-setup`
-     * writes into `~/.config/codesearch-mcp/`. A missing file (or one without an
-     * `infinity` service) means "external backend" — the Docker path is skipped.
-     */
     composePath?: string;
 }
-/**
- * Embedder for a local Infinity server. Inherits the OpenAI-style `/embeddings`
- * HTTP path, batching, retry, and reranker wiring from `OpenAICompatibleEmbedder`
- * unchanged — it adds ONLY container-readiness behavior (`ensureModelAvailable`,
- * `listModels`), delegating to the standalone `infinity-provisioning` primitive
- * because Infinity binds its model set at container startup and exposes no
- * runtime model-pull API.
- */
 export declare class InfinityEmbedder extends OpenAICompatibleEmbedder {
     private readonly base;
     private readonly composePath;
     private readonly provisioningDeps;
     constructor(config: Config, logger?: ILogger, deps?: InfinityDeps);
-    /**
-     * Index-time embed readiness (see `local-backend-provisioning`): verifies only
-     * the embedding model — indexing does not use the reranker, so a missing
-     * reranker model never blocks or restarts indexing. Whenever a recreate is
-     * needed, the full configured set is written so an already-served reranker
-     * model is never dropped. Called by `IndexCommand` before indexing.
-     */
     ensureModelAvailable(): Promise<void>;
     listModels(): Promise<string[]>;
 }

package/dist/src/services/InfinityEmbedder.js

@@ -42,14 +42,6 @@ Object.defineProperty(exports, "serverRoot", { enumerable: true, get: function (
 Object.defineProperty(exports, "probeInfinityHealth", { enumerable: true, get: function () { return infinity_provisioning_1.probeInfinityHealth; } });
 Object.defineProperty(exports, "listInfinityModels", { enumerable: true, get: function () { return infinity_provisioning_1.listInfinityModels; } });
 const path = __importStar(require("path"));
-/**
- * Embedder for a local Infinity server. Inherits the OpenAI-style `/embeddings`
- * HTTP path, batching, retry, and reranker wiring from `OpenAICompatibleEmbedder`
- * unchanged — it adds ONLY container-readiness behavior (`ensureModelAvailable`,
- * `listModels`), delegating to the standalone `infinity-provisioning` primitive
- * because Infinity binds its model set at container startup and exposes no
- * runtime model-pull API.
- */
 class InfinityEmbedder extends OpenAICompatibleEmbedder_1.OpenAICompatibleEmbedder {
     base;
     composePath;
@@ -65,13 +57,6 @@ class InfinityEmbedder extends OpenAICompatibleEmbedder_1.OpenAICompatibleEmbedd
             readinessTimeoutMs: deps.readinessTimeoutMs,
         };
     }
-    /**
-     * Index-time embed readiness (see `local-backend-provisioning`): verifies only
-     * the embedding model — indexing does not use the reranker, so a missing
-     * reranker model never blocks or restarts indexing. Whenever a recreate is
-     * needed, the full configured set is written so an already-served reranker
-     * model is never dropped. Called by `IndexCommand` before indexing.
-     */
     async ensureModelAvailable() {
         await (0, infinity_provisioning_1.ensureBackendReady)({
             baseURL: this.config.embedding.baseURL,

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

@@ -3,17 +3,19 @@ import type { ILogger } from '../interfaces/ILogger';
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
 export declare class LoggerService implements ILogger {
     private readonly logger;
-    private readonly metricsLogger;
-    constructor(logger: pino.Logger, metricsLogger?: pino.Logger | null);
+    private readonly context;
+    private constructor();
     static silent(): LoggerService;
     static fromConfig(cfg: {
         level: string;
         dir?: string;
-    }, name?: string): LoggerService;
-    private static buildFromPath;
+    }, name?: string, bindings?: Record<string, unknown>): LoggerService;
+    static toStream(level: LogLevel, stream: pino.DestinationStream, bindings?: Record<string, unknown>): LoggerService;
+    private static fileTransport;
+    private static build;
     debug(msg: string, data?: Record<string, unknown>): void;
     info(msg: string, data?: Record<string, unknown>): void;
     warn(msg: string, data?: Record<string, unknown>): void;
     error(msg: string, data?: Record<string, unknown>): void;
-    metric(msg: string, data?: Record<string, unknown>): void;
+    withContext<T>(context: Record<string, unknown>, fn: () => Promise<T>): Promise<T>;
 }

package/dist/src/services/LoggerService.js

@@ -41,21 +41,20 @@ const pino_1 = __importDefault(require("pino"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const fs = __importStar(require("fs"));
+const async_hooks_1 = require("async_hooks");
+const error_record_1 = require("../error-record");
 const DEFAULT_LOG_DIR = path.join(os.homedir(), '.config', 'codesearch-mcp', 'logs');
 class LoggerService {
     logger;
-    // Dedicated `info`-level channel for search telemetry, independent of the
-    // main logger's configured level. Null when file logging is disabled so
-    // metrics never reach stdout (owned by the MCP JSON transport).
-    metricsLogger;
-    constructor(logger, metricsLogger = null) {
+    context;
+    constructor(logger, context) {
         this.logger = logger;
-        this.metricsLogger = metricsLogger;
+        this.context = context;
     }
     static silent() {
-        return new LoggerService((0, pino_1.default)({ level: 'silent' }));
+        return LoggerService.build('debug', undefined);
     }
-    static fromConfig(cfg, name) {
+    static fromConfig(cfg, name, bindings) {
         const level = cfg.level;
         const dirVal = cfg.dir;
         const enabled = dirVal !== 'false' && dirVal !== '0';
@@ -66,45 +65,42 @@ class LoggerService {
                 ? path.join(logDir, name, `${name}.log`)
                 : path.join(logDir, 'rag.log');
         }
-        return LoggerService.buildFromPath(level, filePath);
+        return LoggerService.build(level, filePath ? LoggerService.fileTransport(level, filePath) : undefined, bindings);
     }
-    static buildFromPath(level, filePath) {
-        if (filePath)
-            fs.mkdirSync(path.dirname(filePath), { recursive: true });
-        // The transport target must accept `info` so the metrics channel can emit
-        // even when the main level is `warn`/`error`; the main logger still gates
-        // normal calls at `level`, so nothing else leaks below it.
-        const targetLevel = pino_1.default.levels.values[level] < pino_1.default.levels.values.info ? level : 'info';
-        const transport = filePath
-            ? pino_1.default.transport({
-                targets: [{
-                        target: 'pino-roll',
-                        options: {
-                            file: filePath,
-                            frequency: 'daily',
-                            dateFormat: 'yyyy-MM-dd',
-                            mkdir: true,
-                            symlink: true,
-                            limit: { count: 30 },
-                            size: '50m',
-                        },
-                        level: targetLevel,
-                    }],
-            })
-            : undefined;
-        const logger = transport
-            ? (0, pino_1.default)({ level }, transport)
+    static toStream(level, stream, bindings) {
+        return LoggerService.build(level, stream, bindings);
+    }
+    static fileTransport(level, filePath) {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        return pino_1.default.transport({
+            targets: [{
+                    target: 'pino-roll',
+                    options: {
+                        file: filePath,
+                        frequency: 'daily',
+                        dateFormat: 'yyyy-MM-dd',
+                        mkdir: true,
+                        symlink: true,
+                        limit: { count: 30 },
+                        size: '50m',
+                    },
+                    level,
+                }],
+        });
+    }
+    static build(level, destination, bindings) {
+        const context = new async_hooks_1.AsyncLocalStorage();
+        const base = destination
+            ? (0, pino_1.default)({ level, serializers: error_record_1.LOG_SERIALIZERS, mixin: () => ({ ...context.getStore() }) }, destination)
             : (0, pino_1.default)({ level: 'silent' });
-        // Child logger pinned at `info` regardless of the parent level; only used by
-        // metric(). Null when there is no file transport (default stdout must stay
-        // clean for the MCP transport).
-        const metricsLogger = transport ? logger.child({}, { level: 'info' }) : null;
-        return new LoggerService(logger, metricsLogger);
+        return new LoggerService(bindings ? base.child(bindings) : base, context);
     }
     debug(msg, data) { this.logger.debug(data ?? {}, msg); }
     info(msg, data) { this.logger.info(data ?? {}, msg); }
     warn(msg, data) { this.logger.warn(data ?? {}, msg); }
     error(msg, data) { this.logger.error(data ?? {}, msg); }
-    metric(msg, data) { this.metricsLogger?.info(data ?? {}, msg); }
+    withContext(context, fn) {
+        return this.context.run(context, fn);
+    }
 }
 exports.LoggerService = LoggerService;