codesearch-mcp 0.0.15-alpha → 0.0.17-alpha

package/dist/src/services/DatabaseService.js

@@ -1,105 +1,164 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DatabaseService = void 0;
-const typeorm_1 = require("typeorm");
+const node_postgres_1 = require("drizzle-orm/node-postgres");
 const pg_1 = require("pg");
-const db_1 = require("../db");
+const schema = __importStar(require("../db/schema"));
 class DatabaseService {
     config;
-    dataSource;
+    pool;
+    _db;
     constructor(config) {
         this.config = config;
-        this.dataSource = new typeorm_1.DataSource({
-            type: 'postgres',
-            ...config.db,
-            entities: [db_1.CodeChunk, db_1.CodeDependency, db_1.CodeSymbol],
-            synchronize: false,
-        });
     }
-    query(sql, params) {
-        return this.dataSource.query(sql, params);
+    get orm() { return this._db; }
+    async query(sql, params) {
+        const result = await this.pool.query(sql, params);
+        return result.rows;
     }
     transaction(fn) {
-        return this.dataSource.transaction(fn);
-    }
-    getRepository(entity) {
-        return this.dataSource.getRepository(entity);
+        return this._db.transaction(fn);
     }
     destroy() {
-        if (!this.dataSource.isInitialized)
+        if (!this.pool)
             return Promise.resolve();
-        return this.dataSource.destroy();
+        return this.pool.end();
     }
     async initDb() {
-        await this.dataSource.initialize();
+        const { host, port, username, password, database } = this.config.db;
+        this.pool = new pg_1.Pool({ host, port, user: username, password, database });
+        this._db = (0, node_postgres_1.drizzle)(this.pool, { schema });
+        await this.pool.query('SELECT 1');
     }
     async initDbWithSchema() {
         await this.ensureDatabaseExists();
-        await this.dataSource.initialize();
+        await this.initDb();
         // code_chunk table
-        const [{ exists }] = await this.dataSource.query(`
+        const [{ exists }] = await this.query(`
       SELECT EXISTS (
         SELECT 1 FROM information_schema.tables
         WHERE table_schema = 'public' AND table_name = 'code_chunk'
       )
     `);
         if (!exists) {
-            await this.dataSource.synchronize();
-            await this.dataSource.query(`
+            await this.query(`
+        CREATE TABLE code_chunk (
+          id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+          "serviceName" TEXT NOT NULL,
+          "filePath"    TEXT NOT NULL,
+          "startLine"   INT,
+          content       TEXT NOT NULL,
+          embedding     vector(1024) NOT NULL,
+          "lastModified" DOUBLE PRECISION,
+          "contentHash"  VARCHAR(64)
+        )
+      `);
+            await this.query(`
         CREATE INDEX idx_code_chunk_embedding
         ON code_chunk USING hnsw (embedding vector_cosine_ops)
       `);
         }
-        await this.dataSource.query(`CREATE INDEX IF NOT EXISTS idx_code_chunk_service_file ON code_chunk ("serviceName", "filePath")`);
+        await this.query(`CREATE INDEX IF NOT EXISTS idx_code_chunk_service_file ON code_chunk ("serviceName", "filePath")`);
+        await this.query(`ALTER TABLE code_chunk ADD COLUMN IF NOT EXISTS "contentHash" varchar(64) NULL`);
         // code_dependency table
-        const [{ existsDep }] = await this.dataSource.query(`
+        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.dataSource.query(`
+            await this.query(`
         CREATE TABLE code_dependency (
-          id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-          project     TEXT NOT NULL,
-          "fromFile"  TEXT NOT NULL,
+          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
+          "toFile"     TEXT NOT NULL,
+          "toSymbol"   TEXT,
+          "depType"    TEXT NOT NULL
         )
       `);
         }
-        await this.dataSource.query(`CREATE INDEX IF NOT EXISTS idx_dep_project_from ON code_dependency (project, "fromFile")`);
-        await this.dataSource.query(`CREATE INDEX IF NOT EXISTS idx_dep_project_to   ON code_dependency (project, "toFile")`);
-        await this.dataSource.query(`DROP INDEX IF EXISTS idx_dep_from`);
-        await this.dataSource.query(`DROP INDEX IF EXISTS idx_dep_to`);
-        await this.dataSource.query(`DROP INDEX IF EXISTS idx_dep_project`);
+        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`);
         // code_symbol table
-        const [{ existsSym }] = await this.dataSource.query(`
+        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.dataSource.query(`
+            await this.query(`
         CREATE TABLE code_symbol (
-          id        UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-          project   TEXT NOT NULL,
+          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
+          name       TEXT NOT NULL,
+          kind       TEXT NOT NULL,
+          signature  TEXT,
+          line       INT,
+          col        INT
         )
       `);
         }
-        await this.dataSource.query(`CREATE INDEX IF NOT EXISTS idx_symbol_name    ON code_symbol (name, project)`);
-        await this.dataSource.query(`CREATE INDEX IF NOT EXISTS idx_symbol_file    ON code_symbol (project, "filePath")`);
-        await this.dataSource.query(`CREATE UNIQUE INDEX IF NOT EXISTS idx_symbol_unique ON code_symbol (project, "filePath", name, kind)`);
+        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(`CREATE UNIQUE INDEX IF NOT EXISTS idx_symbol_unique ON code_symbol (project, "filePath", name, kind)`);
+        // code_call table
+        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")`);
     }
     async ensureDatabaseExists() {
         const { host, port, username, password, database } = this.config.db;

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

@@ -27,6 +27,12 @@ export declare class IndexerService {
         skipped: number;
         failed: number;
     }>;
+    backfillCalls(signal?: AbortSignal): Promise<{
+        total: number;
+        processed: number;
+        skipped: number;
+        failed: number;
+    }>;
     discoverProjects(rootDir: string): {
         name: string;
         path: string;
@@ -34,6 +40,9 @@ export declare class IndexerService {
     private writeDepEdges;
     scanAndIndex(dir: string, serviceName: string, force?: boolean, signal?: AbortSignal, preCollectedFiles?: string[]): Promise<IndexStats>;
     private getSplitter;
+    private static inferRole;
+    private getEnrichedPrompt;
     private embedText;
+    private static hashContent;
     private ingestFile;
 }

package/dist/src/services/IndexerService.js

@@ -36,8 +36,10 @@ 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 textsplitters_1 = require("@langchain/textsplitters");
 const cli_progress_1 = require("cli-progress");
+const drizzle_orm_1 = require("drizzle-orm");
 const db_1 = require("../db");
 const file_utils_1 = require("../file-utils");
 const LoggerService_1 = require("./LoggerService");
@@ -67,7 +69,9 @@ class IndexerService {
         });
     }
     async backfillSymbols(signal) {
+        const t0 = Date.now();
         const rows = await this.db.query(`SELECT DISTINCT "serviceName", "filePath" FROM code_chunk ORDER BY "serviceName", "filePath"`);
+        this.logger.debug('IndexerService: backfillSymbols start', { total: rows.length });
         let processed = 0, skipped = 0, failed = 0;
         for (const { serviceName, filePath } of rows) {
             if (signal?.aborted)
@@ -80,11 +84,11 @@ class IndexerService {
             }
             try {
                 const { symbols: rawSymbols } = await this.ast.analyzeFile(absPath, serviceName, projectRoot);
-                const symbols = [...new Map(rawSymbols.map(s => ({ ...s, filePath })).map(s => [`${s.name}:${s.kind}`, s])).values()];
-                await this.db.transaction(async (manager) => {
-                    await manager.delete(db_1.CodeSymbol, { project: serviceName, filePath });
+                const symbols = [...new Map(rawSymbols.map(s => ({ ...s, filePath })).map(s => [`${s.name}:${s.kind}`, s])).values()].map(({ project, filePath: fp, name, kind, signature, line, col }) => ({ project, filePath: fp, name, kind, signature, line, col }));
+                await this.db.transaction(async (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, filePath)));
                     if (symbols.length > 0) {
-                        await manager.createQueryBuilder().insert().into(db_1.CodeSymbol).values(symbols).execute();
+                        await tx.insert(db_1.codeSymbol).values(symbols);
                     }
                 });
                 processed++;
@@ -101,6 +105,58 @@ class IndexerService {
                 process.stdout.isTTY ? process.stdout.write(msg + '\r') : console.log(msg);
             }
         }
+        this.logger.debug('IndexerService: backfillSymbols done', { total: rows.length, processed, skipped, failed, ms: Date.now() - t0 });
+        return { total: rows.length, processed, skipped, failed };
+    }
+    async backfillCalls(signal) {
+        const t0 = Date.now();
+        const rows = await this.db.query(`SELECT DISTINCT "serviceName", "filePath" FROM code_chunk ORDER BY "serviceName", "filePath"`);
+        this.logger.debug('IndexerService: backfillCalls start', { total: rows.length });
+        let processed = 0, skipped = 0, failed = 0;
+        for (const { serviceName, filePath } of rows) {
+            if (signal?.aborted)
+                break;
+            const absPath = path.join(this.config.workspaceRoot, filePath);
+            const projectRoot = path.join(this.config.workspaceRoot, serviceName);
+            if (!fs.existsSync(absPath)) {
+                skipped++;
+                continue;
+            }
+            try {
+                const { calls: rawCalls } = await this.ast.analyzeFile(absPath, serviceName, projectRoot);
+                const calls = rawCalls
+                    .filter(c => c.calleeFile.startsWith(this.config.workspaceRoot))
+                    .map(c => ({
+                    project: serviceName,
+                    fromFile: filePath,
+                    fromSymbol: c.fromSymbol,
+                    calleeName: c.calleeName,
+                    calleeFile: path.relative(this.config.workspaceRoot, c.calleeFile),
+                    calleeSymbol: c.calleeSymbol,
+                    line: c.line,
+                    col: c.col,
+                }));
+                await this.db.transaction(async (tx) => {
+                    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, filePath)));
+                    if (calls.length > 0) {
+                        await tx.insert(db_1.codeCall).values(calls);
+                    }
+                });
+                processed++;
+            }
+            catch (err) {
+                const reason = err.message;
+                console.error(`  Failed: ${filePath} — ${reason}`);
+                this.logger.error('IndexerService: call backfill failed', { file: filePath, reason });
+                failed++;
+            }
+            const count = processed + failed;
+            if (count > 0 && count % 50 === 0) {
+                const msg = `  ${count}/${rows.length} files...`;
+                process.stdout.isTTY ? process.stdout.write(msg + '\r') : console.log(msg);
+            }
+        }
+        this.logger.debug('IndexerService: backfillCalls done', { total: rows.length, processed, skipped, failed, ms: Date.now() - t0 });
         return { total: rows.length, processed, skipped, failed };
     }
     discoverProjects(rootDir) {
@@ -109,30 +165,31 @@ class IndexerService {
             .map(d => ({ name: d.name, path: path.join(rootDir, d.name) }))
             .filter(p => fs.existsSync(path.join(p.path, 'package.json')));
     }
-    async writeDepEdges(serviceName, relFilePath, edges, manager) {
-        const run = async (mgr) => {
-            await mgr.delete(db_1.CodeDependency, { project: serviceName, fromFile: relFilePath });
+    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 mgr.createQueryBuilder().insert().into(db_1.CodeDependency).values(edges).execute();
+                await t.insert(db_1.codeDependency).values(edges);
             }
         };
-        if (manager)
-            await run(manager);
+        if (tx)
+            await run(tx);
         else
             await this.db.transaction(run);
     }
     async scanAndIndex(dir, serviceName, force = false, signal, preCollectedFiles) {
         const startTime = Date.now();
-        const repo = this.db.getRepository(db_1.CodeChunk);
+        this.logger.debug('IndexerService: scanAndIndex start', { serviceName, dir, force });
         if (force) {
-            await this.db.query(`UPDATE code_chunk SET "lastModified" = NULL WHERE "serviceName" = $1`, [serviceName]);
+            await this.db.query(`UPDATE code_chunk SET "lastModified" = NULL, "contentHash" = NULL WHERE "serviceName" = $1`, [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 dbPaths = await this.db.query(`SELECT DISTINCT "filePath" FROM code_chunk WHERE "serviceName" = $1`, [serviceName]);
         for (const { filePath } of dbPaths) {
             if (!collectedRelPaths.has(filePath)) {
-                await repo.delete({ serviceName, filePath });
+                await this.db.transaction(tx => 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, filePath))));
                 await this.db.query(`DELETE FROM code_dependency WHERE project = $1 AND "fromFile" = $2`, [serviceName, filePath]);
                 await this.db.query(`DELETE FROM code_dependency WHERE project = $1 AND "toFile" = $2`, [serviceName, filePath]);
                 console.log(`  Removed stale: ${path.basename(filePath)}`);
@@ -167,54 +224,152 @@ class IndexerService {
             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 stats = {
             serviceName, indexed: 0, skipped: 0, failed: 0, chunks: 0, elapsedSec: 0, warnings,
         };
-        for (const filePath of files) {
-            if (signal?.aborted) {
-                bar.stop();
-                console.log(`\n  Interrupted — ${serviceName}`);
-                stats.elapsedSec = Math.round((Date.now() - startTime) / 100) / 10;
-                return stats;
+        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 });
+            for (const filePath of batch) {
+                if (signal?.aborted) {
+                    bar.stop();
+                    console.log(`\n  Interrupted — ${serviceName}`);
+                    stats.elapsedSec = Math.round((Date.now() - startTime) / 100) / 10;
+                    return stats;
+                }
+                bar.update({ filename: 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);
+                if (result.pendingMtimeRefresh) {
+                    mtimeRefreshBatch.push({ relFilePath: result.pendingMtimeRefresh, mtimeMs });
+                }
+                if (result.status === 'indexed')
+                    stats.indexed++;
+                else if (result.status === 'skipped')
+                    stats.skipped++;
+                else
+                    stats.failed++;
+                stats.chunks += result.chunks;
+                bar.increment();
             }
-            bar.update({ filename: path.relative(dir, filePath) });
-            const mtimeMs = fs.statSync(filePath).mtimeMs;
-            const result = await this.ingestFile(filePath, serviceName, mtimeMs, dir);
-            if (result.status === 'indexed')
-                stats.indexed++;
-            else if (result.status === 'skipped')
-                stats.skipped++;
-            else
-                stats.failed++;
-            stats.chunks += result.chunks;
-            bar.increment();
         }
         bar.stop();
         process.stdout.write('\x1B[J');
+        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,
+                ]);
+            }
+            catch (err) {
+                this.logger.error('IndexerService: mtime refresh batch failed', { reason: err.message });
+            }
+        }
+        this.ast.clearCache(dir);
         stats.elapsedSec = Math.round((Date.now() - startTime) / 100) / 10;
