codesearch-mcp 0.0.14-alpha → 0.0.16-alpha

package/dist/src/services/AstParserService.js

@@ -51,6 +51,55 @@ class AstParserService {
         this.logger = logger;
     }
     // ── public interface ────────────────────────────────────────────────────────
+    async analyzeProject(filePaths, serviceName, projectRoot = process.cwd()) {
+        const t0 = Date.now();
+        const analysisMap = new Map();
+        const morphProject = this.createMorphProject(projectRoot);
+        for (const filePath of filePaths) {
+            if (!/\.(ts|tsx|js|jsx)$/.test(filePath) || /\.d\.ts$/.test(filePath)) {
+                analysisMap.set(filePath, { edges: [], symbols: [] });
+                continue;
+            }
+            try {
+                morphProject.addSourceFileAtPath(filePath);
+            }
+            catch (err) {
+                this.logger.warn('AstParser: failed to add source file', { filePath, reason: err.message });
+                analysisMap.set(filePath, { edges: [], symbols: [] });
+            }
+        }
+        for (const sourceFile of morphProject.getSourceFiles()) {
+            const filePath = sourceFile.getFilePath();
+            try {
+                const edges = this.extractEdges(sourceFile, filePath, serviceName);
+                const symbols = this.extractSymbols(sourceFile, filePath, serviceName);
+                analysisMap.set(filePath, { edges, symbols });
+            }
+            catch (err) {
+                this.logger.warn('AstParser: failed to analyze file', { filePath, reason: err.message });
+                analysisMap.set(filePath, { edges: [], symbols: [] });
+            }
+        }
+        // Release source file memory before returning
+        for (const sourceFile of morphProject.getSourceFiles()) {
+            morphProject.removeSourceFile(sourceFile);
+        }
+        this.logger.debug('AstParser: analyzeProject done', {
+            projectRoot, total: filePaths.length, parsed: analysisMap.size, ms: Date.now() - t0,
+        });
+        return analysisMap;
+    }
+    clearCache(projectRoot) {
+        if (projectRoot) {
+            const project = this.morphProjects.get(projectRoot);
+            if (project) {
+                this.morphProjects.delete(projectRoot);
+            }
+        }
+        else {
+            this.morphProjects.clear();
+        }
+    }
     async analyzeFile(filePath, serviceName, projectRoot = path.dirname(filePath)) {
         if (!/\.(ts|tsx|js|jsx)$/.test(filePath) || /\.d\.ts$/.test(filePath)) {
             return { edges: [], symbols: [] };
@@ -77,20 +126,7 @@ class AstParserService {
         return edges;
     }
     // ── private: MorphProject cache (LRU, max MORPH_CACHE_MAX entries) ──────────
-    getMorphProject(projectRoot) {
-        if (this.morphProjects.has(projectRoot)) {
-            // Move to end = most recently used
-            const cached = this.morphProjects.get(projectRoot);
-            this.morphProjects.delete(projectRoot);
-            this.morphProjects.set(projectRoot, cached);
-            return cached;
-        }
-        if (this.morphProjects.size >= MORPH_CACHE_MAX) {
-            // Evict least recently used (first entry in insertion-order Map)
-            const lruKey = this.morphProjects.keys().next().value;
-            this.morphProjects.delete(lruKey);
-            this.logger.debug('AstParser: evicted LRU project', { lruKey });
-        }
+    createMorphProject(projectRoot) {
         const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
         const hasTsconfig = fs.existsSync(tsconfigPath);
         this.logger.debug('AstParser: tsconfig lookup', { projectRoot, found: hasTsconfig });
@@ -117,6 +153,23 @@ class AstParserService {
             });
             project = new ts_morph_1.Project(FALLBACK_OPTS);
         }
+        return project;
+    }
+    getMorphProject(projectRoot) {
+        if (this.morphProjects.has(projectRoot)) {
+            // Move to end = most recently used
+            const cached = this.morphProjects.get(projectRoot);
+            this.morphProjects.delete(projectRoot);
+            this.morphProjects.set(projectRoot, cached);
+            return cached;
+        }
+        if (this.morphProjects.size >= MORPH_CACHE_MAX) {
+            // Evict least recently used (first entry in insertion-order Map)
+            const lruKey = this.morphProjects.keys().next().value;
+            this.morphProjects.delete(lruKey);
+            this.logger.debug('AstParser: evicted LRU project', { lruKey });
+        }
+        const project = this.createMorphProject(projectRoot);
         this.morphProjects.set(projectRoot, project);
         return project;
     }
@@ -223,7 +276,6 @@ class AstParserService {
     // ── private: symbol extraction ─────────────────────────────────────────────
     extractSymbols(sourceFile, filePath, serviceName) {
         const symbols = [];
-        // Find the first line matching the keyword — skips leading decorators.
         const sig = (text, keyword) => {
             const found = text.split('\n').find(l => keyword.test(l));
             return found?.trim() ?? text.split('\n')[0].trim();
@@ -239,7 +291,11 @@ class AstParserService {
                 continue;
             const nameNode = cls.getNameNode();
             const { line, col } = nameNode ? getPos(nameNode) : { line: cls.getStartLineNumber(), col: 1 };
-            symbols.push({ project: serviceName, filePath, name, kind: 'class', signature: sig(cls.getText(), /\bclass\s/), line, col });
+            symbols.push({
+                project: serviceName, filePath, name, kind: 'class',
+                signature: sig(cls.getText(), /\bclass\s/),
+                line, endLine: cls.getEndLineNumber(), col,
+            });
         }
         for (const fn of sourceFile.getFunctions()) {
             const name = fn.getName();
@@ -247,20 +303,36 @@ class AstParserService {
                 continue;
             const nameNode = fn.getNameNode();
             const { line, col } = nameNode ? getPos(nameNode) : { line: fn.getStartLineNumber(), col: 1 };
-            symbols.push({ project: serviceName, filePath, name, kind: 'function', signature: sig(fn.getText(), /\bfunction\s/), line, col });
+            symbols.push({
+                project: serviceName, filePath, name, kind: 'function',
+                signature: sig(fn.getText(), /\bfunction\s/),
+                line, endLine: fn.getEndLineNumber(), col,
+            });
         }
         for (const iface of sourceFile.getInterfaces()) {
             const { line, col } = getPos(iface.getNameNode());
-            symbols.push({ project: serviceName, filePath, name: iface.getName(), kind: 'interface', signature: sig(iface.getText(), /\binterface\s/), line, col });
+            symbols.push({
+                project: serviceName, filePath, name: iface.getName(), kind: 'interface',
+                signature: sig(iface.getText(), /\binterface\s/),
+                line, endLine: iface.getEndLineNumber(), col,
+            });
         }
         for (const ta of sourceFile.getTypeAliases()) {
             const { line, col } = getPos(ta.getNameNode());
-            symbols.push({ project: serviceName, filePath, name: ta.getName(), kind: 'type', signature: sig(ta.getText(), /\btype\s/), line, col });
+            symbols.push({
+                project: serviceName, filePath, name: ta.getName(), kind: 'type',
+                signature: sig(ta.getText(), /\btype\s/),
+                line, endLine: ta.getEndLineNumber(), col,
+            });
         }
         for (const stmt of sourceFile.getVariableStatements()) {
             for (const decl of stmt.getDeclarations()) {
                 const { line, col } = getPos(decl.getNameNode());
-                symbols.push({ project: serviceName, filePath, name: decl.getName(), kind: 'variable', signature: sig(stmt.getText(), /\b(const|let|var)\s/), line, col });
+                symbols.push({
+                    project: serviceName, filePath, name: decl.getName(), kind: 'variable',
+                    signature: sig(stmt.getText(), /\b(const|let|var)\s/),
+                    line, endLine: stmt.getEndLineNumber(), col,
+                });
             }
         }
         return symbols;

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

@@ -1,14 +1,21 @@
-import { EntityManager, EntityTarget, ObjectLiteral, Repository } from 'typeorm';
+import type { NodePgDatabase, NodePgTransaction } from 'drizzle-orm/node-postgres';
+import type { ExtractTablesWithRelations } from 'drizzle-orm/relations';
 import type { Config } from '../config';
+import * as schema from '../db/schema';
+type Schema = typeof schema;
+export type DrizzleDb = NodePgDatabase<Schema>;
+export type DrizzleTx = NodePgTransaction<Schema, ExtractTablesWithRelations<Schema>>;
 export declare class DatabaseService {
     private config;
-    private dataSource;
+    private pool;
+    private _db;
     constructor(config: Config);
+    get orm(): DrizzleDb;
     query<T = any>(sql: string, params?: any[]): Promise<T>;
-    transaction<T>(fn: (manager: EntityManager) => Promise<T>): Promise<T>;
-    getRepository<T extends ObjectLiteral>(entity: EntityTarget<T>): Repository<T>;
+    transaction<T>(fn: (tx: DrizzleTx) => Promise<T>): Promise<T>;
     destroy(): Promise<void>;
     initDb(): Promise<void>;
     initDbWithSchema(): Promise<void>;
     private ensureDatabaseExists;
 }
+export {};

package/dist/src/services/DatabaseService.js

@@ -1,105 +1,146 @@
 "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 });
     }
     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)`);
     }
     async ensureDatabaseExists() {
         const { host, port, username, password, database } = this.config.db;

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

@@ -34,6 +34,8 @@ export declare class IndexerService {
     private writeDepEdges;
     scanAndIndex(dir: string, serviceName: string, force?: boolean, signal?: AbortSignal, preCollectedFiles?: string[]): Promise<IndexStats>;
     private getSplitter;
+    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");
@@ -80,11 +82,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++;
@@ -109,30 +111,29 @@ 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);
         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);
         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)}`);
@@ -171,6 +172,8 @@ class IndexerService {
         const stats = {
             serviceName, indexed: 0, skipped: 0, failed: 0, chunks: 0, elapsedSec: 0, warnings,
         };
+        const mtimeRefreshBatch = [];
+        const analysisMap = await this.ast.analyzeProject(files, serviceName, dir);
         for (const filePath of files) {
             if (signal?.aborted) {
                 bar.stop();
@@ -180,7 +183,14 @@ class IndexerService {
             }
             bar.update({ filename: path.relative(dir, filePath) });
             const mtimeMs = fs.statSync(filePath).mtimeMs;
-            const result = await this.ingestFile(filePath, serviceName, mtimeMs, dir);
+            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);
+            if (result.pendingMtimeRefresh) {
+                mtimeRefreshBatch.push({ relFilePath: result.pendingMtimeRefresh, mtimeMs });
+            }
             if (result.status === 'indexed')
                 stats.indexed++;
             else if (result.status === 'skipped')
@@ -192,29 +202,71 @@ class IndexerService {
         }
         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;
         return stats;
     }
     getSplitter(filePath) {
         return SCHEMA_EXTENSIONS.test(filePath) ? this.schemaSplitter : this.jsSplitter;
     }
+    getEnrichedPrompt(chunk, analysis, serviceName, relPath) {
+        const { pageContent, metadata } = chunk;
+        const header = `Project: ${serviceName} | Path: ${relPath}`;
+        if (!analysis || analysis.symbols.length === 0) {
+            return `${header}\n${pageContent}`;
+        }
+        const chunkStartLine = metadata?.loc?.lines?.from ?? 1;
+        const chunkEndLine = metadata?.loc?.lines?.to ?? chunkStartLine;
+        const relevantSymbols = analysis.symbols.filter(s => s.line != null && s.endLine != null && s.line <= chunkEndLine && s.endLine >= chunkStartLine);
+        if (relevantSymbols.length === 0) {
+            return `${header}\n${pageContent}`;
+        }
+        const symbolsTag = `[Symbols: ${relevantSymbols.map(s => `${s.kind} ${s.name}`).join(', ')}]`;
+        return `${header}\n${symbolsTag}\n${pageContent}`;
+    }
     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) {
         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 } = analysis ?? { edges: [], symbols: [] };
+            // 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 +274,9 @@ 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 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 +285,36 @@ 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, analysis, serviceName, relPath);
                     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);
                 }
             });
             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 };