codesearch-mcp 0.3.0-alpha → 0.4.0-alpha

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

@@ -1,23 +1,22 @@
-import type { NodePgDatabase, NodePgTransaction } from 'drizzle-orm/node-postgres';
-import type { ExtractTablesWithRelations } from 'drizzle-orm/relations';
 import type { Config } from '../config';
-import type { IDatabase, IndexMeta } from '../interfaces/IDatabase';
-import * as schema from '../db/schema';
-type Schema = typeof schema;
-export type DrizzleDb = NodePgDatabase<Schema>;
-export type DrizzleTx = NodePgTransaction<Schema, ExtractTablesWithRelations<Schema>>;
+import type { IDatabase, IndexMeta, InitDbOptions } from '../interfaces/IDatabase';
+import type { ILogger } from '../interfaces/ILogger';
+import type { DrizzleDb, DrizzleTx } from '../db';
 export declare class DatabaseService implements IDatabase {
     private config;
+    private logger;
     private pool;
     private _db;
-    constructor(config: Config);
+    private probeTimeoutMs;
+    constructor(config: Config, logger?: ILogger);
     get orm(): DrizzleDb;
     query<T = any>(sql: string, params?: any[]): Promise<T>;
     queryWithLocalSettings<T = any>(settings: Record<string, string | number>, sql: string, params?: any[]): Promise<T>;
     pgvectorVersion(): Promise<string | null>;
     transaction<T>(fn: (tx: DrizzleTx) => Promise<T>): Promise<T>;
     destroy(): Promise<void>;
-    initDb(): Promise<void>;
+    initDb(options?: InitDbOptions): Promise<void>;
+    probe(): Promise<void>;
     initDbWithSchema(): Promise<void>;
     ensureChunkTable(dimensions: number): Promise<void>;
     recreateChunkTable(dimensions: number): Promise<void>;
@@ -31,4 +30,3 @@ export declare class DatabaseService implements IDatabase {
     private assertMinPostgresVersion;
     private ensureDatabaseExists;
 }
-export {};

package/dist/src/services/DatabaseService.js

@@ -34,20 +34,26 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DatabaseService = void 0;
+const async_hooks_1 = require("async_hooks");
 const node_postgres_1 = require("drizzle-orm/node-postgres");
 const pg_1 = require("pg");
 const drizzle_orm_1 = require("drizzle-orm");
+const LoggerService_1 = require("./LoggerService");
 const schema = __importStar(require("../db/schema"));
 const db_1 = require("../db");
+const schema_steps_1 = require("../db/schema-steps");
 const MIN_PG_VERSION_NUM = 150000;
 const SETTING_NAME = /^[a-z_]+(\.[a-z_]+)*$/;
 const SETTING_VALUE = /^[A-Za-z0-9_]+$/;
 class DatabaseService {
     config;
+    logger;
     pool;
     _db;
-    constructor(config) {
+    probeTimeoutMs;
+    constructor(config, logger = LoggerService_1.LoggerService.silent()) {
         this.config = config;
+        this.logger = logger;
     }
     get orm() { return this._db; }
     async query(sql, params) {
@@ -97,96 +103,31 @@ class DatabaseService {
             return Promise.resolve();
         return this.pool.end();
     }
-    async initDb() {
+    async initDb(options = {}) {
         const { host, port, username, password, database } = this.config.db;
-        this.pool = new pg_1.Pool({ host, port, user: username, password, database });
+        const { connectionTimeoutMs } = options;
+        this.probeTimeoutMs = connectionTimeoutMs;
+        this.pool = new pg_1.Pool({
+            host, port, user: username, password, database,
+            ...(connectionTimeoutMs !== undefined ? { connectionTimeoutMillis: connectionTimeoutMs } : {}),
+        });
+        this.pool.on('error', async_hooks_1.AsyncResource.bind((err) => {
+            this.logger.warn('DatabaseService: idle client error', { err });
+        }));
         this._db = (0, node_postgres_1.drizzle)(this.pool, { schema });
         await this.pool.query('SELECT 1');
     }
+    async probe() {
+        if (!this.pool)
+            throw new Error('DatabaseService: probe() called before initDb()');
+        const query = { text: 'SELECT 1', query_timeout: this.probeTimeoutMs };
+        await this.pool.query(query);
+    }
     async initDbWithSchema() {
         await this.ensureDatabaseExists();
         await this.initDb();
         await this.assertMinPostgresVersion();
-        await this.ensureChunkTable(1024);
-        await this.query(`
-      CREATE TABLE IF NOT EXISTS index_meta (
-        id          BOOLEAN PRIMARY KEY DEFAULT true,
-        provider    TEXT NOT NULL,
-        model       TEXT NOT NULL,
-        dimensions  INT  NOT NULL,
-        "indexedAt" TIMESTAMPTZ NOT NULL DEFAULT now()
-      )
-    `);
-        const [{ existsDep }] = await this.query(`
-      SELECT EXISTS (
-        SELECT 1 FROM information_schema.tables
-        WHERE table_schema = 'public' AND table_name = 'code_dependency'
-      ) AS "existsDep"
-    `);
-        if (!existsDep) {
-            await this.query(`
-        CREATE TABLE code_dependency (
-          id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-          project      TEXT NOT NULL,
-          "fromFile"   TEXT NOT NULL,
-          "fromSymbol" TEXT,
-          "toFile"     TEXT NOT NULL,
-          "toSymbol"   TEXT,
-          "depType"    TEXT NOT NULL
-        )
-      `);
-        }
-        await this.query(`CREATE INDEX IF NOT EXISTS idx_dep_project_from ON code_dependency (project, "fromFile")`);
-        await this.query(`CREATE INDEX IF NOT EXISTS idx_dep_project_to   ON code_dependency (project, "toFile")`);
-        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`);
-        const [{ existsSym }] = await this.query(`
-      SELECT EXISTS (
-        SELECT 1 FROM information_schema.tables
-        WHERE table_schema = 'public' AND table_name = 'code_symbol'
-      ) AS "existsSym"
-    `);
-        if (!existsSym) {
-            await this.query(`
-        CREATE TABLE code_symbol (
-          id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-          project    TEXT NOT NULL,
-          "filePath" TEXT NOT NULL,
-          name       TEXT NOT NULL,
-          kind       TEXT NOT NULL,
-          signature  TEXT,
-          line       INT,
-          col        INT
-        )
-      `);
-        }
-        await this.query(`CREATE INDEX IF NOT EXISTS idx_symbol_name   ON code_symbol (name, project)`);
-        await this.query(`CREATE INDEX IF NOT EXISTS idx_symbol_file   ON code_symbol (project, "filePath")`);
-        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`);
-        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');
-        });
-        await this.query(`
-      CREATE TABLE IF NOT EXISTS code_call (
-        id             UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-        project        TEXT NOT NULL,
-        "fromFile"     TEXT NOT NULL,
-        "fromSymbol"   TEXT,
-        "calleeName"   TEXT NOT NULL,
-        "calleeFile"   TEXT NOT NULL,
-        "calleeSymbol" TEXT,
-        line           INT,
-        col            INT
-      )
-    `);
-        await this.query(`CREATE INDEX IF NOT EXISTS idx_call_callee      ON code_call (project, "calleeName")`);
-        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")`);
+        await (0, schema_steps_1.runSchemaSteps)(this);
     }
     async ensureChunkTable(dimensions) {
         const dim = this.assertDim(dimensions);
@@ -207,7 +148,7 @@ class DatabaseService {
         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_embedding ON code_chunk USING hnsw (embedding vector_cosine_ops) WITH (m = 32, ef_construction = 200)`);
         await this.query(`CREATE INDEX IF NOT EXISTS idx_code_chunk_service_file ON code_chunk ("serviceName", "filePath")`);
     }
     async recreateChunkTable(dimensions) {
@@ -221,8 +162,10 @@ class DatabaseService {
             const row = rows[0];
             return row ? { provider: row.provider, model: row.model, dimensions: Number(row.dimensions) } : null;
         }
-        catch {
-            return null;
+        catch (err) {
+            if (err?.code === '42P01')
+                return null;
+            throw err;
         }
     }
     async writeIndexMeta(meta) {

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

@@ -2,10 +2,9 @@ import type { Config } from '../config';
 import type { IEmbedder } from '../interfaces/IEmbedder';
 import type { IAstParser } from '../interfaces/IAstParser';
 import type { IChunker } from '../interfaces/IChunker';
-import type { IDatabase } from '../interfaces/IDatabase';
+import type { IDatabase, IndexMeta } from '../interfaces/IDatabase';
 import type { DiscoveredProject } from '../interfaces/IProjectDiscovery';
 import type { ILogger } from '../interfaces/ILogger';
-import type { IndexMeta } from '../interfaces/IDatabase';
 export interface IndexStats {
     serviceName: string;
     indexed: number;
@@ -17,16 +16,16 @@ export interface IndexStats {
 }
 export declare class IndexerService {
     private db;
-    private embedder;
     private ast;
-    private chunker;
-    private config;
     private logger;
+    private readonly store;
+    private readonly stalePruner;
+    private readonly batcher;
+    private readonly chunkEmbedder;
+    private readonly ingestor;
+    private readonly schema;
     constructor(db: IDatabase, embedder: IEmbedder, ast: IAstParser, chunker: IChunker, config: Config, logger?: ILogger);
     prepareEmbeddingSchema(): Promise<IndexMeta>;
-    private reconcileIndex;
-    private countChunks;
-    private writeDepEdges;
     scanAndIndex(dir: string, serviceName: string, force?: boolean, signal?: AbortSignal, preCollectedFiles?: string[], opts?: {
         rootTsConfigPath?: string;
     }): Promise<IndexStats>;
@@ -35,6 +34,4 @@ export declare class IndexerService {
         removed: string[];
         failed: string[];
     }>;
-    private static hashContent;
-    private ingestFile;
 }

package/dist/src/services/IndexerService.js

@@ -36,180 +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 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)$/;
+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);
     }
     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) {
-                await this.db.recreateChunkTable(next.dimensions);
-                await this.db.writeIndexMeta(next);
-                this.logger.debug('IndexerService: prepared fresh index', { ...next });
-                return next;
-            }
-            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) {
-            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) {
-            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 });
                 }
@@ -220,20 +114,13 @@ 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', { err });
@@ -282,111 +169,5 @@ class IndexerService {
         }
         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);
-            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);
-            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, graphqlNames: rawGraphqlNames = [], } = analysis ?? { edges: [], symbols: [], calls: [] };
-            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),
-            }));
-            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,
-            }));
-            const symbolRows = (0, symbol_rows_1.buildSymbolRows)(rawSymbols, rawMembers, rawGraphqlNames).map(s => ({ ...s, filePath: relFilePath }));
-            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),
-                declarations: analysis?.declarations,
-                jsx,
-            });
-            const relPath = path.relative(projectRoot, filePath);
-            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;
-            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.ownerOf)(piece, ownerTree, sourceLines),
-                        endLine: piece.startLine + (piece.content.match(/\n/g)?.length ?? 0),
-                    });
-                }
-            }
-            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) {
-            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 };
-        }
-    }
 }
 exports.IndexerService = IndexerService;

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;
+}