+        this.logger.debug('IndexerService: project indexed', {
+            project: serviceName,
+            indexed: stats.indexed,
+            skipped: stats.skipped,
+            failed: stats.failed,
+            chunks: stats.chunks,
+            elapsedSec: stats.elapsedSec,
+        });
         return stats;
     }
     getSplitter(filePath) {
         return SCHEMA_EXTENSIONS.test(filePath) ? this.schemaSplitter : this.jsSplitter;
     }
+    static inferRole(relPath) {
+        const p = relPath.toLowerCase();
+        if (p.includes('/services/') || p.endsWith('.service.ts'))
+            return 'Service';
+        if (p.includes('/controllers/') || p.endsWith('.controller.ts'))
+            return 'Controller';
+        if (p.includes('/entities/') || p.endsWith('.entity.ts'))
+            return 'Entity';
+        if (p.includes('/guards/') || p.endsWith('.guard.ts'))
+            return 'Guard';
+        if (p.includes('/commands/'))
+            return 'Command';
+        if (p.includes('/interfaces/'))
+            return 'Interface';
+        if (p.includes('/middleware/'))
+            return 'Middleware';
+        if (p.includes('/interceptors/'))
+            return 'Interceptor';
+        if (p.endsWith('.test.ts') || p.endsWith('.spec.ts') || p.includes('/tests/'))
+            return 'Test';
+        if (p.includes('/utils/') || p.includes('/helpers/') || p.endsWith('-utils.ts'))
+            return 'Utility';
+        return null;
+    }
+    getEnrichedPrompt(chunk, relPath, serviceName, _meta, edges, symbols) {
+        const chunkStart = (chunk.metadata?.loc?.lines?.from ?? 1);
+        const chunkEnd = (chunk.metadata?.loc?.lines?.to ?? chunkStart);
+        const lines = [];
+        lines.push(`Project: ${serviceName} | File: ${relPath}`);
+        const role = IndexerService.inferRole(relPath);
+        if (role)
+            lines.push(`Role: ${role}`);
+        const overlapping = symbols.filter(s => s.line != null &&
+            s.line <= chunkEnd &&
+            (s.endLine ?? s.line) >= chunkStart);
+        if (overlapping.length > 0) {
+            lines.push(`Symbols: ${overlapping.map(s => `${s.kind} ${s.name}`).join(', ')}`);
+        }
+        if (edges.length > 0) {
+            const depNames = [...new Set(edges.map(e => path.basename(e.toFile, path.extname(e.toFile)).split('.')[0]))];
+            lines.push(`Dependencies: ${depNames.join(', ')}`);
+        }
+        lines.push(`Code: ${chunk.pageContent}`);
+        return lines.join('\n');
+    }
     async embedText(prompt) {
         return this.embedder.embed(prompt);
     }
