codesearch-mcp 0.0.8-alpha → 0.0.10-alpha

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;

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

@@ -0,0 +1,39 @@
+import type { Config } from '../config';
+import type { IEmbedder } from '../interfaces/IEmbedder';
+import type { IAstParser } from '../interfaces/IAstParser';
+import type { DatabaseService } from './DatabaseService';
+import { LoggerService } from './LoggerService';
+export interface IndexStats {
+    serviceName: string;
+    indexed: number;
+    skipped: number;
+    failed: number;
+    chunks: number;
+    elapsedSec: number;
+    warnings: string[];
+}
+export declare class IndexerService {
+    private db;
+    private embedder;
+    private ast;
+    private config;
+    private logger;
+    private readonly jsSplitter;
+    private readonly schemaSplitter;
+    constructor(db: DatabaseService, embedder: IEmbedder, ast: IAstParser, config: Config, logger?: LoggerService);
+    backfillSymbols(signal?: AbortSignal): Promise<{
+        total: number;
+        processed: number;
+        skipped: number;
+        failed: number;
+    }>;
+    discoverProjects(rootDir: string): {
+        name: string;
+        path: string;
+    }[];
+    private writeDepEdges;
+    scanAndIndex(dir: string, serviceName: string, force?: boolean, signal?: AbortSignal, preCollectedFiles?: string[]): Promise<IndexStats>;
+    private getSplitter;
+    private embedText;
+    private ingestFile;
+}