codesearch-mcp 0.0.15-alpha → 0.0.17-alpha

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

@@ -13,12 +13,31 @@ export interface SymbolEntry {
     kind: 'function' | 'class' | 'interface' | 'type' | 'variable' | 'method';
     signature: string | null;
     line: number | null;
+    endLine: number | null;
+    col: number | null;
+}
+export interface CallEdge {
+    project: string;
+    fromFile: string;
+    fromSymbol: string | null;
+    calleeName: string;
+    calleeFile: string;
+    calleeSymbol: string | null;
+    line: number | null;
     col: number | null;
 }
 export interface FileAnalysis {
     edges: DepEdge[];
     symbols: SymbolEntry[];
+    calls: CallEdge[];
 }
 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, opts?: {
+        skipDependencyResolution?: boolean;
+    }): Promise<Map<string, FileAnalysis>>;
+    clearCache(projectRoot?: string): void;
 }

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

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

package/dist/src/project-selector.d.ts

@@ -1,7 +1,16 @@
-export declare function selectProjects(allProjects: {
+export interface Project {
     name: string;
     path: string;
-}[], workspaceDir: string, forceSelect: boolean): Promise<{
-    name: string;
-    path: string;
-}[]>;
+}
+export declare class ProjectSelector {
+    private readonly workspaceDir;
+    private included;
+    private skipped;
+    constructor(workspaceDir: string);
+    select(allProjects: Project[], forceSelect: boolean): Promise<Project[]>;
+    private printAlreadySelected;
+    private promptForSelection;
+    private promptForSkip;
+    private load;
+    private save;
+}

package/dist/src/project-selector.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.selectProjects = selectProjects;
+exports.ProjectSelector = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const prompts_1 = require("@inquirer/prompts");
@@ -65,76 +65,90 @@ async function saveLines(filePath, names) {
         }
     }
 }
