archicore 0.1.0

package/dist/code-index/dependency-graph.js

@@ -0,0 +1,161 @@
+import { EdgeType } from '../types/index.js';
+import { Logger } from '../utils/logger.js';
+export class DependencyGraphBuilder {
+    buildGraph(symbols, asts) {
+        Logger.progress('Building dependency graph...');
+        const graph = {
+            nodes: new Map(),
+            edges: new Map()
+        };
+        this.buildNodes(symbols, asts, graph);
+        this.buildEdges(symbols, graph);
+        Logger.success(`Dependency graph built: ${graph.nodes.size} nodes, ${this.countEdges(graph)} edges`);
+        return graph;
+    }
+    buildNodes(symbols, asts, graph) {
+        for (const [filePath, ast] of asts) {
+            const fileNode = {
+                id: filePath,
+                type: 'file',
+                filePath,
+                name: this.getFileName(filePath),
+                metadata: {
+                    linesOfCode: ast.endLine - ast.startLine,
+                    complexity: this.estimateComplexity(ast)
+                }
+            };
+            graph.nodes.set(filePath, fileNode);
+        }
+        for (const symbol of symbols.values()) {
+            const node = {
+                id: symbol.id,
+                type: symbol.kind === 'function' ? 'function' : 'class',
+                filePath: symbol.filePath,
+                name: symbol.name,
+                metadata: {}
+            };
+            graph.nodes.set(symbol.id, node);
+        }
+    }
+    buildEdges(symbols, graph) {
+        for (const symbol of symbols.values()) {
+            if (!symbol.imports)
+                continue;
+            for (const imp of symbol.imports) {
+                const targetSymbols = this.findSymbolsBySource(symbols, imp.source);
+                for (const targetSymbol of targetSymbols) {
+                    const edge = {
+                        from: symbol.id,
+                        to: targetSymbol.id,
+                        type: EdgeType.Import,
+                        weight: 1
+                    };
+                    this.addEdge(graph, edge);
+                }
+            }
+            for (const ref of symbol.references) {
+                if (ref.kind === 'call') {
+                    const targetSymbol = this.findSymbolAtLocation(symbols, ref.location.filePath, ref.location.startLine);
+                    if (targetSymbol) {
+                        const edge = {
+                            from: symbol.id,
+                            to: targetSymbol.id,
+                            type: EdgeType.Call,
+                            weight: 1
+                        };
+                        this.addEdge(graph, edge);
+                    }
+                }
+            }
+        }
+    }
+    addEdge(graph, edge) {
+        if (!graph.edges.has(edge.from)) {
+            graph.edges.set(edge.from, []);
+        }
+        graph.edges.get(edge.from).push(edge);
+    }
+    findSymbolsBySource(symbols, source) {
+        const results = [];
+        for (const symbol of symbols.values()) {
+            if (symbol.filePath.includes(source)) {
+                results.push(symbol);
+            }
+        }
+        return results;
+    }
+    findSymbolAtLocation(symbols, filePath, line) {
+        for (const symbol of symbols.values()) {
+            if (symbol.filePath === filePath &&
+                symbol.location.startLine <= line &&
+                symbol.location.endLine >= line) {
+                return symbol;
+            }
+        }
+        return null;
+    }
+    getFileName(filePath) {
+        return filePath.split('/').pop() || filePath;
+    }
+    estimateComplexity(node) {
+        let complexity = 1;
+        const complexNodes = [
+            'if_statement',
+            'for_statement',
+            'while_statement',
+            'switch_statement',
+            'catch_clause'
+        ];
+        if (complexNodes.includes(node.type)) {
+            complexity++;
+        }
+        for (const child of node.children) {
+            complexity += this.estimateComplexity(child);
+        }
+        return complexity;
+    }
+    countEdges(graph) {
+        let count = 0;
+        for (const edges of graph.edges.values()) {
+            count += edges.length;
+        }
+        return count;
+    }
+    findDependents(graph, nodeId) {
+        const dependents = new Set();
+        for (const [from, edges] of graph.edges) {
+            for (const edge of edges) {
+                if (edge.to === nodeId) {
+                    dependents.add(from);
+                }
+            }
+        }
+        return dependents;
+    }
+    findDependencies(graph, nodeId) {
+        const dependencies = new Set();
+        const edges = graph.edges.get(nodeId) || [];
+        for (const edge of edges) {
+            dependencies.add(edge.to);
+        }
+        return dependencies;
+    }
+    getTransitiveDependencies(graph, nodeId, maxDepth = 10) {
+        const visited = new Set();
+        const queue = [{ id: nodeId, depth: 0 }];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (current.depth >= maxDepth || visited.has(current.id)) {
+                continue;
+            }
+            visited.add(current.id);
+            const deps = this.findDependencies(graph, current.id);
+            for (const dep of deps) {
+                queue.push({ id: dep, depth: current.depth + 1 });
+            }
+        }
+        visited.delete(nodeId);
+        return visited;
+    }
+}
+//# sourceMappingURL=dependency-graph.js.map

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

