codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

package/dist/src/services/IndexerService.js

@@ -36,194 +36,74 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexerService = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-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 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 SCHEMA_EXTENSIONS = /\.(prisma|graphql|gql)$/;
+const IndexStore_1 = require("../indexing/IndexStore");
+const StaleFilePruner_1 = require("../indexing/StaleFilePruner");
+const AnalysisBatcher_1 = require("../indexing/AnalysisBatcher");
+const ChunkEmbedder_1 = require("../indexing/ChunkEmbedder");
+const FileIngestor_1 = require("../indexing/FileIngestor");
+const project_notices_1 = require("../indexing/project-notices");
+const ConsoleScanReporter_1 = require("../indexing/ConsoleScanReporter");
+const EmbeddingSchemaPreparer_1 = require("../indexing/EmbeddingSchemaPreparer");
 class IndexerService {
     db;
-    embedder;
     ast;
-    chunker;
-    config;
     logger;
+    store;
+    stalePruner;
+    batcher;
+    chunkEmbedder;
+    ingestor;
+    schema;
     constructor(db, embedder, ast, chunker, config, logger = LoggerService_1.LoggerService.silent()) {
         this.db = db;
-        this.embedder = embedder;
         this.ast = ast;
-        this.chunker = chunker;
-        this.config = config;
         this.logger = logger;
+        this.store = new IndexStore_1.IndexStore(db, config);
+        this.stalePruner = new StaleFilePruner_1.StaleFilePruner(db, config);
+        this.batcher = new AnalysisBatcher_1.AnalysisBatcher(ast, config);
+        this.chunkEmbedder = new ChunkEmbedder_1.ChunkEmbedder(embedder, config);
+        this.ingestor = new FileIngestor_1.FileIngestor(this.store, this.chunkEmbedder, chunker, config, logger);
+        this.schema = new EmbeddingSchemaPreparer_1.EmbeddingSchemaPreparer(db, embedder, config, 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 = {
-            provider,
-            model,
-            dimensions: await (0, constants_1.resolveDimension)(override, model, async () => {
-                const probe = await this.embedder.embed('probe', 'document');
-                return probe.length;
-            }),
-        };
-        const meta = await this.db.readIndexMeta();
-        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;
-        }
-        await this.reconcileIndex(meta, next);
-        return next;
-    }
-    async reconcileIndex(prev, next) {
-        if (prev.dimensions !== next.dimensions) {
-            console.log(`Embedding dimension changed (${prev.dimensions} → ${next.dimensions}) — recreating code_chunk.`);
-            this.logger.info('IndexerService: dimension change, recreating code_chunk', { prev, next });
-            await this.db.recreateChunkTable(next.dimensions);
-        }
-        else if (prev.provider !== next.provider || prev.model !== next.model) {
-            console.log(`Embedding model changed (${prev.provider}/${prev.model} → ${next.provider}/${next.model}) — clearing index.`);
-            this.logger.info('IndexerService: model change, clearing code_chunk', { prev, next });
-            await this.db.query(`DELETE FROM code_chunk`);
-        }
-        await this.db.writeIndexMeta(next);
-    }
-    async countChunks() {
-        try {
-            const rows = await this.db.query(`SELECT COUNT(*)::int AS n FROM code_chunk`);
-            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;
-        }
-    }
-    async writeDepEdges(serviceName, relFilePath, edges, tx) {
-        const run = async (t) => {
-            await t.delete(db_1.codeDependency).where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(db_1.codeDependency.project, serviceName), (0, drizzle_orm_1.eq)(db_1.codeDependency.fromFile, relFilePath)));
-            if (edges.length > 0) {
-                await t.insert(db_1.codeDependency).values(edges);
-            }
-        };
-        if (tx)
-            await run(tx);
-        else
-            await this.db.transaction(run);
+        return this.schema.prepare();
     }
     async scanAndIndex(dir, serviceName, force = false, signal, preCollectedFiles, opts) {
         const startTime = Date.now();
+        const reporter = new ConsoleScanReporter_1.ConsoleScanReporter();
         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 })
-                    .where((0, drizzle_orm_1.eq)(db_1.codeChunk.serviceName, serviceName));
-                await tx.delete(db_1.codeSymbol).where((0, drizzle_orm_1.eq)(db_1.codeSymbol.project, serviceName));
-                await tx.delete(db_1.codeCall).where((0, drizzle_orm_1.eq)(db_1.codeCall.project, serviceName));
-            });
+            await this.store.resetProject(serviceName);
         }
         const files = preCollectedFiles ?? (0, file_utils_1.collectFiles)(dir, (0, file_utils_1.loadIgnore)(dir), dir);
         this.logger.debug('IndexerService: scanAndIndex files collected', { serviceName, count: files.length, force });