-async function loadConfig(workspaceDir) {
-    const [included, skipped] = await Promise.all([
-        loadLines(path.join(workspaceDir, '.ragprojects')),
-        loadLines(path.join(workspaceDir, '.ragskip')),
-    ]);
-    return { included, skipped };
-}
-async function saveConfig(workspaceDir, config) {
-    await Promise.all([
-        saveLines(path.join(workspaceDir, '.ragprojects'), config.included),
-        saveLines(path.join(workspaceDir, '.ragskip'), config.skipped),
-    ]);
-}
-async function selectProjects(allProjects, workspaceDir, forceSelect) {
-    const config = await loadConfig(workspaceDir);
-    const newProjects = allProjects.filter(p => !config.included.has(p.name) && !config.skipped.has(p.name));
-    // Nothing to ask — return previously saved selection silently
-    if (newProjects.length === 0 && !forceSelect) {
-        const selected = allProjects.filter(p => config.included.has(p.name));
-        if (selected.length === 0) {
-            console.log('No projects selected. Run with --select to choose projects.');
+class ProjectSelector {
+    workspaceDir;
+    included = new Set();
+    skipped = new Set();
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+    }
+    async select(allProjects, forceSelect) {
+        await this.load();
+        const newProjects = allProjects.filter(p => !this.included.has(p.name) && !this.skipped.has(p.name));
+        const previouslySelected = allProjects.filter(p => this.included.has(p.name));
+        // Nothing new and something already selected — return silently
+        if (newProjects.length === 0 && !forceSelect && previouslySelected.length > 0) {
+            return previouslySelected;
         }
+        // No previous selection — treat as implicit --select so the user picks projects now
+        const autoSelect = !forceSelect && previouslySelected.length === 0;
+        // In --select / auto-select mode show all non-skipped projects; otherwise only new ones
+        const toShow = (forceSelect || autoSelect)
+            ? allProjects.filter(p => !this.skipped.has(p.name))
+            : newProjects;
+        if (toShow.length === 0) {
+            console.log('All discovered projects are marked as skipped. Run with --select to reconfigure.');
+            return [];
+        }
+        if (!forceSelect && !autoSelect)
+            this.printAlreadySelected(allProjects);
+        await this.promptForSelection(toShow, forceSelect || autoSelect, newProjects.length);
+        await this.promptForSkip(toShow);
+        await this.save();
+        const selected = allProjects.filter(p => this.included.has(p.name));
+        console.log(`\nSelected: ${selected.map(p => p.name).join(', ') || '(none)'}`);
         return selected;
     }
-    // In --select mode show all non-skipped projects; otherwise only new ones
-    const toShow = forceSelect
-        ? allProjects.filter(p => !config.skipped.has(p.name))
-        : newProjects;
-    const alreadyIncluded = allProjects.filter(p => config.included.has(p.name));
-    if (!forceSelect && alreadyIncluded.length > 0) {
-        console.log(`Already selected (will be re-indexed): ${alreadyIncluded.map(p => p.name).join(', ')}`);
-        console.log('Run with --select to change the full selection.\n');
-    }
-    const message = forceSelect
-        ? 'Select projects to index'
-        : `Found ${newProjects.length} new project(s) — select which to add`;
-    // Checkbox: pre-check previously included projects
-    const chosen = await (0, prompts_1.checkbox)({
-        message,
-        choices: toShow.map(p => ({
-            name: p.name,
-            value: p.name,
-            checked: config.included.has(p.name),
-        })),
-        pageSize: 15,
-    });
-    const chosenSet = new Set(chosen);
-    // Update included
-    for (const p of toShow) {
-        if (chosenSet.has(p.name)) {
-            config.included.add(p.name);
-            config.skipped.delete(p.name);
+    printAlreadySelected(allProjects) {
+        const alreadyIncluded = allProjects.filter(p => this.included.has(p.name));
+        if (alreadyIncluded.length > 0) {
+            console.log(`Already selected (will be re-indexed): ${alreadyIncluded.map(p => p.name).join(', ')}`);
+            console.log('Run with --select to change the full selection.\n');
         }
-        else {
-            config.included.delete(p.name);
+    }
+    async promptForSelection(toShow, showAll, newCount) {
+        const message = showAll
+            ? 'Select projects to index'
+            : `Found ${newCount} new project(s) — select which to add`;
+        const chosen = await (0, prompts_1.checkbox)({
+            message,
+            choices: toShow.map(p => ({ name: p.name, value: p.name, checked: this.included.has(p.name) })),
+            pageSize: 15,
+        });
+        const chosenSet = new Set(chosen);
+        for (const p of toShow) {
+            if (chosenSet.has(p.name)) {
+                this.included.add(p.name);
+                this.skipped.delete(p.name);
+            }
+            else {
+                this.included.delete(p.name);
+            }
         }
     }
-    // Ask which unchecked projects to always skip
-    const unchecked = toShow.filter(p => !chosenSet.has(p.name) && !config.skipped.has(p.name));
-    if (unchecked.length > 0) {
+    async promptForSkip(toShow) {
+        const unchecked = toShow.filter(p => !this.included.has(p.name) && !this.skipped.has(p.name));
+        if (unchecked.length === 0)
+            return;
         const toSkip = await (0, prompts_1.checkbox)({
             message: 'Always skip (never ask again)?',
             choices: unchecked.map(p => ({ name: p.name, value: p.name, checked: false })),
             pageSize: 15,
         });
         for (const name of toSkip)
-            config.skipped.add(name);
+            this.skipped.add(name);
+    }
+    async load() {
+        [this.included, this.skipped] = await Promise.all([
+            loadLines(path.join(this.workspaceDir, '.ragprojects')),
+            loadLines(path.join(this.workspaceDir, '.ragskip')),
+        ]);
+    }
+    async save() {
+        await Promise.all([
+            saveLines(path.join(this.workspaceDir, '.ragprojects'), this.included),
+            saveLines(path.join(this.workspaceDir, '.ragskip'), this.skipped),
+        ]);
     }
-    await saveConfig(workspaceDir, config);
-    const selected = allProjects.filter(p => config.included.has(p.name));
-    console.log(`\nSelected: ${selected.map(p => p.name).join(', ') || '(none)'}`);
-    return selected;
 }
+exports.ProjectSelector = ProjectSelector;

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

@@ -4,11 +4,18 @@ export declare class AstParserService implements IAstParser {
     private logger;
     private morphProjects;
     constructor(logger?: LoggerService);
+    analyzeProject(filePaths: string[], serviceName: string, projectRoot?: string, opts?: {
+        skipDependencyResolution?: boolean;
+    }): 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;
     private buildUsageMap;
     private extractSymbols;
+    private extractCalls;
+    private getContainerName;
 }

package/dist/src/services/AstParserService.js

@@ -51,9 +51,64 @@ class AstParserService {
         this.logger = logger;
     }
     // ── public interface ────────────────────────────────────────────────────────
+    async analyzeProject(filePaths, serviceName, projectRoot = process.cwd(), opts = {}) {
+        const t0 = Date.now();
+        const skipDependencyResolution = opts.skipDependencyResolution ?? false;
+        this.logger.debug('AstParser: analyzeProject start', { serviceName, projectRoot, files: filePaths.length, skipDependencyResolution });
+        const analysisMap = new Map();
+        const morphProject = this.createMorphProject(projectRoot, skipDependencyResolution);
+        for (const filePath of filePaths) {
+            if (!/\.(ts|tsx|js|jsx)$/.test(filePath) || /\.d\.ts$/.test(filePath)) {
+                analysisMap.set(filePath, { edges: [], symbols: [], calls: [] });
+                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: [], calls: [] });
+            }
+        }
+        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);
+                const calls = this.extractCalls(sourceFile, filePath, serviceName);
+                analysisMap.set(filePath, { edges, symbols, calls });
+            }
+            catch (err) {
+                this.logger.warn('AstParser: failed to analyze file', { filePath, reason: err.message });
+                analysisMap.set(filePath, { edges: [], symbols: [], calls: [] });
+            }
+        }
+        // Release source file memory before returning
+        for (const sourceFile of morphProject.getSourceFiles()) {
+            morphProject.removeSourceFile(sourceFile);
+        }
+        this.logger.debug('AstParser: analyzeProject done', {
+            serviceName, projectRoot, total: filePaths.length, parsed: analysisMap.size, skipDependencyResolution, 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)) {
+        const t0 = Date.now();
+        this.logger.debug('AstParser: analyzeFile start', { filePath, serviceName, projectRoot });
         if (!/\.(ts|tsx|js|jsx)$/.test(filePath) || /\.d\.ts$/.test(filePath)) {
-            return { edges: [], symbols: [] };
+            this.logger.debug('AstParser: analyzeFile skip (non-TS)', { filePath, ms: Date.now() - t0 });
+            return { edges: [], symbols: [], calls: [] };
         }
         const morphProject = this.getMorphProject(projectRoot);
         const existing = morphProject.getSourceFile(filePath);
@@ -63,13 +118,16 @@ class AstParserService {
         try {
             sourceFile = morphProject.addSourceFileAtPath(filePath);
         }
-        catch {
-            return { edges: [], symbols: [] };
+        catch (err) {
+            this.logger.warn('AstParser: analyzeFile failed to add source file', { filePath, reason: err.message, ms: Date.now() - t0 });
+            return { edges: [], symbols: [], calls: [] };
         }
         const edges = this.extractEdges(sourceFile, filePath, serviceName);
         const symbols = this.extractSymbols(sourceFile, filePath, serviceName);
+        const calls = this.extractCalls(sourceFile, filePath, serviceName);
         morphProject.removeSourceFile(sourceFile);
-        return { edges, symbols };
+        this.logger.debug('AstParser: analyzeFile done', { filePath, edges: edges.length, symbols: symbols.length, calls: calls.length, ms: Date.now() - t0 });
+        return { edges, symbols, calls };
     }
     // Kept for test compatibility (extract-import-edges.test.ts).
     async extractImportEdges(filePath, serviceName, projectRoot) {
@@ -77,46 +135,57 @@ 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, skipFileDependencyResolution = false) {
+        const t0 = Date.now();
         const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
         const hasTsconfig = fs.existsSync(tsconfigPath);
-        this.logger.debug('AstParser: tsconfig lookup', { projectRoot, found: hasTsconfig });
+        this.logger.debug('AstParser: tsconfig lookup', { projectRoot, found: hasTsconfig, skipFileDependencyResolution });
         let project;
         try {
             const opts = hasTsconfig
-                ? { tsConfigFilePath: tsconfigPath, skipAddingFilesFromTsConfig: true, skipFileDependencyResolution: false }
-                : FALLBACK_OPTS;
+                ? { tsConfigFilePath: tsconfigPath, skipAddingFilesFromTsConfig: true, skipFileDependencyResolution }
+                : { ...FALLBACK_OPTS, skipFileDependencyResolution };
             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 });
+                this.logger.debug('AstParser: tsconfig loaded', { pathCount, ms: Date.now() - t0 });
                 if (pathCount > 0) {
                     this.logger.debug('AstParser: path aliases', { aliases: Object.keys(pathsMap) });
                 }
             }
+            else {
+                this.logger.debug('AstParser: MorphProject created (fallback opts)', { ms: Date.now() - t0 });
+            }
         }
         catch (err) {
             this.logger.warn('AstParser: tsconfig load failed, using fallback', {
                 tsconfigPath,
                 reason: err.message,
+                ms: Date.now() - t0,
             });
             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);
+            this.logger.debug('AstParser: getMorphProject cache hit', { projectRoot, cacheSize: this.morphProjects.size });
+            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 });
+        }
+        this.logger.debug('AstParser: getMorphProject cache miss', { projectRoot, cacheSize: this.morphProjects.size });
+        const project = this.createMorphProject(projectRoot);
         this.morphProjects.set(projectRoot, project);
         return project;
     }