@@ -0,0 +1,44 @@
+/**
+ * Code Index Module
+ *
+ * Основной модуль для индексации кода:
+ * - Парсинг AST через Tree-sitter
+ * - Извлечение символов (функции, классы, интерфейсы)
+ * - Построение графа зависимостей
+ * - Анализ связей между компонентами
+ */
+import { ASTParser } from './ast-parser.js';
+import { SymbolExtractor } from './symbol-extractor.js';
+import { DependencyGraphBuilder } from './dependency-graph.js';
+import { DependencyGraph, Symbol, ASTNode } from '../types/index.js';
+export declare class CodeIndex {
+    private astParser;
+    private symbolExtractor;
+    private graphBuilder;
+    private rootDir;
+    private asts;
+    private symbols;
+    private graph;
+    constructor(rootDir?: string);
+    indexProject(rootDir?: string): Promise<void>;
+    parseProject(): Promise<Map<string, ASTNode>>;
+    extractSymbols(asts: Map<string, ASTNode>): Map<string, Symbol>;
+    buildDependencyGraph(asts: Map<string, ASTNode>, symbols: Map<string, Symbol>): DependencyGraph;
+    getGraph(): DependencyGraph | null;
+    getSymbols(): Map<string, Symbol>;
+    getASTs(): Map<string, ASTNode>;
+    findSymbol(name: string): Symbol | null;
+    findSymbolsInFile(filePath: string): Symbol[];
+    reindexFile(filePath: string): Promise<void>;
+    getStatistics(): {
+        totalFiles: number;
+        totalSymbols: number;
+        totalNodes: number;
+        totalEdges: number;
+        symbolsByKind: Record<string, number>;
+    };
+    private countGraphEdges;
+    private getSymbolsByKind;
+}
+export { ASTParser, SymbolExtractor, DependencyGraphBuilder };
+//# sourceMappingURL=index.d.ts.map

package/dist/code-index/index.js

