archicore 0.1.0

package/dist/cli.js

@@ -0,0 +1,295 @@
+#!/usr/bin/env node
+/**
+ * ArchiCore CLI
+ *
+ * AI Software Architect - Interactive CLI
+ */
+import 'dotenv/config';
+import { Command } from 'commander';
+import { AIArhitector } from './index.js';
+import { Logger, LogLevel } from './utils/logger.js';
+import chalk from 'chalk';
+import ora from 'ora';
+import { writeFile } from 'fs/promises';
+// Import new CLI modules
+import { registerAnalyzerCommands, registerExportCommand, startInteractiveMode, initProject, } from './cli/index.js';
+const program = new Command();
+program
+    .name('archicore')
+    .description('ArchiCore - AI Software Architect')
+    .version('0.1.0');
+// Init command - initialize project in current directory
+program
+    .command('init')
+    .description('Initialize ArchiCore in current directory')
+    .option('-n, --name <name>', 'Project name')
+    .action(async (options) => {
+    await initProject(process.cwd(), options.name);
+});
+// Register modular commands
+registerAnalyzerCommands(program);
+registerExportCommand(program);
+// Interactive mode (default when no command)
+program
+    .command('chat', { isDefault: false })
+    .description('Start interactive mode')
+    .action(async () => {
+    await startInteractiveMode();
+});
+// Legacy commands (keeping for backwards compatibility)
+program
+    .command('index')
+    .description('Index a project (legacy)')
+    .option('-d, --dir <directory>', 'Project directory', process.cwd())
+    .option('-v, --verbose', 'Verbose output')
+    .action(async (options) => {
+    if (options.verbose) {
+        Logger.setLevel(LogLevel.DEBUG);
+    }
+    const spinner = ora('Initializing AIArhitector...').start();
+    try {
+        const ai = new AIArhitector({
+            rootDir: options.dir,
+            llm: {
+                provider: 'deepseek',
+                model: 'deepseek-chat',
+                temperature: 0.1,
+                maxTokens: 4096
+            },
+            vectorStore: {
+                url: process.env.QDRANT_URL || 'http://localhost:6333',
+                apiKey: process.env.QDRANT_API_KEY,
+                collectionName: 'aiarhitector'
+            }
+        });
+        spinner.text = 'Indexing project...';
+        await ai.initialize();
+        const stats = ai.getStatistics();
+        spinner.succeed('Project indexed!');
+        console.log(chalk.green('\n📊 Statistics:\n'));
+        console.log(`  Files: ${stats.codeIndex.totalFiles}`);
+        console.log(`  Symbols: ${stats.codeIndex.totalSymbols}`);
+        console.log(`  Nodes: ${stats.codeIndex.totalNodes}`);
+        console.log(`  Edges: ${stats.codeIndex.totalEdges}`);
+        console.log(chalk.cyan('\n🔤 Symbols by kind:\n'));
+        for (const [kind, count] of Object.entries(stats.codeIndex.symbolsByKind)) {
+            console.log(`  ${kind}: ${count}`);
+        }
+        const memStats = await stats.semanticMemory;
+        if (memStats) {
+            console.log(chalk.magenta('\n🧠 Semantic memory:\n'));
+            console.log(`  Vectors: ${memStats.vectorsCount}`);
+            console.log(`  Points: ${memStats.pointsCount}`);
+        }
+    }
+    catch (error) {
+        spinner.fail('Indexing error');
+        Logger.error('Error', error);
+        process.exit(1);
+    }
+});
+program
+    .command('analyze')
+    .description('Analyze impact of changes (legacy)')
+    .requiredOption('-d, --description <desc>', 'Change description')
+    .option('--files <files>', 'Files (comma-separated)')
+    .option('--symbols <symbols>', 'Symbols (comma-separated)')
+    .option('--type <type>', 'Change type (add|modify|delete|refactor)', 'modify')
+    .option('--output <file>', 'Output file')
+    .action(async (options) => {
+    const spinner = ora('Analyzing impact...').start();
+    try {
+        const ai = new AIArhitector({
+            rootDir: process.cwd(),
+            llm: {
+                provider: 'deepseek',
+                model: 'deepseek-chat',
+                temperature: 0.1,
+                maxTokens: 4096
+            },
+            vectorStore: {
+                url: process.env.QDRANT_URL || 'http://localhost:6333',
+                apiKey: process.env.QDRANT_API_KEY,
+                collectionName: 'aiarhitector'
+            }
+        });
+        spinner.text = 'Loading index...';
+        await ai.initialize();
+        const change = {
+            type: options.type,
+            description: options.description,
+            files: options.files ? options.files.split(',') : [],
+            symbols: options.symbols ? options.symbols.split(',') : []
+        };
+        spinner.text = 'Analyzing...';
+        const impact = await ai.analyzeChange(change);
+        spinner.succeed('Analysis complete!');
+        console.log(chalk.bold('\n📋 IMPACT ANALYSIS REPORT\n'));
+        console.log(chalk.yellow('⚠ AFFECTED COMPONENTS:\n'));
+        console.log(`  Total: ${impact.affectedNodes.length}`);
+        const byLevel = {
+            critical: impact.affectedNodes.filter(n => n.impactLevel === 'critical'),
+            high: impact.affectedNodes.filter(n => n.impactLevel === 'high'),
+            medium: impact.affectedNodes.filter(n => n.impactLevel === 'medium'),
+            low: impact.affectedNodes.filter(n => n.impactLevel === 'low')
+        };
+        console.log(`  🔴 Critical: ${byLevel.critical.length}`);
+        console.log(`  🟠 High: ${byLevel.high.length}`);
+        console.log(`  🟡 Medium: ${byLevel.medium.length}`);
+        console.log(`  🟢 Low: ${byLevel.low.length}`);
+        if (byLevel.critical.length > 0) {
+            console.log(chalk.red('\n🔴 CRITICAL COMPONENTS:\n'));
+            for (const node of byLevel.critical.slice(0, 10)) {
+                console.log(`  - ${node.name} (${node.filePath})`);
+                console.log(`    ${node.reason}`);
+            }
+        }
+        console.log(chalk.red('\n⚠ RISKS:\n'));
+        for (const risk of impact.risks) {
+            console.log(`  [${risk.severity.toUpperCase()}] ${risk.description}`);
+            if (risk.mitigation) {
+                console.log(`  💡 ${risk.mitigation}`);
+            }
+            console.log('');
+        }
+        console.log(chalk.blue('\n✅ RECOMMENDATIONS:\n'));
+        for (const rec of impact.recommendations) {
+            console.log(`  [${rec.priority.toUpperCase()}] ${rec.description}`);
+            if (rec.details) {
+                console.log(`  ${rec.details}`);
+            }
+            console.log('');
+        }
+        if (options.output) {
+            const report = {
+                change,
+                impact,
+                timestamp: new Date().toISOString()
+            };
+            await writeFile(options.output, JSON.stringify(report, null, 2));
+            console.log(chalk.green(`\n✓ Report saved: ${options.output}`));
+        }
+    }
+    catch (error) {
+        spinner.fail('Analysis error');
+        Logger.error('Error', error);
+        process.exit(1);
+    }
+});
+program
+    .command('search')
+    .description('Semantic code search (legacy)')
+    .requiredOption('-q, --query <query>', 'Search query')
+    .option('-l, --limit <limit>', 'Number of results', '10')
+    .action(async (options) => {
+    const spinner = ora('Searching...').start();
+    try {
+        const ai = new AIArhitector({
+            rootDir: process.cwd(),
+            llm: {
+                provider: 'deepseek',
+                model: 'deepseek-chat',
+                temperature: 0.1,
+                maxTokens: 4096
+            },
+            vectorStore: {
+                url: process.env.QDRANT_URL || 'http://localhost:6333',
+                apiKey: process.env.QDRANT_API_KEY,
+                collectionName: 'aiarhitector'
+            }
+        });
+        await ai.initialize();
+        spinner.text = 'Executing search...';
+        const results = await ai.searchCode(options.query, parseInt(options.limit));
+        spinner.succeed(`Found ${results.length} results`);
+        console.log(chalk.bold('\n🔍 SEARCH RESULTS:\n'));
+        for (const [index, result] of results.entries()) {
+            console.log(chalk.cyan(`${index + 1}. ${result.chunk.metadata.filePath}:${result.chunk.metadata.startLine}`));
+            console.log(`   Relevance: ${(result.score * 100).toFixed(2)}%`);
+            console.log(`   ${result.context}\n`);
+        }
+    }
+    catch (error) {
+        spinner.fail('Search error');
+        Logger.error('Error', error);
+        process.exit(1);
+    }
+});
+program
+    .command('ask')
+    .description('Ask about architecture (legacy)')
+    .requiredOption('-q, --question <question>', 'Question')
+    .action(async (options) => {
+    const spinner = ora('Analyzing...').start();
+    try {
+        const ai = new AIArhitector({
+            rootDir: process.cwd(),
+            llm: {
+                provider: 'deepseek',
+                model: 'deepseek-chat',
+                temperature: 0.3,
+                maxTokens: 4096
+            },
+            vectorStore: {
+                url: process.env.QDRANT_URL || 'http://localhost:6333',
+                apiKey: process.env.QDRANT_API_KEY,
+                collectionName: 'aiarhitector'
+            }
+        });
+        await ai.initialize();
+        spinner.text = 'Getting AI response...';
+        const answer = await ai.askQuestion(options.question);
+        spinner.succeed('Answer received!');
+        console.log(chalk.bold('\n💬 AI ARCHITECT:\n'));
+        console.log(answer);
+    }
+    catch (error) {
+        spinner.fail('Error');
+        Logger.error('Error', error);
+        process.exit(1);
+    }
+});
+program
+    .command('docs')
+    .description('Generate documentation (legacy)')
+    .option('-o, --output <file>', 'Output file', 'ARCHITECTURE.md')
+    .action(async (options) => {
+    const spinner = ora('Generating documentation...').start();
+    try {
+        const ai = new AIArhitector({
+            rootDir: process.cwd(),
+            llm: {
+                provider: 'deepseek',
+                model: 'deepseek-chat',
+                temperature: 0.3,
+                maxTokens: 8192
+            },
+            vectorStore: {
+                url: process.env.QDRANT_URL || 'http://localhost:6333',
+                apiKey: process.env.QDRANT_API_KEY,
+                collectionName: 'aiarhitector'
+            }
+        });
+        await ai.initialize();
+        spinner.text = 'Generating documentation...';
+        const docs = await ai.generateDocumentation();
+        await writeFile(options.output, docs);
+        spinner.succeed(`Documentation saved: ${options.output}`);
+    }
+    catch (error) {
+        spinner.fail('Documentation generation error');
+        Logger.error('Error', error);
+        process.exit(1);
+    }
+});
+// Handle no command - start interactive mode
+if (process.argv.length === 2) {
+    startInteractiveMode().catch((error) => {
+        console.error('Failed to start interactive mode:', error);
+        process.exit(1);
+    });
+}
+else {
+    program.parse();
+}
+//# sourceMappingURL=cli.js.map