@@ -223,7 +292,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 +307,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,23 +319,114 @@ 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;
     }
+    // ── private: call graph extraction ────────────────────────────────────────
+    extractCalls(sourceFile, filePath, serviceName) {
+        const calls = [];
+        for (const callExpr of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)) {
+            const expr = callExpr.getExpression();
+            let calleeName = null;
+            let calleeFile = null;
+            let calleeSymbol = null;
+            try {
+                if (ts_morph_1.Node.isPropertyAccessExpression(expr)) {
+                    calleeName = expr.getName();
+                    const sym = expr.getNameNode().getSymbol();
+                    const decl = sym?.getDeclarations()?.[0];
+                    const declPath = decl?.getSourceFile().getFilePath();
+                    if (declPath && !declPath.includes('/node_modules/') && declPath !== filePath) {
+                        calleeFile = declPath;
+                        calleeSymbol = calleeName;
+                    }
+                }
+                else if (ts_morph_1.Node.isIdentifier(expr)) {
+                    calleeName = expr.getText();
+                    const sym = expr.getSymbol();
+                    if (sym) {
+                        // Imported identifiers resolve to ImportSpecifier (same file); follow the alias.
+                        const firstDecl = sym.getDeclarations()?.[0];
+                        const resolved = firstDecl && ts_morph_1.Node.isImportSpecifier(firstDecl)
+                            ? (sym.getAliasedSymbol() ?? sym)
+                            : sym;
+                        const decl = resolved.getDeclarations()?.[0];
+                        const declPath = decl?.getSourceFile().getFilePath();
+                        if (declPath && !declPath.includes('/node_modules/') && declPath !== filePath) {
+                            calleeFile = declPath;
+                            calleeSymbol = calleeName;
+                        }
+                    }
+                }
+            }
+            catch {
+                // type resolution failures are normal — skip this call
+            }
+            if (!calleeName || !calleeFile)
+                continue;
+            const fromSymbol = this.getContainerName(callExpr);
+            const pos = sourceFile.compilerNode
+                .getLineAndCharacterOfPosition(callExpr.getStart());
+            calls.push({
+                project: serviceName,
+                fromFile: filePath,
+                fromSymbol,
+                calleeName,
+                calleeFile,
+                calleeSymbol,
+                line: pos.line + 1,
+                col: pos.character + 1,
+            });
+        }
+        return calls;
+    }
+    getContainerName(node) {
+        let current = node.getParent();
+        while (current) {
+            if (ts_morph_1.Node.isMethodDeclaration(current) || ts_morph_1.Node.isFunctionDeclaration(current)) {
+                return current.getName() ?? null;
+            }
+            if (ts_morph_1.Node.isArrowFunction(current) || ts_morph_1.Node.isFunctionExpression(current)) {
+                const parent = current.getParent();
+                if (ts_morph_1.Node.isVariableDeclaration(parent))
+                    return parent.getName();
+                if (ts_morph_1.Node.isPropertyDeclaration(parent))
+                    return parent.getName();
+            }
+            current = current.getParent();
+        }
+        return null;
+    }
 }
 exports.AstParserService = AstParserService;

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