@@ -0,0 +1,124 @@
+/**
+ * Code Index Module
+ *
+ * Основной модуль для индексации кода:
+ * - Парсинг AST через Tree-sitter
+ * - Извлечение символов (функции, классы, интерфейсы)
+ * - Построение графа зависимостей
+ * - Анализ связей между компонентами
+ */
+import { ASTParser } from './ast-parser.js';
+import { SymbolExtractor } from './symbol-extractor.js';
+import { DependencyGraphBuilder } from './dependency-graph.js';
+import { Logger } from '../utils/logger.js';
+export class CodeIndex {
+    astParser;
+    symbolExtractor;
+    graphBuilder;
+    rootDir;
+    asts = new Map();
+    symbols = new Map();
+    graph = null;
+    constructor(rootDir) {
+        this.rootDir = rootDir || process.cwd();
+        this.astParser = new ASTParser();
+        this.symbolExtractor = new SymbolExtractor();
+        this.graphBuilder = new DependencyGraphBuilder();
+    }
+    async indexProject(rootDir) {
+        const dir = rootDir || this.rootDir;
+        Logger.info(`Starting indexing of project: ${dir}`);
+        this.asts = await this.astParser.parseProject(dir);
+        this.symbols = this.symbolExtractor.extractSymbols(this.asts);
+        this.symbolExtractor.extractReferences(this.symbols, this.asts);
+        this.graph = this.graphBuilder.buildGraph(this.symbols, this.asts);
+        Logger.success('Project indexed successfully');
+    }
+    // Методы для использования в ProjectService
+    async parseProject() {
+        this.asts = await this.astParser.parseProject(this.rootDir);
+        return this.asts;
+    }
+    extractSymbols(asts) {
+        this.symbols = this.symbolExtractor.extractSymbols(asts);
+        this.symbolExtractor.extractReferences(this.symbols, asts);
+        return this.symbols;
+    }
+    buildDependencyGraph(asts, symbols) {
+        this.graph = this.graphBuilder.buildGraph(symbols, asts);
+        return this.graph;
+    }
+    getGraph() {
+        return this.graph;
+    }
+    getSymbols() {
+        return this.symbols;
+    }
+    getASTs() {
+        return this.asts;
+    }
+    findSymbol(name) {
+        for (const symbol of this.symbols.values()) {
+            if (symbol.name === name) {
+                return symbol;
+            }
+        }
+        return null;
+    }
+    findSymbolsInFile(filePath) {
+        const results = [];
+        for (const symbol of this.symbols.values()) {
+            if (symbol.filePath === filePath) {
+                results.push(symbol);
+            }
+        }
+        return results;
+    }
+    async reindexFile(filePath) {
+        Logger.progress(`Reindexing file: ${filePath}`);
+        const ast = await this.astParser.parseFile(filePath);
+        if (ast) {
+            this.asts.set(filePath, ast);
+            for (const [id, symbol] of this.symbols) {
+                if (symbol.filePath === filePath) {
+                    this.symbols.delete(id);
+                }
+            }
+            const newSymbols = this.symbolExtractor.extractSymbols(new Map([[filePath, ast]]));
+            for (const [id, symbol] of newSymbols) {
+                this.symbols.set(id, symbol);
+            }
+            if (this.graph) {
+                this.graph = this.graphBuilder.buildGraph(this.symbols, this.asts);
+            }
+            Logger.success(`File reindexed: ${filePath}`);
+        }
+    }
+    getStatistics() {
+        return {
+            totalFiles: this.asts.size,
+            totalSymbols: this.symbols.size,
+            totalNodes: this.graph?.nodes.size || 0,
+            totalEdges: this.countGraphEdges(),
+            symbolsByKind: this.getSymbolsByKind()
+        };
+    }
+    countGraphEdges() {
+        if (!this.graph)
+            return 0;
+        let count = 0;
+        for (const edges of this.graph.edges.values()) {
+            count += edges.length;
+        }
+        return count;
+    }
+    getSymbolsByKind() {
+        const counts = {};
+        for (const symbol of this.symbols.values()) {
+            counts[symbol.kind] = (counts[symbol.kind] || 0) + 1;
+        }
+        return counts;
+    }
+}
+export { ASTParser, SymbolExtractor, DependencyGraphBuilder };
+//# sourceMappingURL=index.js.map

package/dist/code-index/symbol-extractor.d.ts

@@ -0,0 +1,13 @@
+import { ASTNode, Symbol } from '../types/index.js';
+export declare class SymbolExtractor {
+    extractSymbols(asts: Map<string, ASTNode>): Map<string, Symbol>;
+    private extractFromNode;
+    private getSymbolKind;
+    private extractImports;
+    private parseImportNode;
+    private extractImportSpecifiers;
+    extractReferences(symbols: Map<string, Symbol>, asts: Map<string, ASTNode>): void;
+    private findReferences;
+    private inferReferenceKind;
+}
+//# sourceMappingURL=symbol-extractor.d.ts.map