-        const collectedRelPaths = new Set(files.map(f => path.relative(this.config.workspaceRoot, f)));
-        const knownFiles = await this.db.listKnownFiles(serviceName);
-        const staleFiles = knownFiles.filter(f => !collectedRelPaths.has(f));
-        if (staleFiles.length > 0) {
-            await this.db.deleteFiles(serviceName, staleFiles);
-            for (const f of staleFiles) {
-                console.log(`  Removed stale: ${path.basename(f)}`);
-            }
-        }
-        const bar = new cli_progress_1.SingleBar({
-            format: `{serviceName} {bar} {percentage}% | {value}/{total} | {duration_formatted} elapsed | ~{eta_formatted} left | {filename}`,
-            barCompleteChar: '█',
-            barIncompleteChar: '░',
-            hideCursor: true,
-            clearOnComplete: false,
-        }, cli_progress_1.Presets.shades_grey);
-        const warnings = [];
-        console.log(`\nIndexing ${serviceName}: ${files.length} files`);
-        const meta = (0, file_utils_1.readRagMeta)(dir);
-        if (meta === 'invalid') {
-            const msg = `.ragmeta.json found but invalid JSON`;
-            console.log(`  ⚠ ${msg}`);
-            warnings.push(msg);
-        }
-        else if (meta !== 'missing') {
-            const parts = [meta.description, meta.stack && `[${meta.stack}]`].filter(Boolean).join(' ');
-            console.log(`  ✓ .ragmeta.json: ${parts || '(no fields)'}`);
-        }
-        else {
-            const msg = `No .ragmeta.json — add {"description":"...","stack":"...","notes":"..."} so list_projects can describe this project`;
-            console.log(`  ⚠ ${msg}`);
-            warnings.push(msg);
+        const staleFiles = await this.stalePruner.prune(serviceName, files);
+        for (const f of staleFiles) {
+            reporter.staleRemoved(f);
         }
-        if (!fs.existsSync(path.join(dir, '.ragignore'))) {
-            const msg = `No .ragignore — create one to exclude generated/codegen files (e.g. src/gql/graphql.ts, **/__snapshots__/**)`;
-            console.log(`  ⚠ ${msg}`);
-            warnings.push(msg);
-        }
-        if (files.length > this.config.indexer.astBatchSize) {
-            console.log(`  ⚠ Large project (${files.length} files) — AST analysis uses batches of ${this.config.indexer.astBatchSize}; cross-batch dependency edges may be incomplete`);
-        }
-        bar.start(files.length, 0, { serviceName, filename: '' });
+        const notices = (0, project_notices_1.collectProjectNotices)(dir, files.length, this.batcher.batchSize);
+        reporter.begin(serviceName, files.length, notices);
+        const warnings = notices.filter(n => n.warning).map(n => n.message);
         const stats = {
             serviceName, indexed: 0, skipped: 0, failed: 0, chunks: 0, elapsedSec: 0, warnings,
         };
         const mtimeRefreshBatch = [];
-        const isLargeProject = files.length > this.config.indexer.astBatchSize;
-        for (let batchStart = 0; batchStart < files.length; batchStart += this.config.indexer.astBatchSize) {
-            if (signal?.aborted)
-                break;
-            const batch = files.slice(batchStart, batchStart + this.config.indexer.astBatchSize);
-            const analysisMap = await this.ast.analyzeProject(batch, serviceName, dir, {
-                skipDependencyResolution: isLargeProject,
-                rootTsConfigPath: opts?.rootTsConfigPath,
-            });
+        for await (const { batch, analysisMap } of this.batcher.batches(files, serviceName, dir, signal, opts?.rootTsConfigPath)) {
             for (const filePath of batch) {
                 if (signal?.aborted) {
-                    bar.stop();
-                    console.log(`\n  Interrupted — ${serviceName}`);
+                    reporter.interrupted(serviceName);
                     stats.elapsedSec = Math.round((Date.now() - startTime) / 100) / 10;
                     return stats;
                 }
-                bar.update({ filename: path.relative(dir, filePath) });
+                reporter.file(path.relative(dir, filePath));
                 const mtimeMs = fs.statSync(filePath).mtimeMs;
                 const analysis = analysisMap.get(filePath);
                 if (analysis === undefined && /\.(ts|tsx|js|jsx)$/.test(filePath) && !/\.d\.ts$/.test(filePath)) {
                     this.logger.warn('IndexerService: no pre-computed analysis for TS file', { file: filePath });
                 }
-                const result = await this.ingestFile(filePath, serviceName, mtimeMs, dir, analysis, meta);
+                const result = await this.ingestor.ingestFile(filePath, serviceName, mtimeMs, dir, analysis);
                 if (result.pendingMtimeRefresh) {
                     mtimeRefreshBatch.push({ relFilePath: result.pendingMtimeRefresh, mtimeMs });
                 }
@@ -234,23 +114,16 @@ class IndexerService {
                 else
                     stats.failed++;
                 stats.chunks += result.chunks;
-                bar.increment();
+                reporter.advance();
             }
         }
-        bar.stop();
-        process.stdout.write('\x1B[J');
+        reporter.end();
         if (mtimeRefreshBatch.length > 0) {
             try {
-                await this.db.query(`UPDATE code_chunk SET "lastModified" = t.mtime
-           FROM unnest($1::text[], $2::float8[]) AS t(fp, mtime)
-           WHERE "serviceName" = $3 AND "filePath" = t.fp`, [
-                    mtimeRefreshBatch.map(r => r.relFilePath),
-                    mtimeRefreshBatch.map(r => r.mtimeMs),
-                    serviceName,
-                ]);
+                await this.store.refreshMtimes(serviceName, mtimeRefreshBatch);
             }
             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 +138,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,126 +163,11 @@ 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);
             }
         }
         return { removed, failed };
     }
