codesearch-mcp 0.0.9-alpha → 0.0.11-alpha

package/dist/src/db/entities/code-symbol.entity.js

@@ -0,0 +1,59 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeSymbol = void 0;
+const typeorm_1 = require("typeorm");
+let CodeSymbol = class CodeSymbol {
+    id;
+    project;
+    filePath;
+    name;
+    kind;
+    signature;
+    line;
+    col;
+};
+exports.CodeSymbol = CodeSymbol;
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)('uuid'),
+    __metadata("design:type", String)
+], CodeSymbol.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], CodeSymbol.prototype, "project", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], CodeSymbol.prototype, "filePath", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], CodeSymbol.prototype, "name", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], CodeSymbol.prototype, "kind", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'text', nullable: true }),
+    __metadata("design:type", Object)
+], CodeSymbol.prototype, "signature", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: true }),
+    __metadata("design:type", Object)
+], CodeSymbol.prototype, "line", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: true }),
+    __metadata("design:type", Object)
+], CodeSymbol.prototype, "col", void 0);
+exports.CodeSymbol = CodeSymbol = __decorate([
+    (0, typeorm_1.Entity)()
+], CodeSymbol);

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

@@ -1,4 +1,3 @@
 export { CodeChunk } from './entities/code-chunk.entity';
 export { CodeDependency } from './entities/code-dependency.entity';
-export { db } from './data-source';
-export { initDb, initDbWithSchema } from './init';
+export { CodeSymbol } from './entities/code-symbol.entity';

package/dist/src/db/index.js

@@ -1,12 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initDbWithSchema = exports.initDb = exports.db = exports.CodeDependency = exports.CodeChunk = void 0;
+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 data_source_1 = require("./data-source");
-Object.defineProperty(exports, "db", { enumerable: true, get: function () { return data_source_1.db; } });
-var init_1 = require("./init");
-Object.defineProperty(exports, "initDb", { enumerable: true, get: function () { return init_1.initDb; } });
-Object.defineProperty(exports, "initDbWithSchema", { enumerable: true, get: function () { return init_1.initDbWithSchema; } });
+var code_symbol_entity_1 = require("./entities/code-symbol.entity");
+Object.defineProperty(exports, "CodeSymbol", { enumerable: true, get: function () { return code_symbol_entity_1.CodeSymbol; } });

package/dist/src/file-utils.d.ts

@@ -6,7 +6,8 @@ export interface ProjectMeta {
     notes: string | null;
     relations: Relations | null;
 }
-export declare function readRagMeta(projectDir: string): ProjectMeta | null;
+export type RagMetaResult = ProjectMeta | 'missing' | 'invalid';
+export declare function readRagMeta(projectDir: string): RagMetaResult;
 export declare const IGNORE_DIRS: Set<string>;
 export declare function loadIgnore(projectDir: string): ReturnType<typeof ignore>;
 export declare function collectFiles(dir: string, ig: ReturnType<typeof ignore>, rootDir: string): string[];

package/dist/src/file-utils.js

