codesearch-mcp 0.0.15-alpha → 0.0.16-alpha

package/CHANGELOG.md

@@ -3,6 +3,23 @@
 All notable changes to this project will be documented in this file.
 Format based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [0.0.16-alpha] - 2026-05-02
+
+### Added
+
+- **Hybrid incremental indexing (mtime + SHA-256)** — `rag-index` now uses a two-step skip check per file: fast `mtime` comparison first (no file read), then SHA-256 content hash if `mtime` changed. Files with identical content but reset timestamps (after `git clone`, DB transfer, or `touch`) are skipped without re-embedding. `lastModified` is refreshed in a single batch SQL `UPDATE` after each project scan. `--reindex` clears both fields.
+- `contentHash varchar(64)` column added to `code_chunk`; applied automatically via `ALTER TABLE ... ADD COLUMN IF NOT EXISTS` on startup — no manual migration needed.
+
+### Changed
+
+- **Migrated from TypeORM to Drizzle ORM**
+- **Batch AST parsing (`analyzeProject`)** — `IndexerService` now parses all project files in a single `MorphProject` instance instead of one per file, reducing ts-morph overhead on large projects
+- **Enriched embedding context** — chunks now include `[Symbols: class Foo, function bar]` tag when the chunk overlaps known symbol definitions, improving semantic search quality for partial/truncated chunks. **Requires full re-index** (`rag-index /path --reindex`) — existing embeddings were built without symbol context and will produce degraded similarity scores against new chunks if mixed.
+- **`endLine` added to `SymbolEntry`** — enables accurate chunk-to-symbol overlap detection used by enriched prompts
+- **`analyzeProject` error isolation** — parse failures are caught per-file; one broken file no longer aborts the entire project scan
+- **Memory cleanup in `analyzeProject`** — source files are explicitly removed from `MorphProject` after parsing to release memory
+- **Logging improvements** — `AstParser: analyzeProject done` debug log reports total files, parsed count, and elapsed ms; per-file `depsMs` renamed to `astMs` (now ~0 since AST work is done upfront)
+
 ## [0.0.15-alpha] - 2026-05-02
 
 ### Changed

package/README.md

@@ -6,6 +6,8 @@ Ask Claude things like *"where is the payment retry logic?"* or *"show me how au
 
 > **Alpha** — works well locally, API may change before 1.0.
 