-    async ingestFile(filePath, serviceName, mtimeMs, projectRoot) {
+    static hashContent(content) {
+        return (0, crypto_1.createHash)('sha256').update(content).digest('hex');
+    }
+    async ingestFile(filePath, serviceName, mtimeMs, projectRoot, analysis, meta) {
         try {
-            const repo = this.db.getRepository(db_1.CodeChunk);
             const relFilePath = path.relative(this.config.workspaceRoot, filePath);
-            const existing = await repo.findOne({
-                select: ['id', 'lastModified'],
-                where: { serviceName, filePath: relFilePath },
-            });
+            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 { edges: rawEdges, symbols: rawSymbols } = await this.ast.analyzeFile(filePath, serviceName, projectRoot);
-            // normalize edges to workspace-relative paths
+            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, calls: rawCalls } = 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 => ({
@@ -222,10 +377,22 @@ class IndexerService {
                 fromFile: path.relative(this.config.workspaceRoot, e.fromFile),
                 toFile: path.relative(this.config.workspaceRoot, e.toFile),
             }));
-            // normalize symbols: replace absolute filePath with workspace-relative
-            const symbols = [...new Map(rawSymbols.map(s => ({ ...s, filePath: relFilePath })).map(s => [`${s.name}:${s.kind}`, s])).values()];
-            const depsMs = Date.now() - t0;
-            const code = fs.readFileSync(filePath, 'utf-8');
+            // 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,
+            }));
+            // Normalize symbols: replace absolute filePath with workspace-relative, strip endLine (not stored)
+            const symbols = [...new Map(rawSymbols.map(s => ({ ...s, filePath: relFilePath })).map(s => [`${s.name}:${s.kind}`, s])).values()].map(({ project, filePath: fp, name, kind, signature, line, col }) => ({ project, filePath: fp, name, kind, signature, line, col }));
+            const astMs = Date.now() - tAst;
             const chunks = await this.getSplitter(filePath).createDocuments([code]);
             const relPath = path.relative(projectRoot, filePath);
             const t2 = Date.now();