@@ -43,12 +43,10 @@ exports.collectFiles = collectFiles;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const ignore_1 = __importDefault(require("ignore"));
-// Returns null if file is missing or contains invalid JSON.
-// Returns ProjectMeta (fields may be null) if file exists and parses correctly.
 function readRagMeta(projectDir) {
     const metaPath = path.join(projectDir, '.ragmeta.json');
     if (!fs.existsSync(metaPath))
-        return null;
+        return 'missing';
     try {
         const raw = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
         return {
@@ -59,7 +57,7 @@ function readRagMeta(projectDir) {
         };
     }
     catch {
-        return null;
+        return 'invalid';
     }
 }
 exports.IGNORE_DIRS = new Set([
@@ -79,7 +77,14 @@ function loadIgnore(projectDir) {
 }
 function collectFiles(dir, ig, rootDir) {
     const result = [];
-    for (const file of fs.readdirSync(dir)) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        return result;
+    }
+    for (const file of entries) {
         const fullPath = path.join(dir, file);
         const relPath = path.relative(rootDir, fullPath);
         if (ig.ignores(relPath))

package/dist/src/graph.js

@@ -243,10 +243,11 @@ function buildHtml(nodes, edges) {
 }
 // Single entry point — reads meta once, prints console summary and writes HTML
 function generateProjectGraph(projects, workspacePath) {
-    const nodes = projects.map(p => ({
-        name: p.name,
-        ...((0, file_utils_1.readRagMeta)(p.path) ?? { description: null, stack: null, notes: null, relations: null }),
-    }));
+    const EMPTY = { description: null, stack: null, notes: null, relations: null };
+    const nodes = projects.map(p => {
+        const meta = (0, file_utils_1.readRagMeta)(p.path);
+        return { name: p.name, ...(typeof meta === 'object' ? meta : EMPTY) };
+    });
     const edges = buildEdges(nodes);
     printConsole(nodes, edges, workspacePath);
     const htmlPath = path.join(workspacePath, 'project-graph.html');

package/dist/src/help.js

@@ -19,7 +19,7 @@ function printHelp(command) {
             console.log('  -h, --help        Show this help message');
             console.log('');
             console.log('Subcommands:');
-            console.log('  backfill          Populate dependency graph for already-indexed files');
+            console.log('  backfill          Populate symbol index (code_symbol) for already-indexed files');
             break;
         case 'rag-mcp':
         case 'mcp':

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

@@ -0,0 +1,24 @@
+export interface DepEdge {
+    project: string;
+    fromFile: string;
+    fromSymbol: string | null;
+    toFile: string;
+    toSymbol: string | null;
+    depType: string;
+}
+export interface SymbolEntry {
+    project: string;
+    filePath: string;
+    name: string;
+    kind: 'function' | 'class' | 'interface' | 'type' | 'variable';
+    signature: string | null;
+    line: number | null;
+    col: number | null;
+}
+export interface FileAnalysis {
+    edges: DepEdge[];
+    symbols: SymbolEntry[];
+}
+export interface IAstParser {
+    analyzeFile(filePath: string, serviceName: string, projectRoot?: string): Promise<FileAnalysis>;
+}

package/dist/src/interfaces/IAstParser.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,4 @@
+export interface IEmbedder {
+    embed(text: string): Promise<number[]>;
+    translate?(text: string, model: string): Promise<string>;
+}

package/dist/src/interfaces/IEmbedder.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/interrupt.d.ts

@@ -1,3 +1 @@
-export declare const signal: AbortSignal;
-export declare function setupInterrupt(): void;
-export declare function teardownInterrupt(): void;
+export declare function setupInterrupt(controller: AbortController): () => void;

package/dist/src/interrupt.js

@@ -1,27 +1,25 @@
 "use strict";
-// Graceful interruption signal for long-running CLI operations.
-// Listens for ESC or Ctrl+C on stdin and aborts the shared controller.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.signal = void 0;
 exports.setupInterrupt = setupInterrupt;
-exports.teardownInterrupt = teardownInterrupt;
-const controller = new AbortController();
-exports.signal = controller.signal;
-function setupInterrupt() {
+// Graceful interruption for long-running CLI operations.
+// Caller creates the AbortController; this function wires stdin and returns a cleanup function.
+function setupInterrupt(controller) {
     if (!process.stdin.isTTY)
-        return;
+        return () => { };
     process.stdin.setRawMode(true);
     process.stdin.resume();
     process.stdin.setEncoding('utf8');
-    process.stdin.on('data', (key) => {
+    const handler = (key) => {
         if (key === '\x1b' || key === '\x03')
             controller.abort();
-    });
+    };
+    process.stdin.on('data', handler);
     console.log('Press ESC or Ctrl+C to interrupt.\n');
-}
-function teardownInterrupt() {
-    if (!process.stdin.isTTY)
-        return;
-    process.stdin.setRawMode(false);
-    process.stdin.pause();
+    return () => {
+        process.stdin.off('data', handler);
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+        }
+    };
 }

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

@@ -0,0 +1,14 @@
+import type { IAstParser, DepEdge, FileAnalysis } from '../interfaces/IAstParser';
+import { LoggerService } from './LoggerService';
+export declare class AstParserService implements IAstParser {
+    private logger;
+    private morphProjects;
+    constructor(logger?: LoggerService);
+    analyzeFile(filePath: string, serviceName: string, projectRoot?: string): Promise<FileAnalysis>;
+    extractImportEdges(filePath: string, serviceName: string, projectRoot?: string): Promise<DepEdge[]>;
+    private getMorphProject;
+    private extractEdges;
+    private resolveFromSymbol;
+    private buildUsageMap;
+    private extractSymbols;
+}

package/dist/src/services/AstParserService.js

@@ -0,0 +1,256 @@
+"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.AstParserService = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const ts_morph_1 = require("ts-morph");
+const LoggerService_1 = require("./LoggerService");
+const FALLBACK_OPTS = {
+    skipAddingFilesFromTsConfig: true,
+    skipFileDependencyResolution: false,
+    compilerOptions: { allowJs: true, noEmit: true },
+};
+class AstParserService {
+    logger;
+    morphProjects = new Map();
+    constructor(logger = LoggerService_1.LoggerService.silent()) {
+        this.logger = logger;
+    }
+    // ── public interface ────────────────────────────────────────────────────────
+    async analyzeFile(filePath, serviceName, projectRoot = path.dirname(filePath)) {
+        if (!/\.(ts|tsx|js|jsx)$/.test(filePath) || /\.d\.ts$/.test(filePath)) {
+            return { edges: [], symbols: [] };
+        }
+        const morphProject = this.getMorphProject(projectRoot);
+        const existing = morphProject.getSourceFile(filePath);
+        if (existing)
+            morphProject.removeSourceFile(existing);
+        let sourceFile;
+        try {
+            sourceFile = morphProject.addSourceFileAtPath(filePath);
+        }
+        catch {
+            return { edges: [], symbols: [] };
+        }
+        const edges = this.extractEdges(sourceFile, filePath, serviceName);
+        const symbols = this.extractSymbols(sourceFile, filePath, serviceName);
+        morphProject.removeSourceFile(sourceFile);
+        return { edges, symbols };
+    }
+    // Kept for test compatibility (extract-import-edges.test.ts).
+    async extractImportEdges(filePath, serviceName, projectRoot) {
+        const { edges } = await this.analyzeFile(filePath, serviceName, projectRoot);
+        return edges;
+    }
+    // ── private: MorphProject cache ────────────────────────────────────────────
+    getMorphProject(projectRoot) {
+        if (!this.morphProjects.has(projectRoot)) {
+            const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
+            const hasTsconfig = fs.existsSync(tsconfigPath);
+            this.logger.debug('AstParser: tsconfig lookup', { projectRoot, found: hasTsconfig });
+            let project;
+            try {
+                const opts = hasTsconfig
+                    ? { tsConfigFilePath: tsconfigPath, skipAddingFilesFromTsConfig: true, skipFileDependencyResolution: false }
+                    : FALLBACK_OPTS;
+                project = new ts_morph_1.Project(opts);
+                if (hasTsconfig) {
+                    const co = project.getCompilerOptions();
+                    const pathsMap = co.paths ?? {};
+                    const pathCount = Object.keys(pathsMap).length;
+                    this.logger.debug('AstParser: tsconfig loaded', { pathCount });
+                    if (pathCount > 0) {
+                        this.logger.debug('AstParser: path aliases', { aliases: Object.keys(pathsMap) });
+                    }
+                }
+            }
+            catch (err) {
+                this.logger.warn('AstParser: tsconfig load failed, using fallback', {
+                    tsconfigPath,
+                    reason: err.message,
+                });
+                project = new ts_morph_1.Project(FALLBACK_OPTS);
+            }
+            this.morphProjects.set(projectRoot, project);
+        }
+        return this.morphProjects.get(projectRoot);
+    }
+    // ── private: edge extraction (imports + re-exports) ────────────────────────
+    extractEdges(sourceFile, filePath, serviceName) {
+        const edges = [];
+        const usageMap = this.buildUsageMap(sourceFile);
+        for (const decl of sourceFile.getImportDeclarations()) {
+            const resolved = decl.getModuleSpecifierSourceFile();
+            if (!resolved) {
+                const specifier = decl.getModuleSpecifierValue();
+                if (specifier.startsWith('.')) {
+                    this.logger.debug('AstParser: unresolved import', { specifier, file: filePath });
+                }
+                continue;
+            }
+            const toFile = resolved.getFilePath();
+            if (toFile.includes('/node_modules/'))
+                continue;
+            const namedImports = decl.getNamedImports();
+            const defaultImport = decl.getDefaultImport();
+            const namespaceImport = decl.getNamespaceImport();
+            if (namedImports.length > 0) {
+                for (const named of namedImports) {
+                    const localName = named.getAliasNode()?.getText() ?? named.getName();
+                    const fromSymbol = this.resolveFromSymbol(localName, usageMap);
+                    edges.push({
+                        project: serviceName, fromFile: filePath, fromSymbol,
+                        toFile, toSymbol: named.getName(), depType: 'import',
+                    });
+                }
+            }
+            else if (defaultImport) {
+                edges.push({
+                    project: serviceName, fromFile: filePath, fromSymbol: null,
+                    toFile, toSymbol: null, depType: 'import-default',
+                });
+            }
+            else if (namespaceImport) {
+                edges.push({
+                    project: serviceName, fromFile: filePath, fromSymbol: null,
+                    toFile, toSymbol: null, depType: 'import-namespace',
+                });
+            }
+        }
+        for (const decl of sourceFile.getExportDeclarations()) {
+            const resolved = decl.getModuleSpecifierSourceFile();
+            if (!resolved)
+                continue;
+            const toFile = resolved.getFilePath();
+            if (toFile.includes('/node_modules/'))
+                continue;
+            const namedExports = decl.getNamedExports();
+            if (namedExports.length > 0) {
+                for (const named of namedExports) {
+                    edges.push({
+                        project: serviceName, fromFile: filePath, fromSymbol: null,
+                        toFile, toSymbol: named.getName(), depType: 'reexport',
+                    });
+                }
+            }
+            else {
+                edges.push({
+                    project: serviceName, fromFile: filePath, fromSymbol: null,
+                    toFile, toSymbol: null, depType: 'reexport-namespace',
+                });
+            }
+        }
+        return edges;
+    }
+    resolveFromSymbol(localName, usageMap) {
+        const users = usageMap.get(localName);
+        return users?.length === 1 ? users[0] : null;
+    }
+    buildUsageMap(sourceFile) {
+        const map = new Map();
+        const containers = [
+            ...sourceFile.getClasses().flatMap(n => n.getName() ? [{ name: n.getName(), node: n }] : []),
+            ...sourceFile.getFunctions().flatMap(n => n.getName() ? [{ name: n.getName(), node: n }] : []),
+            // include top-level variable declarations so arrow function exports are tracked for fromSymbol
+            ...sourceFile.getVariableStatements()
+                .flatMap(stmt => stmt.getDeclarations())
+                .flatMap(n => {
+                const name = n.getName();
+                return name ? [{ name, node: n }] : [];
+            }),
+        ];
+        for (const { name, node } of containers) {
+            for (const id of node.getDescendantsOfKind(ts_morph_1.SyntaxKind.Identifier)) {
+                const text = id.getText();
+                const existing = map.get(text);
+                if (existing) {
+                    if (!existing.includes(name))
+                        existing.push(name);
+                }
+                else {
+                    map.set(text, [name]);
+                }
+            }
+        }
+        return map;
+    }
+    // ── 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();
+        };
+        const getPos = (node) => {
+            const { line, character } = sourceFile.compilerNode
+                .getLineAndCharacterOfPosition(node.getStart());
+            return { line: line + 1, col: character + 1 };
+        };
+        for (const cls of sourceFile.getClasses()) {
+            const name = cls.getName();
+            if (!name)
+                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 });
+        }
+        for (const fn of sourceFile.getFunctions()) {
+            const name = fn.getName();
+            if (!name)
+                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 });
+        }
+        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 });
+        }
+        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 });
+        }
+        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 });
+            }
+        }
+        return symbols;
+    }
+}
+exports.AstParserService = AstParserService;

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