package/dist/code-index/symbol-extractor.js

@@ -0,0 +1,150 @@
+import { SymbolKind } from '../types/index.js';
+import { Logger } from '../utils/logger.js';
+export class SymbolExtractor {
+    extractSymbols(asts) {
+        const symbols = new Map();
+        Logger.progress('Extracting symbols from AST...');
+        for (const [filePath, ast] of asts) {
+            this.extractFromNode(ast, filePath, symbols);
+        }
+        Logger.success(`Extracted ${symbols.size} symbols`);
+        return symbols;
+    }
+    extractFromNode(node, filePath, symbols) {
+        const symbolKind = this.getSymbolKind(node.type);
+        if (symbolKind && node.name) {
+            const symbol = {
+                id: `${filePath}:${node.name}:${node.startLine}`,
+                name: node.name,
+                kind: symbolKind,
+                filePath,
+                location: {
+                    filePath,
+                    startLine: node.startLine,
+                    endLine: node.endLine,
+                    startColumn: 0,
+                    endColumn: 0
+                },
+                references: [],
+                imports: this.extractImports(node)
+            };
+            symbols.set(symbol.id, symbol);
+        }
+        for (const child of node.children) {
+            this.extractFromNode(child, filePath, symbols);
+        }
+    }
+    getSymbolKind(nodeType) {
+        const mapping = {
+            // JavaScript/TypeScript
+            'function_declaration': SymbolKind.Function,
+            'method_definition': SymbolKind.Function,
+            'arrow_function': SymbolKind.Function,
+            'class_declaration': SymbolKind.Class,
+            'interface_declaration': SymbolKind.Interface,
+            'type_alias_declaration': SymbolKind.Type,
+            'variable_declaration': SymbolKind.Variable,
+            'const_declaration': SymbolKind.Constant,
+            'lexical_declaration': SymbolKind.Variable,
+            // Python
+            'function_definition': SymbolKind.Function,
+            'class_definition': SymbolKind.Class,
+            'decorated_definition': SymbolKind.Function,
+            'async_function_definition': SymbolKind.Function,
+            // Go
+            'method_declaration': SymbolKind.Function,
+            'type_declaration': SymbolKind.Type,
+            // Rust
+            'function_item': SymbolKind.Function,
+            'impl_item': SymbolKind.Class,
+            'struct_item': SymbolKind.Class,
+            'enum_item': SymbolKind.Type,
+            'trait_item': SymbolKind.Interface
+        };
+        return mapping[nodeType] || null;
+    }
+    extractImports(node) {
+        const imports = [];
+        if (node.type === 'import_statement' || node.type === 'import_declaration') {
+            const importNode = this.parseImportNode(node);
+            if (importNode) {
+                imports.push(importNode);
+            }
+        }
+        for (const child of node.children) {
+            imports.push(...this.extractImports(child));
+        }
+        return imports;
+    }
+    parseImportNode(node) {
+        const sourceNode = node.children.find(c => c.type === 'string');
+        if (!sourceNode)
+            return null;
+        const source = sourceNode.metadata.text;
+        const specifiers = this.extractImportSpecifiers(node);
+        return {
+            source: source.replace(/['"]/g, ''),
+            specifiers,
+            location: {
+                filePath: node.filePath,
+                startLine: node.startLine,
+                endLine: node.endLine,
+                startColumn: 0,
+                endColumn: 0
+            }
+        };
+    }
+    extractImportSpecifiers(node) {
+        const specifiers = [];
+        const findSpecifiers = (n) => {
+            if (n.type === 'import_specifier' || n.type === 'identifier') {
+                if (n.name) {
+                    specifiers.push(n.name);
+                }
+            }
+            n.children.forEach(findSpecifiers);
+        };
+        findSpecifiers(node);
+        return specifiers;
+    }
+    extractReferences(symbols, asts) {
+        Logger.progress('Building reference graph...');
+        for (const [filePath, ast] of asts) {
+            this.findReferences(ast, symbols, filePath);
+        }
+        Logger.success('Reference graph built');
+    }
+    findReferences(node, symbols, currentFile) {
+        if (node.type === 'identifier' && node.name) {
+            for (const symbol of symbols.values()) {
+                if (symbol.name === node.name) {
+                    const ref = {
+                        location: {
+                            filePath: currentFile,
+                            startLine: node.startLine,
+                            endLine: node.endLine,
+                            startColumn: 0,
+                            endColumn: 0
+                        },
+                        kind: this.inferReferenceKind(node)
+                    };
+                    symbol.references.push(ref);
+                }
+            }
+        }
+        for (const child of node.children) {
+            this.findReferences(child, symbols, currentFile);
+        }
+    }
+    inferReferenceKind(node) {
+        const parent = node.metadata.parent;
+        if (parent?.includes('call'))
+            return 'call';
+        if (parent?.includes('assignment'))
+            return 'write';
+        if (parent?.includes('type'))
+            return 'type';
+        return 'read';
+    }
+}
+//# sourceMappingURL=symbol-extractor.js.map

package/dist/export/index.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Export/Import System
+ *
+ * Форматы экспорта:
+ * - JSON (полный)
+ * - HTML отчёт
+ * - Markdown отчёт
+ * - PDF (через HTML)
+ * - CSV (метрики)
+ * - GraphML (граф зависимостей)
+ */
+import { DependencyGraph, Symbol } from '../types/index.js';
+import { ProjectMetrics } from '../metrics/index.js';
+import { RulesCheckResult } from '../rules-engine/index.js';
+import { DeadCodeResult } from '../analyzers/dead-code.js';
+import { DuplicationResult } from '../analyzers/duplication.js';
+import { SecurityResult } from '../analyzers/security.js';
+export interface ExportData {
+    projectName: string;
+    exportDate: string;
+    version: string;
+    graph?: DependencyGraph;
+    symbols?: Map<string, Symbol>;
+    metrics?: ProjectMetrics;
+    rules?: RulesCheckResult;
+    deadCode?: DeadCodeResult;
+    duplication?: DuplicationResult;
+    security?: SecurityResult;
+}
+export interface ExportOptions {
+    format: 'json' | 'html' | 'markdown' | 'csv' | 'graphml';
+    includeGraph?: boolean;
+    includeSymbols?: boolean;
+    includeMetrics?: boolean;
+    includeRules?: boolean;
+    includeDeadCode?: boolean;
+    includeDuplication?: boolean;
+    includeSecurity?: boolean;
+    language?: 'en' | 'ru';
+}
+export interface ImportResult {
+    success: boolean;
+    data?: ExportData;
+    errors?: string[];
+}
+export declare class ExportManager {
+    private version;
+    /**
+     * Экспорт данных в указанный формат
+     */
+    export(data: ExportData, options: ExportOptions): Promise<string>;
+    /**
+     * Импорт данных из JSON
+     */
+    import(jsonString: string): Promise<ImportResult>;
+    /**
+     * Экспорт в JSON
+     */
+    private exportJSON;
+    /**
+     * Экспорт в HTML
+     */
+    private exportHTML;
+    /**
+     * Экспорт в Markdown
+     */
+    private exportMarkdown;
+    /**
+     * Экспорт метрик в CSV
+     */
+    private exportCSV;
+    /**
+     * Экспорт графа в GraphML
+     */
+    private exportGraphML;
+    /**
+     * Санитизация ID для GraphML
+     */
+    private sanitizeId;
+    /**
+     * Экранирование XML
+     */
+    private escapeXml;
+}
+/**
+ * Быстрые функции экспорта
+ */
+export declare function exportToJSON(data: ExportData): Promise<string>;
+export declare function exportToHTML(data: ExportData, language?: 'en' | 'ru'): Promise<string>;
+export declare function exportToMarkdown(data: ExportData, language?: 'en' | 'ru'): Promise<string>;
+export declare function importFromJSON(jsonString: string): Promise<ImportResult>;
+//# sourceMappingURL=index.d.ts.map