archicore 0.1.0

package/dist/impact-engine/index.js

@@ -0,0 +1,284 @@
+/**
+ * Change Impact Engine
+ *
+ * Анализ влияния изменений на кодовую базу:
+ * - Определение затронутых компонентов
+ * - Оценка рисков
+ * - Генерация рекомендаций
+ * - Построение графа влияния
+ */
+import { Logger } from '../utils/logger.js';
+export class ImpactEngine {
+    analyzeChange(change, graph, symbols, architecture) {
+        Logger.progress(`Analyzing impact of change: ${change.description}`);
+        const affectedNodes = this.findAffectedNodes(change, graph, symbols);
+        const risks = this.assessRisks(change, affectedNodes, architecture);
+        const recommendations = this.generateRecommendations(change, affectedNodes, risks);
+        const impactGraph = this.buildImpactGraph(change, affectedNodes, graph);
+        Logger.success(`Impact analysis complete: ${affectedNodes.length} nodes affected`);
+        return {
+            change,
+            affectedNodes,
+            risks,
+            recommendations,
+            impactGraph
+        };
+    }
+    findAffectedNodes(change, graph, symbols) {
+        const affected = [];
+        const visited = new Set();
+        const changedNodes = this.getChangedNodes(change, graph, symbols);
+        for (const nodeId of changedNodes) {
+            this.traverseDependents(nodeId, graph, affected, visited, 0);
+        }
+        affected.sort((a, b) => {
+            const levelOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+            return levelOrder[a.impactLevel] - levelOrder[b.impactLevel];
+        });
+        return affected;
+    }
+    getChangedNodes(change, graph, symbols) {
+        const nodes = new Set();
+        for (const file of change.files) {
+            const node = graph.nodes.get(file);
+            if (node) {
+                nodes.add(node.id);
+            }
+        }
+        for (const symbolName of change.symbols) {
+            for (const symbol of symbols.values()) {
+                if (symbol.name === symbolName) {
+                    nodes.add(symbol.id);
+                }
+            }
+        }
+        return nodes;
+    }
+    traverseDependents(nodeId, graph, affected, visited, distance, maxDistance = 5) {
+        if (visited.has(nodeId) || distance > maxDistance) {
+            return;
+        }
+        visited.add(nodeId);
+        const node = graph.nodes.get(nodeId);
+        if (!node)
+            return;
+        const impactLevel = this.calculateImpactLevel(distance, node.type);
+        affected.push({
+            id: nodeId,
+            name: node.name,
+            type: node.type,
+            filePath: node.filePath,
+            impactLevel,
+            reason: this.generateImpactReason(distance, node.type),
+            distance
+        });
+        const dependents = this.findDependents(nodeId, graph);
+        for (const dependent of dependents) {
+            this.traverseDependents(dependent, graph, affected, visited, distance + 1, maxDistance);
+        }
+    }
+    findDependents(nodeId, graph) {
+        const dependents = [];
+        for (const [from, edges] of graph.edges) {
+            for (const edge of edges) {
+                if (edge.to === nodeId) {
+                    dependents.push(from);
+                }
+            }
+        }
+        return dependents;
+    }
+    calculateImpactLevel(distance, nodeType) {
+        if (distance === 0)
+            return 'critical';
+        if (distance === 1 && nodeType === 'file')
+            return 'high';
+        if (distance === 1)
+            return 'high';
+        if (distance === 2)
+            return 'medium';
+        return 'low';
+    }
+    generateImpactReason(distance, _nodeType) {
+        if (distance === 0)
+            return 'Directly modified';
+        if (distance === 1)
+            return 'Direct dependency';
+        if (distance === 2)
+            return 'Indirect dependency (2 levels)';
+        return `Indirect dependency (${distance} levels)`;
+    }
+    assessRisks(change, affectedNodes, _architecture) {
+        const risks = [];
+        const criticalNodes = affectedNodes.filter(n => n.impactLevel === 'critical');
+        const highImpactNodes = affectedNodes.filter(n => n.impactLevel === 'high');
+        if (criticalNodes.length > 10) {
+            risks.push({
+                id: 'wide-impact',
+                severity: 'high',
+                category: 'breaking_change',
+                description: `Change affects ${criticalNodes.length} critical components`,
+                affectedComponents: criticalNodes.map(n => n.name),
+                mitigation: 'Consider breaking into smaller changes'
+            });
+        }
+        if (change.type === 'delete') {
+            risks.push({
+                id: 'deletion-risk',
+                severity: 'critical',
+                category: 'breaking_change',
+                description: 'Deletion may break dependent components',
+                affectedComponents: affectedNodes.map(n => n.name),
+                mitigation: 'Ensure all dependencies are updated or removed'
+            });
+        }
+        if (change.type === 'modify' && highImpactNodes.length > 0) {
+            risks.push({
+                id: 'api-change',
+                severity: 'high',
+                category: 'compatibility',
+                description: 'Modification may break API contracts',
+                affectedComponents: highImpactNodes.map(n => n.name),
+                mitigation: 'Review and update all API consumers'
+            });
+        }
+        const coreFiles = affectedNodes.filter(n => n.filePath.includes('/core/') || n.filePath.includes('/kernel/'));
+        if (coreFiles.length > 0) {
+            risks.push({
+                id: 'core-system-risk',
+                severity: 'critical',
+                category: 'breaking_change',
+                description: 'Change affects core system components',
+                affectedComponents: coreFiles.map(n => n.name),
+                mitigation: 'Thorough testing required, consider staged rollout'
+            });
+        }
+        return risks;
+    }
+    generateRecommendations(change, affectedNodes, risks) {
+        const recommendations = [];
+        recommendations.push({
+            type: 'review',
+            priority: 'critical',
+            description: 'Review all affected components',
+            details: `${affectedNodes.length} components will be affected by this change`
+        });
+        const criticalNodes = affectedNodes.filter(n => n.impactLevel === 'critical');
+        if (criticalNodes.length > 0) {
+            recommendations.push({
+                type: 'test',
+                priority: 'critical',
+                description: 'Test critical components',
+                details: `Focus on: ${criticalNodes.slice(0, 5).map(n => n.name).join(', ')}`
+            });
+        }
+        const highRisks = risks.filter(r => r.severity === 'critical' || r.severity === 'high');
+        if (highRisks.length > 0) {
+            recommendations.push({
+                type: 'check',
+                priority: 'critical',
+                description: 'Address high-severity risks',
+                details: highRisks.map(r => r.description).join('; ')
+            });
+        }
+        if (affectedNodes.some(n => n.filePath.includes('test'))) {
+            recommendations.push({
+                type: 'test',
+                priority: 'high',
+                description: 'Update affected tests',
+                details: 'Test files detected in affected nodes'
+            });
+        }
+        if (change.type === 'refactor') {
+            recommendations.push({
+                type: 'refactor',
+                priority: 'medium',
+                description: 'Consider incremental refactoring',
+                details: 'Break into smaller, safer changes'
+            });
+        }
+        return recommendations;
+    }
+    buildImpactGraph(_change, affectedNodes, graph) {
+        const impactGraph = {
+            nodes: new Map(),
+            edges: []
+        };
+        for (const affected of affectedNodes) {
+            const node = {
+                id: affected.id,
+                name: affected.name,
+                impactLevel: affected.impactLevel,
+                metadata: {
+                    type: affected.type,
+                    filePath: affected.filePath,
+                    distance: affected.distance,
+                    reason: affected.reason
+                }
+            };
+            impactGraph.nodes.set(affected.id, node);
+        }
+        for (const affected of affectedNodes) {
+            const edges = graph.edges.get(affected.id) || [];
+            for (const edge of edges) {
+                if (impactGraph.nodes.has(edge.to)) {
+                    impactGraph.edges.push({
+                        from: affected.id,
+                        to: edge.to,
+                        reason: `Depends on via ${edge.type}`
+                    });
+                }
+            }
+        }
+        return impactGraph;
+    }
+    generateReport(impact) {
+        let report = `# Impact Analysis: ${impact.change.description}\n\n`;
+        report += `## Summary\n\n`;
+        report += `- **Change Type:** ${impact.change.type}\n`;
+        report += `- **Affected Files:** ${impact.change.files.length}\n`;
+        report += `- **Affected Components:** ${impact.affectedNodes.length}\n`;
+        report += `- **Risks Identified:** ${impact.risks.length}\n\n`;
+        report += `## Affected Components\n\n`;
+        const byLevel = this.groupByImpactLevel(impact.affectedNodes);
+        for (const [level, nodes] of Object.entries(byLevel)) {
+            if (nodes.length > 0) {
+                report += `### ${level.toUpperCase()} Impact (${nodes.length})\n\n`;
+                for (const node of nodes.slice(0, 10)) {
+                    report += `- **${node.name}** (${node.filePath})\n`;
+                    report += `  - ${node.reason}\n`;
+                }
+                if (nodes.length > 10) {
+                    report += `\n... and ${nodes.length - 10} more\n`;
+                }
+                report += '\n';
+            }
+        }
+        report += `## Risks\n\n`;
+        for (const risk of impact.risks) {
+            report += `### ${risk.severity.toUpperCase()}: ${risk.description}\n`;
+            report += `**Category:** ${risk.category}\n`;
+            if (risk.mitigation) {
+                report += `**Mitigation:** ${risk.mitigation}\n`;
+            }
+            report += '\n';
+        }
+        report += `## Recommendations\n\n`;
+        for (const rec of impact.recommendations) {
+            report += `- **[${rec.priority.toUpperCase()}]** ${rec.description}\n`;
+            if (rec.details) {
+                report += `  ${rec.details}\n`;
+            }
+        }
+        return report;
+    }
+    groupByImpactLevel(nodes) {
+        return {
+            critical: nodes.filter(n => n.impactLevel === 'critical'),
+            high: nodes.filter(n => n.impactLevel === 'high'),
+            medium: nodes.filter(n => n.impactLevel === 'medium'),
+            low: nodes.filter(n => n.impactLevel === 'low')
+        };
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/index.d.ts

@@ -0,0 +1,60 @@
+/**
+ * AIArhitector - AI Software Architect System
+ *
+ * Главный класс, объединяющий все модули системы
+ */
+import { Change, ChangeImpact, LLMConfig, SemanticSearchResult, DependencyGraph } from './types/index.js';
+export interface AIArhitectorConfig {
+    rootDir: string;
+    llm: LLMConfig;
+    vectorStore: {
+        url: string;
+        apiKey?: string;
+        collectionName: string;
+    };
+    architectureConfigPath?: string;
+}
+export declare class AIArhitector {
+    private codeIndex;
+    private semanticMemory;
+    private architecture;
+    private impactEngine;
+    private orchestrator;
+    private config;
+    private initialized;
+    constructor(config: AIArhitectorConfig);
+    initialize(): Promise<void>;
+    analyzeChange(change: Change): Promise<ChangeImpact>;
+    searchCode(query: string, limit?: number): Promise<SemanticSearchResult[]>;
+    askQuestion(question: string): Promise<string>;
+    suggestRefactoring(code: string, goal: string): Promise<string>;
+    reviewCode(code: string, changedFiles: string[]): Promise<string>;
+    generateDocumentation(): Promise<string>;
+    getDependencyGraph(): DependencyGraph | null;
+    getArchitectureModel(): import("./types/index.js").ArchitectureModel;
+    getStatistics(): {
+        codeIndex: {
+            totalFiles: number;
+            totalSymbols: number;
+            totalNodes: number;
+            totalEdges: number;
+            symbolsByKind: Record<string, number>;
+        };
+        semanticMemory: Promise<{
+            name: string;
+            vectorsCount: number;
+            pointsCount: number | null | undefined;
+            status: "green" | "yellow" | "grey" | "red";
+        } | null>;
+    };
+    reindexFile(filePath: string): Promise<void>;
+    private ensureInitialized;
+}
+export * from './types/index.js';
+export { CodeIndex } from './code-index/index.js';
+export { SemanticMemory } from './semantic-memory/index.js';
+export { ArchitectureKnowledge } from './architecture/index.js';
+export { ImpactEngine } from './impact-engine/index.js';
+export { LLMOrchestrator } from './orchestrator/index.js';
+export { DeepSeekOptimizer } from './orchestrator/deepseek-optimizer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,149 @@
+/**
+ * AIArhitector - AI Software Architect System
+ *
+ * Главный класс, объединяющий все модули системы
+ */
+import { CodeIndex } from './code-index/index.js';
+import { SemanticMemory } from './semantic-memory/index.js';
+import { ArchitectureKnowledge } from './architecture/index.js';
+import { ImpactEngine } from './impact-engine/index.js';
+import { LLMOrchestrator } from './orchestrator/index.js';
+import { Logger } from './utils/logger.js';
+import { config } from 'dotenv';
+config();
+export class AIArhitector {
+    codeIndex;
+    semanticMemory;
+    architecture;
+    impactEngine;
+    orchestrator;
+    config;
+    initialized = false;
+    constructor(config) {
+        this.config = config;
+        this.codeIndex = new CodeIndex();
+        this.semanticMemory = new SemanticMemory({ provider: config.llm.provider }, config.vectorStore);
+        this.architecture = new ArchitectureKnowledge(config.architectureConfigPath || '.aiarhitector/architecture.json');
+        this.impactEngine = new ImpactEngine();
+        this.orchestrator = new LLMOrchestrator(config.llm);
+        Logger.info('AIArhitector initialized');
+    }
+    async initialize() {
+        if (this.initialized) {
+            Logger.warn('Already initialized');
+            return;
+        }
+        Logger.info('Initializing AIArhitector...');
+        await this.codeIndex.indexProject(this.config.rootDir);
+        await this.semanticMemory.initialize();
+        await this.semanticMemory.indexSymbols(this.codeIndex.getSymbols(), this.codeIndex.getASTs());
+        await this.architecture.load();
+        this.initialized = true;
+        Logger.success('AIArhitector ready!');
+    }
+    async analyzeChange(change) {
+        this.ensureInitialized();
+        Logger.info(`Analyzing change: ${change.description}`);
+        const graph = this.codeIndex.getGraph();
+        if (!graph) {
+            throw new Error('Dependency graph not built');
+        }
+        const impact = this.impactEngine.analyzeChange(change, graph, this.codeIndex.getSymbols(), this.architecture.getModel());
+        const semanticContext = await this.semanticMemory.searchByQuery(change.description, 5);
+        const llmAnalysis = await this.orchestrator.analyzeImpact(impact, {
+            architecture: this.architecture.getModel(),
+            semanticMemory: semanticContext,
+            codeIndex: graph,
+            recentChanges: [change]
+        });
+        Logger.info('LLM Analysis:\n' + llmAnalysis);
+        return impact;
+    }
+    async searchCode(query, limit = 10) {
+        this.ensureInitialized();
+        return await this.semanticMemory.searchByQuery(query, limit);
+    }
+    async askQuestion(question) {
+        this.ensureInitialized();
+        const semanticContext = await this.semanticMemory.searchByQuery(question, 10);
+        const answer = await this.orchestrator.answerArchitecturalQuestion(question, {
+            architecture: this.architecture.getModel(),
+            semanticMemory: semanticContext,
+            codeIndex: this.codeIndex.getGraph() || undefined
+        });
+        return answer;
+    }
+    async suggestRefactoring(code, goal) {
+        this.ensureInitialized();
+        const semanticContext = await this.semanticMemory.searchSimilarCode(code, {}, 5);
+        const suggestion = await this.orchestrator.suggestRefactoring(code, goal, {
+            architecture: this.architecture.getModel(),
+            semanticMemory: semanticContext
+        });
+        return suggestion;
+    }
+    async reviewCode(code, changedFiles) {
+        this.ensureInitialized();
+        const semanticContext = await this.semanticMemory.searchSimilarCode(code, {}, 5);
+        const review = await this.orchestrator.reviewCode(code, changedFiles, {
+            architecture: this.architecture.getModel(),
+            semanticMemory: semanticContext,
+            codeIndex: this.codeIndex.getGraph() || undefined
+        });
+        return review;
+    }
+    async generateDocumentation() {
+        this.ensureInitialized();
+        const graph = this.codeIndex.getGraph();
+        const stats = this.codeIndex.getStatistics();
+        const codebaseSummary = `
+Codebase Statistics:
+- Total Files: ${stats.totalFiles}
+- Total Symbols: ${stats.totalSymbols}
+- Symbols by Kind: ${JSON.stringify(stats.symbolsByKind, null, 2)}
+
+Architecture:
+${this.architecture.generateReport()}
+`;
+        const docs = await this.orchestrator.generateDocumentation(codebaseSummary, {
+            architecture: this.architecture.getModel(),
+            codeIndex: graph || undefined
+        });
+        return docs;
+    }
+    getDependencyGraph() {
+        return this.codeIndex.getGraph();
+    }
+    getArchitectureModel() {
+        return this.architecture.getModel();
+    }
+    getStatistics() {
+        return {
+            codeIndex: this.codeIndex.getStatistics(),
+            semanticMemory: this.semanticMemory.getStatistics()
+        };
+    }
+    async reindexFile(filePath) {
+        this.ensureInitialized();
+        await this.codeIndex.reindexFile(filePath);
+        await this.semanticMemory.deleteFile(filePath);
+        const symbols = this.codeIndex.findSymbolsInFile(filePath);
+        const asts = this.codeIndex.getASTs();
+        const fileSymbols = new Map(symbols.map(s => [s.id, s]));
+        await this.semanticMemory.indexSymbols(fileSymbols, asts);
+        Logger.success(`File reindexed: ${filePath}`);
+    }
+    ensureInitialized() {
+        if (!this.initialized) {
+            throw new Error('AIArhitector not initialized. Call initialize() first.');
+        }
+    }
+}
+export * from './types/index.js';
+export { CodeIndex } from './code-index/index.js';
+export { SemanticMemory } from './semantic-memory/index.js';
+export { ArchitectureKnowledge } from './architecture/index.js';
+export { ImpactEngine } from './impact-engine/index.js';
+export { LLMOrchestrator } from './orchestrator/index.js';
+export { DeepSeekOptimizer } from './orchestrator/deepseek-optimizer.js';
+//# sourceMappingURL=index.js.map

package/dist/metrics/index.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Code Metrics Module
+ *
+ * Вычисление метрик качества кода:
+ * - Цикломатическая сложность
+ * - Когнитивная сложность
+ * - Связанность (Coupling)
+ * - Связность (Cohesion)
+ * - Maintainability Index
+ * - Lines of Code метрики
+ */
+import { DependencyGraph, Symbol, ASTNode } from '../types/index.js';
+export interface FileMetrics {
+    filePath: string;
+    loc: LOCMetrics;
+    complexity: ComplexityMetrics;
+    coupling: CouplingMetrics;
+    maintainability: number;
+    issues: MetricIssue[];
+}
+export interface LOCMetrics {
+    total: number;
+    code: number;
+    comments: number;
+    blank: number;
+    ratio: number;
+}
+export interface ComplexityMetrics {
+    cyclomatic: number;
+    cognitive: number;
+    halstead: HalsteadMetrics;
+    maxNesting: number;
+    avgFunctionComplexity: number;
+}
+export interface HalsteadMetrics {
+    vocabulary: number;
+    length: number;
+    volume: number;
+    difficulty: number;
+    effort: number;
+    time: number;
+    bugs: number;
+}
+export interface CouplingMetrics {
+    afferentCoupling: number;
+    efferentCoupling: number;
+    instability: number;
+    abstractness: number;
+    distance: number;
+}
+export interface MetricIssue {
+    type: 'complexity' | 'coupling' | 'size' | 'maintainability';
+    severity: 'high' | 'medium' | 'low';
+    message: string;
+    suggestion: string;
+}
+export interface ProjectMetrics {
+    summary: ProjectSummary;
+    files: FileMetrics[];
+    hotspots: Hotspot[];
+}
+export interface ProjectSummary {
+    totalFiles: number;
+    totalLOC: number;
+    avgComplexity: number;
+    avgMaintainability: number;
+    avgCoupling: number;
+    technicalDebtHours: number;
+    grade: 'A' | 'B' | 'C' | 'D' | 'F';
+}
+export interface Hotspot {
+    filePath: string;
+    score: number;
+    reasons: string[];
+}
+export declare class MetricsCalculator {
+    private readonly COMPLEXITY_THRESHOLD;
+    private readonly COGNITIVE_THRESHOLD;
+    private readonly COUPLING_THRESHOLD;
+    private readonly LOC_THRESHOLD;
+    private readonly NESTING_THRESHOLD;
+    /**
+     * Вычислить метрики для всего проекта
+     */
+    calculateProjectMetrics(graph: DependencyGraph, symbols: Map<string, Symbol>, fileContents: Map<string, string>, asts: Map<string, ASTNode>): Promise<ProjectMetrics>;
+    /**
+     * Вычислить метрики для одного файла
+     */
+    calculateFileMetrics(filePath: string, content: string, ast: ASTNode | undefined, graph: DependencyGraph, symbols: Map<string, Symbol>): FileMetrics;
+    /**
+     * Подсчёт строк кода
+     */
+    private calculateLOC;
+    /**
+     * Вычисление сложности
+     */
+    private calculateComplexity;
+    /**
+     * Цикломатическая сложность (McCabe)
+     */
+    private calculateCyclomaticComplexity;
+    /**
+     * Когнитивная сложность (SonarSource)
+     */
+    private calculateCognitiveComplexity;
+    /**
+     * Halstead метрики
+     */
+    private calculateHalsteadMetrics;
+    /**
+     * Максимальная вложенность
+     */
+    private calculateMaxNesting;
+    /**
+     * Вычисление связанности
+     */
+    private calculateCoupling;
+    /**
+     * Индекс поддерживаемости (Maintainability Index)
+     * Формула Microsoft: MI = MAX(0, (171 - 5.2 * ln(V) - 0.23 * G - 16.2 * ln(LOC)) * 100 / 171)
+     */
+    private calculateMaintainability;
+    /**
+     * Выявление проблем
+     */
+    private identifyIssues;
+    /**
+     * Сводка по проекту
+     */
+    private calculateSummary;
+    /**
+     * Определение "горячих точек"
+     */
+    private identifyHotspots;
+}
+//# sourceMappingURL=index.d.ts.map