+See [CHANGELOG.md](./CHANGELOG.md) for version history.
+
 ## How it works
 
 1. `rag-index` scans your projects, chunks source files, embeds them with [bge-m3](https://huggingface.co/BAAI/bge-m3) via Ollama, and stores vectors in PostgreSQL

package/dist/src/db/index.d.ts

@@ -1,3 +1,2 @@
-export { CodeChunk } from './entities/code-chunk.entity';
-export { CodeDependency } from './entities/code-dependency.entity';
-export { CodeSymbol } from './entities/code-symbol.entity';
+export { codeChunk, codeDependency, codeSymbol } from './schema';
+export type { CodeChunkInsert } from './schema';

package/dist/src/db/index.js

@@ -1,9 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CodeSymbol = exports.CodeDependency = exports.CodeChunk = void 0;
-var code_chunk_entity_1 = require("./entities/code-chunk.entity");
-Object.defineProperty(exports, "CodeChunk", { enumerable: true, get: function () { return code_chunk_entity_1.CodeChunk; } });
-var code_dependency_entity_1 = require("./entities/code-dependency.entity");
-Object.defineProperty(exports, "CodeDependency", { enumerable: true, get: function () { return code_dependency_entity_1.CodeDependency; } });
-var code_symbol_entity_1 = require("./entities/code-symbol.entity");
-Object.defineProperty(exports, "CodeSymbol", { enumerable: true, get: function () { return code_symbol_entity_1.CodeSymbol; } });
+exports.codeSymbol = exports.codeDependency = exports.codeChunk = void 0;
+var schema_1 = require("./schema");
+Object.defineProperty(exports, "codeChunk", { enumerable: true, get: function () { return schema_1.codeChunk; } });
+Object.defineProperty(exports, "codeDependency", { enumerable: true, get: function () { return schema_1.codeDependency; } });
+Object.defineProperty(exports, "codeSymbol", { enumerable: true, get: function () { return schema_1.codeSymbol; } });

package/dist/src/db/schema.d.ts

@@ -0,0 +1,417 @@
+export declare const codeChunk: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "code_chunk";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "code_chunk";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        serviceName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "serviceName";
+            tableName: "code_chunk";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        filePath: import("drizzle-orm/pg-core").PgColumn<{
+            name: "filePath";
+            tableName: "code_chunk";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        startLine: import("drizzle-orm/pg-core").PgColumn<{
+            name: "startLine";
+            tableName: "code_chunk";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        content: import("drizzle-orm/pg-core").PgColumn<{
+            name: "content";
+            tableName: "code_chunk";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        embedding: import("drizzle-orm/pg-core").PgColumn<{
+            name: "embedding";
+            tableName: "code_chunk";
+            dataType: "custom";
+            columnType: "PgCustomColumn";
+            data: string;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            pgColumnBuilderBrand: "PgCustomColumnBuilderBrand";
+        }>;
+        lastModified: import("drizzle-orm/pg-core").PgColumn<{
+            name: "lastModified";
+            tableName: "code_chunk";
+            dataType: "number";
+            columnType: "PgDoublePrecision";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        contentHash: import("drizzle-orm/pg-core").PgColumn<{
+            name: "contentHash";
+            tableName: "code_chunk";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 64;
+        }>;
+    };
+    dialect: "pg";
+}>;
+export declare const codeDependency: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "code_dependency";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "code_dependency";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        project: import("drizzle-orm/pg-core").PgColumn<{
+            name: "project";
+            tableName: "code_dependency";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        fromFile: import("drizzle-orm/pg-core").PgColumn<{
+            name: "fromFile";
+            tableName: "code_dependency";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        fromSymbol: import("drizzle-orm/pg-core").PgColumn<{
+            name: "fromSymbol";
+            tableName: "code_dependency";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        toFile: import("drizzle-orm/pg-core").PgColumn<{
+            name: "toFile";
+            tableName: "code_dependency";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        toSymbol: import("drizzle-orm/pg-core").PgColumn<{
+            name: "toSymbol";
+            tableName: "code_dependency";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        depType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "depType";
+            tableName: "code_dependency";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const codeSymbol: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "code_symbol";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "code_symbol";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        project: import("drizzle-orm/pg-core").PgColumn<{
+            name: "project";
+            tableName: "code_symbol";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        filePath: import("drizzle-orm/pg-core").PgColumn<{
+            name: "filePath";
+            tableName: "code_symbol";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "code_symbol";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        kind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "kind";
+            tableName: "code_symbol";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        signature: import("drizzle-orm/pg-core").PgColumn<{
+            name: "signature";
+            tableName: "code_symbol";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        line: import("drizzle-orm/pg-core").PgColumn<{
+            name: "line";
+            tableName: "code_symbol";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        col: import("drizzle-orm/pg-core").PgColumn<{
+            name: "col";
+            tableName: "code_symbol";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type CodeChunkInsert = typeof codeChunk.$inferInsert;

package/dist/src/db/schema.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeSymbol = exports.codeDependency = exports.codeChunk = void 0;
+const pg_core_1 = require("drizzle-orm/pg-core");
+const vector = (0, pg_core_1.customType)({
+    dataType(config) { return `vector(${config?.dimensions ?? 1024})`; },
+});
+exports.codeChunk = (0, pg_core_1.pgTable)('code_chunk', {
+    id: (0, pg_core_1.uuid)('id').primaryKey().defaultRandom(),
+    serviceName: (0, pg_core_1.text)('serviceName').notNull(),
+    filePath: (0, pg_core_1.text)('filePath').notNull(),
+    startLine: (0, pg_core_1.integer)('startLine'),
+    content: (0, pg_core_1.text)('content').notNull(),
+    embedding: vector('embedding', { dimensions: 1024 }).notNull(),
+    lastModified: (0, pg_core_1.doublePrecision)('lastModified'),
+    contentHash: (0, pg_core_1.varchar)('contentHash', { length: 64 }),
+});
+exports.codeDependency = (0, pg_core_1.pgTable)('code_dependency', {
+    id: (0, pg_core_1.uuid)('id').primaryKey().defaultRandom(),
+    project: (0, pg_core_1.text)('project').notNull(),
+    fromFile: (0, pg_core_1.text)('fromFile').notNull(),
+    fromSymbol: (0, pg_core_1.text)('fromSymbol'),
+    toFile: (0, pg_core_1.text)('toFile').notNull(),
+    toSymbol: (0, pg_core_1.text)('toSymbol'),
+    depType: (0, pg_core_1.text)('depType').notNull(),
+});
+exports.codeSymbol = (0, pg_core_1.pgTable)('code_symbol', {
+    id: (0, pg_core_1.uuid)('id').primaryKey().defaultRandom(),
+    project: (0, pg_core_1.text)('project').notNull(),
+    filePath: (0, pg_core_1.text)('filePath').notNull(),
+    name: (0, pg_core_1.text)('name').notNull(),
+    kind: (0, pg_core_1.text)('kind').notNull(),
+    signature: (0, pg_core_1.text)('signature'),
+    line: (0, pg_core_1.integer)('line'),
+    col: (0, pg_core_1.integer)('col'),
+});

package/dist/src/interfaces/IAstParser.d.ts

@@ -13,6 +13,7 @@ export interface SymbolEntry {
     kind: 'function' | 'class' | 'interface' | 'type' | 'variable' | 'method';
     signature: string | null;
     line: number | null;
+    endLine: number | null;
     col: number | null;
 }
 export interface FileAnalysis {
@@ -20,5 +21,10 @@ export interface FileAnalysis {
     symbols: SymbolEntry[];
 }
 export interface IAstParser {
+    /**
+     * @deprecated Use analyzeProject instead for project-wide context.
+     */
     analyzeFile(filePath: string, serviceName: string, projectRoot?: string): Promise<FileAnalysis>;
+    analyzeProject(filePaths: string[], serviceName: string, projectRoot?: string): Promise<Map<string, FileAnalysis>>;
+    clearCache(projectRoot?: string): void;
 }

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

@@ -4,8 +4,11 @@ export declare class AstParserService implements IAstParser {
     private logger;
     private morphProjects;
     constructor(logger?: LoggerService);
+    analyzeProject(filePaths: string[], serviceName: string, projectRoot?: string): Promise<Map<string, FileAnalysis>>;
+    clearCache(projectRoot?: string): void;
     analyzeFile(filePath: string, serviceName: string, projectRoot?: string): Promise<FileAnalysis>;
     extractImportEdges(filePath: string, serviceName: string, projectRoot?: string): Promise<DepEdge[]>;
+    private createMorphProject;
     private getMorphProject;
     private extractEdges;
     private resolveFromSymbol;

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

package/dist/src/services/McpServer.js

@@ -63,6 +63,8 @@ Pick one workflow based on what you need:
 | **Flow audit** | "how does X connect to Y", "audit this flow", "trace the path" | search_codebase → **get_dependencies + get_dependents** → Grep |
 | **Impact** | "what would break if I change X", "what uses Z" | get_dependents → search_codebase for context |
 
+> **No results?** Never conclude the code doesn't exist after a single attempt. Retry with \`threshold\` raised by 0.05–0.10 (e.g. 0.45 → 0.50 → 0.55) before giving up. The code may exist under a different name or domain term.
+
 ## Tools
 
 - **list_projects** — call this first to see what projects are indexed and their exact names.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codesearch-mcp",
-  "version": "0.0.15-alpha",
+  "version": "0.0.16-alpha",
   "description": "Local semantic codebase search via MCP — indexes projects into pgvector, exposes search to Claude",
   "license": "MIT",
   "main": "dist/app.js",
@@ -34,14 +34,13 @@
     "@modelcontextprotocol/sdk": "^1.0.0",
     "cli-progress": "^3.12.0",
     "dotenv": "^17.4.2",
+    "drizzle-orm": "^0.45.2",
     "ignore": "^7.0.5",
     "ollama": "^0.5.0",
     "pg": "^8.13.0",
     "pino": "^10.3.1",
     "pino-roll": "^4.0.0",
-    "reflect-metadata": "^0.2.2",
     "ts-morph": "^28.0.0",
-    "typeorm": "^0.3.20",
     "zod": "^4.3.6"
   },
   "devDependencies": {