-    static hashContent(content) {
-        return (0, crypto_1.createHash)('sha256').update(content).digest('hex');
-    }
-    async ingestFile(filePath, serviceName, mtimeMs, projectRoot, analysis, meta) {
-        try {
-            const relFilePath = path.relative(this.config.workspaceRoot, filePath);
-            const [existing] = await this.db.orm
-                .select({ id: db_1.codeChunk.id, lastModified: db_1.codeChunk.lastModified, contentHash: db_1.codeChunk.contentHash })
-                .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
-                .filter(e => e.toFile.startsWith(this.config.workspaceRoot))
-                .map(e => ({
-                ...e,
-                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 => ({
-                project: serviceName,
-                fromFile: relFilePath,
-                fromSymbol: c.fromSymbol,
-                calleeName: c.calleeName,
-                calleeFile: path.relative(this.config.workspaceRoot, c.calleeFile),
-                calleeSymbol: c.calleeSymbol,
-                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 chunks = await this.chunker.chunk(code, {
-                strategy: this.config.indexer.chunkStrategy,
-                isSchemaFile: SCHEMA_EXTENSIONS.test(filePath),
-                symbols: rawSymbols,
-            });
-            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 t2 = Date.now();
-            const records = [];
-            const embedBatchSize = this.config.embedding.batchSize;
-            for (let i = 0; i < chunks.length; i += embedBatchSize) {
-                const batch = chunks.slice(i, i + embedBatchSize);
-                const prompts = batch.map(piece => (0, enriched_prompt_1.getEnrichedPrompt)(piece, relPath, serviceName, promptEdges, rawSymbols));
-                const vectors = await this.embedder.embedBatch(prompts, 'document');
-                for (let j = 0; j < batch.length; j++) {
-                    const piece = batch[j];
-                    records.push({
-                        serviceName, filePath: relFilePath, startLine: piece.startLine,
-                        content: piece.content,
-                        embedding: `[${vectors[j]}]`,
-                        lastModified: mtimeMs,
-                        contentHash: hash,
-                        ownerPath: (0, owner_path_1.resolveOwnerPath)(piece.startLine, ownerRanges),
-                    });
-                }
-            }
-            const embedMs = Date.now() - t2;
-            const t3 = Date.now();
-            await this.db.transaction(async (tx) => {
-                await tx.delete(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)));
-                for (let i = 0; i < records.length; i += this.config.indexer.batchSize) {
-                    await tx.insert(db_1.codeChunk).values(records.slice(i, i + this.config.indexer.batchSize));
-                }
-                await this.writeDepEdges(serviceName, relFilePath, edges, tx);
-                await tx.delete(db_1.codeSymbol).where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(db_1.codeSymbol.project, serviceName), (0, drizzle_orm_1.eq)(db_1.codeSymbol.filePath, relFilePath)));
-                if (symbolRows.length > 0) {
-                    await tx.insert(db_1.codeSymbol).values(symbolRows);
-                }
-                await tx.delete(db_1.codeCall).where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(db_1.codeCall.project, serviceName), (0, drizzle_orm_1.eq)(db_1.codeCall.fromFile, relFilePath)));
-                if (calls.length > 0) {
-                    await tx.insert(db_1.codeCall).values(calls);
-                }
-            });
-            const dbMs = Date.now() - t3;
-            if (chunks.length > 0) {
-                this.logger.debug('IndexerService: file indexed', {
-                    file: relFilePath, chunks: chunks.length,
-                    astMs, embedMs, dbMs, totalMs: Date.now() - t0,
-                });
-            }
-            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 });
-            return { status: 'failed', chunks: 0 };
-        }
-    }
 }
 exports.IndexerService = IndexerService;

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;

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

@@ -0,0 +1,18 @@
+import type { IDatabase } from '../interfaces/IDatabase';
+import type { IIndexIdentityGuard } from '../interfaces/IIndexIdentityGuard';
+import type { ILogger } from '../interfaces/ILogger';
+import type { IMcpReadiness, ReadinessCheck } from '../interfaces/IMcpReadiness';
+export declare const CHECK_DEADLINE_MS: number;
+export declare class McpReadiness implements IMcpReadiness {
+    private db;
+    private identity;
+    private logger;
+    private isReady;
+    private lastCause;
+    private inFlight;
+    constructor(db: Pick<IDatabase, 'initDb' | 'probe'>, identity: IIndexIdentityGuard, logger: ILogger);
+    get ready(): boolean;
+    start(): Promise<ReadinessCheck>;
+    ensureReady(): Promise<ReadinessCheck>;
+    private recheck;
+}