@@ -234,43 +401,40 @@ class IndexerService {
                 const batch = chunks.slice(i, i + this.config.indexer.batchSize);
                 const embedded = await Promise.all(batch.map(async (chunk) => {
                     const startLine = (chunk.metadata?.loc?.lines?.from ?? 1);
-                    const prompt = `Project: ${serviceName} | Path: ${relPath}\n${chunk.pageContent}`;
+                    const prompt = this.getEnrichedPrompt(chunk, relPath, serviceName, meta ?? 'missing', edges, rawSymbols);
                     const embedding = await this.embedText(prompt);
-                    return repo.create({
+                    return {
                         serviceName, filePath: relFilePath, startLine,
                         content: chunk.pageContent,
                         embedding: `[${embedding}]`,
                         lastModified: mtimeMs,
-                    });
+                        contentHash: hash,
+                    };
                 }));
                 records.push(...embedded);
             }
             const embedMs = Date.now() - t2;
             const t3 = Date.now();
-            await this.db.transaction(async (manager) => {
-                await manager.delete(db_1.CodeChunk, { serviceName, filePath: relFilePath });
+            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 manager.createQueryBuilder()
-                        .insert()
-                        .into(db_1.CodeChunk)
-                        .values(records.slice(i, i + this.config.indexer.batchSize))
-                        .execute();
+                    await tx.insert(db_1.codeChunk).values(records.slice(i, i + this.config.indexer.batchSize));
                 }
-                await this.writeDepEdges(serviceName, relFilePath, edges, manager);
-                await manager.delete(db_1.CodeSymbol, { project: serviceName, filePath: relFilePath });
+                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 (symbols.length > 0) {
-                    await manager.createQueryBuilder()
-                        .insert()
-                        .into(db_1.CodeSymbol)
-                        .values(symbols)
-                        .execute();
+                    await tx.insert(db_1.codeSymbol).values(symbols);
+                }
+                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,
-                    depsMs, embedMs, dbMs, totalMs: Date.now() - t0,
+                    astMs, embedMs, dbMs, totalMs: Date.now() - t0,
                 });
             }
             return { status: 'indexed', chunks: chunks.length };

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

@@ -4,7 +4,11 @@ export declare class LoggerService {
     private readonly logger;
     constructor(logger: pino.Logger);
     static silent(): LoggerService;
-    static fromEnv(name?: string): LoggerService;
+    static fromConfig(cfg: {
+        level: string;
+        dir?: string;
+    }, name?: string): LoggerService;
+    private static buildFromPath;
     debug(msg: string, data?: Record<string, unknown>): void;
     info(msg: string, data?: Record<string, unknown>): void;
     warn(msg: string, data?: Record<string, unknown>): void;