@@ -0,0 +1,14 @@
+import { EntityManager, EntityTarget, ObjectLiteral, Repository } from 'typeorm';
+import type { Config } from '../config';
+export declare class DatabaseService {
+    private config;
+    private dataSource;
+    constructor(config: Config);
+    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>;
+    destroy(): Promise<void>;
+    initDb(): Promise<void>;
+    initDbWithSchema(): Promise<void>;
+    private ensureDatabaseExists;
+}

package/dist/src/services/DatabaseService.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseService = void 0;
+const typeorm_1 = require("typeorm");
+const pg_1 = require("pg");
+const db_1 = require("../db");
+class DatabaseService {
+    config;
+    dataSource;
+    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);
+    }
+    transaction(fn) {
+        return this.dataSource.transaction(fn);
+    }
+    getRepository(entity) {
+        return this.dataSource.getRepository(entity);
+    }
+    destroy() {
+        if (!this.dataSource.isInitialized)
+            return Promise.resolve();
+        return this.dataSource.destroy();
+    }
+    async initDb() {
+        await this.dataSource.initialize();
+    }
+    async initDbWithSchema() {
+        await this.ensureDatabaseExists();
+        await this.dataSource.initialize();
+        // code_chunk table
+        const [{ exists }] = await this.dataSource.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(`
+        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")`);
+        // code_dependency table
+        const [{ existsDep }] = await this.dataSource.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(`
+        CREATE TABLE code_dependency (
+          id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+          project     TEXT NOT NULL,
+          "fromFile"  TEXT NOT NULL,
+          "fromSymbol" TEXT,
+          "toFile"    TEXT NOT NULL,
+          "toSymbol"  TEXT,
+          "depType"   TEXT NOT NULL
+        )
+      `);
+        }
+        await this.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`);
+        // code_symbol table
+        const [{ existsSym }] = await this.dataSource.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(`
+        CREATE TABLE code_symbol (
+          id        UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+          project   TEXT NOT NULL,
+          "filePath" TEXT NOT NULL,
+          name      TEXT NOT NULL,
+          kind      TEXT NOT NULL,
+          signature TEXT,
+          line      INT,
+          col       INT
+        )
+      `);
+        }
+        await this.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)`);
+    }
+    async ensureDatabaseExists() {
+        const { host, port, username, password, database } = this.config.db;
+        const client = new pg_1.Client({ host, port, user: username, password, database: 'postgres' });
+        try {
+            await client.connect();
+            const { rows } = await client.query(`SELECT 1 FROM pg_database WHERE datname = $1`, [database]);
+            if (rows.length === 0) {
+                await client.query(`CREATE DATABASE "${database}"`);
+                await client.end();
+                const extClient = new pg_1.Client({ host, port, user: username, password, database });
+                try {
+                    await extClient.connect();
+                    await extClient.query(`CREATE EXTENSION IF NOT EXISTS vector`);
+                }
+                finally {
+                    await extClient.end().catch(() => { });
+                }
+                console.log(`Created database "${database}"`);
+            }
+            else {
+                await client.end();
+            }
+        }
+        catch (err) {
+            await client.end().catch(() => { });
+            throw new Error(`Failed to ensure database "${database}" exists: ${err.message}`);
+        }
+    }
+}
+exports.DatabaseService = DatabaseService;