package/dist/code-index/ast-parser.d.ts

@@ -0,0 +1,16 @@
+import Parser from 'tree-sitter';
+import { ASTNode, Location } from '../types/index.js';
+export declare class ASTParser {
+    private parsers;
+    constructor();
+    private initializeParsers;
+    parseFile(filePath: string): Promise<ASTNode | null>;
+    private parseWithRegex;
+    private inferTypeFromPattern;
+    private extractVueScript;
+    parseProject(rootDir: string): Promise<Map<string, ASTNode>>;
+    private convertToASTNode;
+    private extractName;
+    extractLocation(node: Parser.SyntaxNode, filePath: string): Location;
+}
+//# sourceMappingURL=ast-parser.d.ts.map

package/dist/code-index/ast-parser.js

@@ -0,0 +1,330 @@
+import Parser from 'tree-sitter';
+import TypeScript from 'tree-sitter-typescript';
+import JavaScript from 'tree-sitter-javascript';
+import Python from 'tree-sitter-python';
+import { FileUtils } from '../utils/file-utils.js';
+import { Logger } from '../utils/logger.js';
+// Tree-sitter has a ~32KB limit for parsing
+const MAX_TREE_SITTER_SIZE = 30000;
+export class ASTParser {
+    parsers;
+    constructor() {
+        this.parsers = new Map();
+        this.initializeParsers();
+    }
+    initializeParsers() {
+        const tsParser = new Parser();
+        tsParser.setLanguage(TypeScript.typescript);
+        this.parsers.set('typescript', tsParser);
+        const jsParser = new Parser();
+        jsParser.setLanguage(JavaScript);
+        this.parsers.set('javascript', jsParser);
+        const pyParser = new Parser();
+        pyParser.setLanguage(Python);
+        this.parsers.set('python', pyParser);
+        Logger.debug('AST parsers initialized');
+    }
+    async parseFile(filePath) {
+        try {
+            let content = await FileUtils.readFileContent(filePath);
+            let language = FileUtils.getLanguageFromExtension(filePath);
+            // Vue SFC: extract <script> section and parse as TS/JS
+            if (language === 'vue') {
+                const scriptResult = this.extractVueScript(content);
+                if (!scriptResult) {
+                    return null; // No script section found
+                }
+                content = scriptResult.content;
+                language = scriptResult.isTypeScript ? 'typescript' : 'javascript';
+            }
+            // Validate content before parsing
+            if (!content || typeof content !== 'string' || !content.trim()) {
+                Logger.warn(`Empty or invalid content in: ${filePath}`);
+                return null;
+            }
+            // For large files, use regex-based fallback
+            if (content.length > MAX_TREE_SITTER_SIZE) {
+                Logger.debug(`Large file (${content.length} bytes), using regex fallback: ${filePath}`);
+                return this.parseWithRegex(content, filePath, language);
+            }
+            const parser = this.parsers.get(language);
+            if (!parser) {
+                // Use regex fallback for unsupported languages
+                return this.parseWithRegex(content, filePath, language);
+            }
+            const tree = parser.parse(content);
+            return this.convertToASTNode(tree.rootNode, filePath);
+        }
+        catch (error) {
+            // Try regex fallback on parse error
+            try {
+                const content = await FileUtils.readFileContent(filePath);
+                const language = FileUtils.getLanguageFromExtension(filePath);
+                Logger.debug(`Tree-sitter failed, using regex fallback: ${filePath}`);
+                return this.parseWithRegex(content, filePath, language);
+            }
+            catch {
+                Logger.error(`Failed to parse ${filePath}`, error);
+                return null;
+            }
+        }
+    }
+    // Regex-based fallback for large files or unsupported languages
+    parseWithRegex(content, filePath, language) {
+        const children = [];
+        const lines = content.split('\n');
+        // Patterns for different languages
+        const patterns = {
+            javascript: [
+                /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/,
+                /^(?:export\s+)?class\s+(\w+)/,
+                /^(?:export\s+)?const\s+(\w+)\s*=/,
+                /^(?:export\s+)?let\s+(\w+)\s*=/,
+                /(\w+)\s*[=:]\s*(?:async\s+)?\([^)]*\)\s*(?:=>|{)/,
+                /(\w+)\s*\([^)]*\)\s*{/
+            ],
+            typescript: [
+                /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/,
+                /^(?:export\s+)?class\s+(\w+)/,
+                /^(?:export\s+)?interface\s+(\w+)/,
+                /^(?:export\s+)?type\s+(\w+)\s*=/,
+                /^(?:export\s+)?const\s+(\w+)\s*[=:]/,
+                /^(?:export\s+)?enum\s+(\w+)/,
+                /(\w+)\s*[=:]\s*(?:async\s+)?\([^)]*\)\s*(?:=>|{)/,
+                /(\w+)\s*\([^)]*\)\s*(?::\s*\w+)?\s*{/
+            ],
+            python: [
+                /^(?:async\s+)?def\s+(\w+)/,
+                /^class\s+(\w+)/
+            ],
+            vue: [
+                /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/,
+                /^(?:export\s+)?const\s+(\w+)\s*=/,
+                /(\w+)\s*[=:]\s*(?:async\s+)?\([^)]*\)\s*(?:=>|{)/,
+                /(\w+)\s*\([^)]*\)\s*{/
+            ],
+            go: [
+                /^func\s+(?:\([^)]+\)\s+)?(\w+)/,
+                /^type\s+(\w+)\s+(?:struct|interface)/
+            ],
+            rust: [
+                /^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/,
+                /^(?:pub\s+)?struct\s+(\w+)/,
+                /^(?:pub\s+)?enum\s+(\w+)/,
+                /^(?:pub\s+)?trait\s+(\w+)/,
+                /^impl(?:<[^>]+>)?\s+(\w+)/
+            ],
+            java: [
+                /^(?:public|private|protected)?\s*(?:static\s+)?(?:final\s+)?class\s+(\w+)/,
+                /^(?:public|private|protected)?\s*(?:static\s+)?(?:final\s+)?interface\s+(\w+)/,
+                /^(?:public|private|protected)?\s*(?:static\s+)?(?:final\s+)?(?:\w+\s+)+(\w+)\s*\(/
+            ],
+            php: [
+                /^(?:public|private|protected)?\s*(?:static\s+)?function\s+(\w+)/,
+                /^class\s+(\w+)/,
+                /^interface\s+(\w+)/,
+                /^trait\s+(\w+)/
+            ],
+            ruby: [
+                /^def\s+(\w+)/,
+                /^class\s+(\w+)/,
+                /^module\s+(\w+)/
+            ],
+            csharp: [
+                /^(?:public|private|protected|internal)?\s*(?:static\s+)?(?:partial\s+)?class\s+(\w+)/,
+                /^(?:public|private|protected|internal)?\s*interface\s+(\w+)/,
+                /^(?:public|private|protected|internal)?\s*(?:static\s+)?(?:async\s+)?(?:\w+\s+)+(\w+)\s*\(/
+            ],
+            cpp: [
+                /^(?:class|struct)\s+(\w+)/,
+                /^(?:\w+\s+)*(\w+)\s*\([^)]*\)\s*(?:const)?\s*(?:override)?\s*{/,
+                /^namespace\s+(\w+)/
+            ],
+            c: [
+                /^(?:\w+\s+)*(\w+)\s*\([^)]*\)\s*{/,
+                /^struct\s+(\w+)/,
+                /^typedef\s+.*\s+(\w+)\s*;/
+            ]
+        };
+        const langPatterns = patterns[language] || patterns.javascript;
+        lines.forEach((line, index) => {
+            const trimmedLine = line.trim();
+            for (const pattern of langPatterns) {
+                const match = trimmedLine.match(pattern);
+                if (match && match[1]) {
+                    const name = match[1];
+                    // Skip common false positives
+                    if (['if', 'else', 'for', 'while', 'switch', 'catch', 'try', 'return', 'new', 'throw'].includes(name)) {
+                        continue;
+                    }
+                    const type = this.inferTypeFromPattern(pattern, language);
+                    children.push({
+                        id: `${filePath}:${name}:${index}`,
+                        type,
+                        name,
+                        filePath,
+                        startLine: index,
+                        endLine: index,
+                        children: [],
+                        metadata: {
+                            text: trimmedLine.substring(0, 200),
+                            hasErrors: false,
+                            regexParsed: true
+                        }
+                    });
+                    break; // One match per line
+                }
+            }
+        });
+        return {
+            id: `${filePath}:0:0`,
+            type: 'program',
+            name: filePath.split(/[/\\]/).pop() || '',
+            filePath,
+            startLine: 0,
+            endLine: lines.length,
+            children,
+            metadata: {
+                text: `File: ${filePath}`,
+                hasErrors: false,
+                regexParsed: true,
+                symbolCount: children.length
+            }
+        };
+    }
+    inferTypeFromPattern(pattern, _language) {
+        const patternStr = pattern.source;
+        if (patternStr.includes('class'))
+            return 'class_declaration';
+        if (patternStr.includes('interface'))
+            return 'interface_declaration';
+        if (patternStr.includes('function') || patternStr.includes('def') || patternStr.includes('fn'))
+            return 'function_declaration';
+        if (patternStr.includes('type') || patternStr.includes('enum'))
+            return 'type_alias_declaration';
+        if (patternStr.includes('struct'))
+            return 'struct_declaration';
+        if (patternStr.includes('trait'))
+            return 'trait_declaration';
+        if (patternStr.includes('const') || patternStr.includes('let'))
+            return 'variable_declaration';
+        if (patternStr.includes('module') || patternStr.includes('namespace'))
+            return 'module_declaration';
+        if (patternStr.includes('impl'))
+            return 'impl_declaration';
+        return 'function_declaration';
+    }
+    extractVueScript(content) {
+        // Find script blocks - there may be multiple (setup + regular)
+        // We want the main script block, not script setup (which uses different syntax)
+        const scriptRegex = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
+        let match;
+        let bestMatch = null;
+        while ((match = scriptRegex.exec(content)) !== null) {
+            const attrs = match[1] || '';
+            const scriptContent = match[2] || '';
+            // Skip empty scripts
+            if (!scriptContent.trim())
+                continue;
+            // Prefer non-setup script, but take setup if it's the only one
+            const isSetup = /\bsetup\b/i.test(attrs);
+            if (!bestMatch || !isSetup) {
+                bestMatch = { attrs, content: scriptContent };
+                // If this is a regular (non-setup) script with content, use it
+                if (!isSetup)
+                    break;
+            }
+        }
+        if (!bestMatch || !bestMatch.content.trim()) {
+            return null;
+        }
+        // Check if TypeScript
+        const isTypeScript = /lang\s*=\s*["']ts["']/.test(bestMatch.attrs) ||
+            /lang\s*=\s*["']typescript["']/.test(bestMatch.attrs);
+        return {
+            content: bestMatch.content.trim(),
+            isTypeScript
+        };
+    }
+    async parseProject(rootDir) {
+        const files = await FileUtils.getAllFiles(rootDir);
+        const asts = new Map();
+        Logger.progress(`Parsing ${files.length} files...`);
+        for (const file of files) {
+            const ast = await this.parseFile(file);
+            if (ast) {
+                asts.set(file, ast);
+            }
+        }
+        Logger.success(`Parsed ${asts.size} files successfully`);
+        return asts;
+    }
+    convertToASTNode(node, filePath) {
+        const children = [];
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child) {
+                children.push(this.convertToASTNode(child, filePath));
+            }
+        }
+        return {
+            id: `${filePath}:${node.startPosition.row}:${node.startPosition.column}`,
+            type: node.type,
+            name: this.extractName(node),
+            filePath,
+            startLine: node.startPosition.row,
+            endLine: node.endPosition.row,
+            children,
+            metadata: {
+                text: node.text.length > 200 ? node.text.substring(0, 200) + '...' : node.text,
+                hasErrors: node.hasError
+            }
+        };
+    }
+    extractName(node) {
+        // Try field name first (works for most languages)
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+            return nameNode.text;
+        }
+        // Python: decorated_definition has the actual definition as child
+        if (node.type === 'decorated_definition') {
+            const defNode = node.children.find(c => c.type === 'function_definition' || c.type === 'class_definition');
+            if (defNode) {
+                const innerName = defNode.childForFieldName('name');
+                if (innerName)
+                    return innerName.text;
+            }
+        }
+        const interestingTypes = [
+            // JS/TS
+            'function_declaration',
+            'class_declaration',
+            'interface_declaration',
+            'type_alias_declaration',
+            'variable_declaration',
+            // Python
+            'function_definition',
+            'class_definition',
+            'async_function_definition'
+        ];
+        if (interestingTypes.includes(node.type)) {
+            // Try to extract name from text
+            const match = node.text.match(/(?:def|class|function|async\s+def)\s+(\w+)/);
+            if (match)
+                return match[1];
+            return node.text.split(/[\s({:]/)[1] || 'anonymous';
+        }
+        return '';
+    }
+    extractLocation(node, filePath) {
+        return {
+            filePath,
+            startLine: node.startPosition.row,
+            endLine: node.endPosition.row,
+            startColumn: node.startPosition.column,
+            endColumn: node.endPosition.column
+        };
+    }
+}
+//# sourceMappingURL=ast-parser.js.map

package/dist/code-index/dependency-graph.d.ts

@@ -0,0 +1,16 @@
+import { DependencyGraph, Symbol, ASTNode } from '../types/index.js';
+export declare class DependencyGraphBuilder {
+    buildGraph(symbols: Map<string, Symbol>, asts: Map<string, ASTNode>): DependencyGraph;
+    private buildNodes;
+    private buildEdges;
+    private addEdge;
+    private findSymbolsBySource;
+    private findSymbolAtLocation;
+    private getFileName;
+    private estimateComplexity;
+    private countEdges;
+    findDependents(graph: DependencyGraph, nodeId: string): Set<string>;
+    findDependencies(graph: DependencyGraph, nodeId: string): Set<string>;
+    getTransitiveDependencies(graph: DependencyGraph, nodeId: string, maxDepth?: number): Set<string>;
+}
+//# sourceMappingURL=dependency-graph.d.ts.map