archicore 0.1.0

package/dist/refactoring/index.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Refactoring Suggestions Engine
+ *
+ * Автоматические предложения по рефакторингу:
+ * - Extract Method/Function
+ * - Extract Class/Module
+ * - Rename suggestions
+ * - Move to appropriate layer
+ * - Simplify conditionals
+ * - Remove code smells
+ */
+import { DependencyGraph, Symbol } from '../types/index.js';
+import { ProjectMetrics } from '../metrics/index.js';
+import { DuplicationResult } from '../analyzers/duplication.js';
+import { DeadCodeResult } from '../analyzers/dead-code.js';
+import { RulesCheckResult } from '../rules-engine/index.js';
+export interface RefactoringSuggestion {
+    id: string;
+    type: RefactoringType;
+    priority: 'critical' | 'high' | 'medium' | 'low';
+    effort: 'trivial' | 'easy' | 'moderate' | 'hard';
+    file: string;
+    line?: number;
+    endLine?: number;
+    title: string;
+    description: string;
+    rationale: string;
+    suggestedCode?: string;
+    relatedFiles?: string[];
+    estimatedImpact: Impact;
+}
+export type RefactoringType = 'extract-method' | 'extract-class' | 'extract-module' | 'inline-method' | 'move-method' | 'move-to-layer' | 'rename' | 'simplify-conditional' | 'remove-dead-code' | 'eliminate-duplication' | 'reduce-complexity' | 'fix-coupling' | 'introduce-parameter-object' | 'replace-magic-number' | 'extract-constant' | 'split-file';
+export interface Impact {
+    complexity: number;
+    maintainability: number;
+    testability: number;
+    readability: number;
+}
+export interface RefactoringResult {
+    suggestions: RefactoringSuggestion[];
+    summary: RefactoringSummary;
+}
+export interface RefactoringSummary {
+    totalSuggestions: number;
+    byPriority: {
+        critical: number;
+        high: number;
+        medium: number;
+        low: number;
+    };
+    byType: Record<RefactoringType, number>;
+    estimatedTotalEffort: string;
+    potentialImprovements: {
+        complexityReduction: number;
+        maintainabilityGain: number;
+    };
+}
+export declare class RefactoringEngine {
+    /**
+     * Генерация всех предложений по рефакторингу
+     */
+    analyze(graph: DependencyGraph, symbols: Map<string, Symbol>, fileContents: Map<string, string>, metrics: ProjectMetrics, duplication?: DuplicationResult, deadCode?: DeadCodeResult, rulesResult?: RulesCheckResult): Promise<RefactoringResult>;
+    /**
+     * Анализ метрик для предложений
+     */
+    private analyzeMetrics;
+    /**
+     * Анализ дублирования
+     */
+    private analyzeDuplication;
+    /**
+     * Анализ мёртвого кода
+     */
+    private analyzeDeadCode;
+    /**
+     * Анализ нарушений правил
+     */
+    private analyzeRuleViolations;
+    /**
+     * Конвертация нарушения в предложение
+     */
+    private violationToSuggestion;
+    /**
+     * Анализ code smells
+     */
+    private analyzeCodeSmells;
+    /**
+     * Анализ структуры проекта
+     */
+    private analyzeProjectStructure;
+    /**
+     * Генерация кода для извлечения
+     */
+    private generateExtractionSuggestion;
+    /**
+     * Приоритизация предложений
+     */
+    private prioritizeSuggestions;
+    /**
+     * Расчёт сводки
+     */
+    private calculateSummary;
+    /**
+     * Хеширование строки
+     */
+    private hashString;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/refactoring/index.js

@@ -0,0 +1,580 @@
+/**
+ * Refactoring Suggestions Engine
+ *
+ * Автоматические предложения по рефакторингу:
+ * - Extract Method/Function
+ * - Extract Class/Module
+ * - Rename suggestions
+ * - Move to appropriate layer
+ * - Simplify conditionals
+ * - Remove code smells
+ */
+import { SymbolKind } from '../types/index.js';
+import { Logger } from '../utils/logger.js';
+// Code smell patterns
+const CODE_SMELLS = {
+    longMethod: { maxLines: 50, maxComplexity: 10 },
+    longParameterList: { maxParams: 5 },
+    largeClass: { maxMethods: 20, maxLines: 500 },
+    godClass: { maxDependencies: 15 },
+    featureEnvy: { threshold: 3 }, // вызовов методов другого класса
+    dataClump: { minOccurrences: 3 },
+    primitiveObsession: { threshold: 5 },
+    switchStatement: { maxCases: 5 },
+    magicNumber: { pattern: /(?<![.\d])\b\d{2,}\b(?!\.\d)/ },
+    deepNesting: { maxDepth: 4 }
+};
+export class RefactoringEngine {
+    /**
+     * Генерация всех предложений по рефакторингу
+     */
+    async analyze(graph, symbols, fileContents, metrics, duplication, deadCode, rulesResult) {
+        Logger.progress('Generating refactoring suggestions...');
+        const suggestions = [];
+        // 1. Анализ метрик
+        suggestions.push(...this.analyzeMetrics(metrics, fileContents));
+        // 2. Анализ дублирования
+        if (duplication) {
+            suggestions.push(...this.analyzeDuplication(duplication));
+        }
+        // 3. Анализ мёртвого кода
+        if (deadCode) {
+            suggestions.push(...this.analyzeDeadCode(deadCode));
+        }
+        // 4. Анализ нарушений правил
+        if (rulesResult) {
+            suggestions.push(...this.analyzeRuleViolations(rulesResult));
+        }
+        // 5. Анализ code smells
+        suggestions.push(...this.analyzeCodeSmells(fileContents, symbols));
+        // 6. Анализ структуры проекта
+        suggestions.push(...this.analyzeProjectStructure(graph, symbols));
+        // 7. Сортировка по приоритету
+        const sorted = this.prioritizeSuggestions(suggestions);
+        // 8. Сводка
+        const summary = this.calculateSummary(sorted);
+        Logger.success(`Generated ${sorted.length} refactoring suggestions`);
+        return { suggestions: sorted, summary };
+    }
+    /**
+     * Анализ метрик для предложений
+     */
+    analyzeMetrics(metrics, _fileContents) {
+        const suggestions = [];
+        for (const fileMetrics of metrics.files) {
+            const filePath = fileMetrics.filePath;
+            // Высокая сложность
+            if (fileMetrics.complexity.cyclomatic > CODE_SMELLS.longMethod.maxComplexity) {
+                suggestions.push({
+                    id: `complexity-${this.hashString(filePath)}`,
+                    type: 'reduce-complexity',
+                    priority: fileMetrics.complexity.cyclomatic > 20 ? 'high' : 'medium',
+                    effort: 'moderate',
+                    file: filePath,
+                    title: 'Reduce cyclomatic complexity',
+                    description: `File has cyclomatic complexity of ${fileMetrics.complexity.cyclomatic}`,
+                    rationale: 'High complexity makes code harder to test and maintain',
+                    estimatedImpact: { complexity: -5, maintainability: -3, testability: -4, readability: -3 }
+                });
+            }
+            // Высокая когнитивная сложность
+            if (fileMetrics.complexity.cognitive > 15) {
+                suggestions.push({
+                    id: `cognitive-${this.hashString(filePath)}`,
+                    type: 'simplify-conditional',
+                    priority: 'medium',
+                    effort: 'moderate',
+                    file: filePath,
+                    title: 'Simplify cognitive complexity',
+                    description: `Cognitive complexity is ${fileMetrics.complexity.cognitive}`,
+                    rationale: 'High cognitive complexity makes code hard to understand',
+                    estimatedImpact: { complexity: -4, maintainability: -3, testability: -2, readability: -5 }
+                });
+            }
+            // Низкий индекс поддерживаемости
+            if (fileMetrics.maintainability < 40) {
+                suggestions.push({
+                    id: `maintain-${this.hashString(filePath)}`,
+                    type: 'split-file',
+                    priority: 'high',
+                    effort: 'hard',
+                    file: filePath,
+                    title: 'Improve maintainability',
+                    description: `Maintainability index is ${fileMetrics.maintainability.toFixed(0)} (critical)`,
+                    rationale: 'Low maintainability index indicates technical debt',
+                    estimatedImpact: { complexity: -6, maintainability: -8, testability: -4, readability: -5 }
+                });
+            }
+            // Высокая связанность (coupling)
+            if (fileMetrics.coupling.efferentCoupling > 15) {
+                suggestions.push({
+                    id: `coupling-${this.hashString(filePath)}`,
+                    type: 'fix-coupling',
+                    priority: 'medium',
+                    effort: 'moderate',
+                    file: filePath,
+                    title: 'Reduce outgoing dependencies',
+                    description: `File has ${fileMetrics.coupling.efferentCoupling} outgoing dependencies`,
+                    rationale: 'High coupling makes changes risky and testing difficult',
+                    estimatedImpact: { complexity: -3, maintainability: -5, testability: -4, readability: -2 }
+                });
+            }
+            // Слишком много строк
+            if (fileMetrics.loc.code > CODE_SMELLS.largeClass.maxLines) {
+                suggestions.push({
+                    id: `loc-${this.hashString(filePath)}`,
+                    type: 'split-file',
+                    priority: 'medium',
+                    effort: 'hard',
+                    file: filePath,
+                    title: 'Split large file',
+                    description: `File has ${fileMetrics.loc.code} lines of code`,
+                    rationale: 'Large files are hard to navigate and understand',
+                    estimatedImpact: { complexity: -4, maintainability: -4, testability: -3, readability: -6 }
+                });
+            }
+        }
+        // Hotspots
+        for (const hotspot of metrics.hotspots.slice(0, 5)) {
+            suggestions.push({
+                id: `hotspot-${this.hashString(hotspot.filePath)}`,
+                type: 'reduce-complexity',
+                priority: 'high',
+                effort: 'hard',
+                file: hotspot.filePath,
+                title: 'Address code hotspot',
+                description: `This file is a hotspot with score ${hotspot.score.toFixed(0)}`,
+                rationale: 'Hotspots are high-risk areas that need attention',
+                estimatedImpact: { complexity: -6, maintainability: -5, testability: -5, readability: -4 }
+            });
+        }
+        return suggestions;
+    }
+    /**
+     * Анализ дублирования
+     */
+    analyzeDuplication(duplication) {
+        const suggestions = [];
+        for (const clone of duplication.clones) {
+            const isExact = clone.type === 'exact';
+            const multiFile = new Set(clone.instances.map(i => i.file)).size > 1;
+            suggestions.push({
+                id: `dup-${clone.id}`,
+                type: 'eliminate-duplication',
+                priority: clone.linesCount > 20 ? 'high' : 'medium',
+                effort: multiFile ? 'moderate' : 'easy',
+                file: clone.instances[0].file,
+                line: clone.instances[0].startLine,
+                endLine: clone.instances[0].endLine,
+                title: isExact ? 'Extract duplicated code' : 'Refactor similar code',
+                description: `${clone.instances.length} instances of ${isExact ? 'identical' : 'similar'} code (${clone.linesCount} lines)`,
+                rationale: 'Code duplication increases maintenance cost and bug risk',
+                suggestedCode: this.generateExtractionSuggestion(clone),
+                relatedFiles: clone.instances.map(i => i.file),
+                estimatedImpact: {
+                    complexity: -2,
+                    maintainability: -(clone.instances.length * 2),
+                    testability: -2,
+                    readability: -3
+                }
+            });
+        }
+        return suggestions;
+    }
+    /**
+     * Анализ мёртвого кода
+     */
+    analyzeDeadCode(deadCode) {
+        const suggestions = [];
+        // Неиспользуемые экспорты
+        for (const unused of deadCode.unusedExports.slice(0, 20)) {
+            suggestions.push({
+                id: `unused-export-${this.hashString(unused.file + unused.name)}`,
+                type: 'remove-dead-code',
+                priority: 'low',
+                effort: 'trivial',
+                file: unused.file,
+                line: unused.line,
+                title: `Remove unused export: ${unused.name}`,
+                description: `${unused.type} "${unused.name}" is exported but never imported`,
+                rationale: 'Dead code clutters the codebase and confuses developers',
+                estimatedImpact: { complexity: -1, maintainability: -1, testability: 0, readability: -1 }
+            });
+        }
+        // Недостижимый код
+        for (const unreachable of deadCode.unreachableCode) {
+            suggestions.push({
+                id: `unreachable-${this.hashString(unreachable.file + unreachable.startLine)}`,
+                type: 'remove-dead-code',
+                priority: 'medium',
+                effort: 'trivial',
+                file: unreachable.file,
+                line: unreachable.startLine,
+                endLine: unreachable.endLine,
+                title: 'Remove unreachable code',
+                description: unreachable.reason,
+                rationale: 'Unreachable code is dead weight and potentially confusing',
+                estimatedImpact: { complexity: -1, maintainability: -1, testability: 0, readability: -2 }
+            });
+        }
+        // Пустые блоки
+        for (const empty of deadCode.emptyBlocks) {
+            suggestions.push({
+                id: `empty-${this.hashString(empty.file + empty.line)}`,
+                type: 'remove-dead-code',
+                priority: 'low',
+                effort: 'trivial',
+                file: empty.file,
+                line: empty.line,
+                title: `Remove empty ${empty.type}${empty.name ? `: ${empty.name}` : ''}`,
+                description: `Empty ${empty.type} block does nothing`,
+                rationale: 'Empty blocks are usually placeholder code that was never completed',
+                estimatedImpact: { complexity: 0, maintainability: -1, testability: 0, readability: -1 }
+            });
+        }
+        // Закомментированный код
+        for (const commented of deadCode.commentedCode.slice(0, 10)) {
+            suggestions.push({
+                id: `commented-${this.hashString(commented.file + commented.startLine)}`,
+                type: 'remove-dead-code',
+                priority: 'low',
+                effort: 'trivial',
+                file: commented.file,
+                line: commented.startLine,
+                endLine: commented.endLine,
+                title: 'Remove commented-out code',
+                description: `${commented.linesCount} lines of commented code`,
+                rationale: 'Commented code should be deleted - use version control instead',
+                estimatedImpact: { complexity: 0, maintainability: -1, testability: 0, readability: -2 }
+            });
+        }
+        return suggestions;
+    }
+    /**
+     * Анализ нарушений правил
+     */
+    analyzeRuleViolations(rulesResult) {
+        const suggestions = [];
+        for (const violation of rulesResult.violations) {
+            const suggestion = this.violationToSuggestion(violation);
+            if (suggestion) {
+                suggestions.push(suggestion);
+            }
+        }
+        return suggestions;
+    }
+    /**
+     * Конвертация нарушения в предложение
+     */
+    violationToSuggestion(violation) {
+        const baseImpact = { complexity: -2, maintainability: -3, testability: -2, readability: -2 };
+        // Use ruleId to determine refactoring type
+        const ruleType = violation.ruleId?.split('-')[0] || '';
+        switch (ruleType) {
+            case 'no-circular':
+                return {
+                    id: `circular-${this.hashString(violation.file)}`,
+                    type: 'fix-coupling',
+                    priority: 'high',
+                    effort: 'hard',
+                    file: violation.file,
+                    title: 'Break circular dependency',
+                    description: violation.message,
+                    rationale: 'Circular dependencies cause build issues and tight coupling',
+                    estimatedImpact: { ...baseImpact, complexity: -5 }
+                };
+            case 'layer-boundary':
+                return {
+                    id: `layer-${this.hashString(violation.file + violation.line)}`,
+                    type: 'move-to-layer',
+                    priority: 'medium',
+                    effort: 'moderate',
+                    file: violation.file,
+                    line: violation.line,
+                    title: 'Fix layer boundary violation',
+                    description: violation.message,
+                    rationale: 'Layer violations break architectural integrity',
+                    estimatedImpact: baseImpact
+                };
+            case 'max-dependencies':
+                return {
+                    id: `deps-${this.hashString(violation.file)}`,
+                    type: 'split-file',
+                    priority: 'medium',
+                    effort: 'hard',
+                    file: violation.file,
+                    title: 'Reduce dependencies',
+                    description: violation.message,
+                    rationale: 'Too many dependencies indicates the file does too much',
+                    estimatedImpact: { ...baseImpact, maintainability: -5 }
+                };
+            case 'no-import':
+                return {
+                    id: `import-${this.hashString(violation.file + violation.line)}`,
+                    type: 'move-method',
+                    priority: 'medium',
+                    effort: 'easy',
+                    file: violation.file,
+                    line: violation.line,
+                    title: 'Remove forbidden import',
+                    description: violation.message,
+                    rationale: 'This import violates architectural rules',
+                    estimatedImpact: baseImpact
+                };
+            default:
+                return null;
+        }
+    }
+    /**
+     * Анализ code smells
+     */
+    analyzeCodeSmells(fileContents, _symbols) {
+        const suggestions = [];
+        for (const [filePath, content] of fileContents) {
+            const lines = content.split('\n');
+            // Long parameter lists
+            const funcPattern = /(?:function|const|let|var)\s+(\w+)\s*(?:=\s*(?:async\s*)?\(|\()([^)]*)\)/g;
+            let match;
+            while ((match = funcPattern.exec(content)) !== null) {
+                const params = match[2].split(',').filter(p => p.trim());
+                if (params.length > CODE_SMELLS.longParameterList.maxParams) {
+                    const line = content.substring(0, match.index).split('\n').length;
+                    suggestions.push({
+                        id: `params-${this.hashString(filePath + match[1])}`,
+                        type: 'introduce-parameter-object',
+                        priority: 'low',
+                        effort: 'easy',
+                        file: filePath,
+                        line,
+                        title: `Introduce parameter object for ${match[1]}`,
+                        description: `Function has ${params.length} parameters`,
+                        rationale: 'Long parameter lists are hard to remember and use correctly',
+                        estimatedImpact: { complexity: -1, maintainability: -2, testability: -1, readability: -3 }
+                    });
+                }
+            }
+            // Magic numbers
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Пропускаем комментарии и импорты
+                if (line.trim().startsWith('//') || line.includes('import'))
+                    continue;
+                const magicMatch = line.match(/(?<![.\d])\b(\d{2,})\b(?!\.\d)/);
+                if (magicMatch && !line.includes('const') && !line.includes('=')) {
+                    const num = magicMatch[1];
+                    // Исключаем общие значения
+                    if (!['100', '1000', '10', '60', '24', '365'].includes(num)) {
+                        suggestions.push({
+                            id: `magic-${this.hashString(filePath + i + num)}`,
+                            type: 'extract-constant',
+                            priority: 'low',
+                            effort: 'trivial',
+                            file: filePath,
+                            line: i + 1,
+                            title: `Extract magic number ${num}`,
+                            description: `Magic number ${num} should be a named constant`,
+                            rationale: 'Magic numbers are hard to understand and maintain',
+                            estimatedImpact: { complexity: 0, maintainability: -1, testability: 0, readability: -2 }
+                        });
+                    }
+                }
+            }
+            // Deep nesting
+            let maxNesting = 0;
+            let currentNesting = 0;
+            let deepestLine = 0;
+            for (let i = 0; i < lines.length; i++) {
+                const opens = (lines[i].match(/{/g) || []).length;
+                const closes = (lines[i].match(/}/g) || []).length;
+                currentNesting += opens - closes;
+                if (currentNesting > maxNesting) {
+                    maxNesting = currentNesting;
+                    deepestLine = i + 1;
+                }
+            }
+            if (maxNesting > CODE_SMELLS.deepNesting.maxDepth) {
+                suggestions.push({
+                    id: `nesting-${this.hashString(filePath)}`,
+                    type: 'extract-method',
+                    priority: 'medium',
+                    effort: 'moderate',
+                    file: filePath,
+                    line: deepestLine,
+                    title: 'Reduce nesting depth',
+                    description: `Maximum nesting depth is ${maxNesting}`,
+                    rationale: 'Deep nesting makes code hard to follow and test',
+                    estimatedImpact: { complexity: -4, maintainability: -3, testability: -3, readability: -5 }
+                });
+            }
+            // Switch with many cases
+            const switchPattern = /switch\s*\([^)]+\)\s*{([^}]+(?:{[^}]*}[^}]*)*)}/g;
+            while ((match = switchPattern.exec(content)) !== null) {
+                const cases = (match[1].match(/case\s+/g) || []).length;
+                if (cases > CODE_SMELLS.switchStatement.maxCases) {
+                    const line = content.substring(0, match.index).split('\n').length;
+                    suggestions.push({
+                        id: `switch-${this.hashString(filePath + line)}`,
+                        type: 'simplify-conditional',
+                        priority: 'medium',
+                        effort: 'moderate',
+                        file: filePath,
+                        line,
+                        title: 'Replace switch with polymorphism',
+                        description: `Switch statement has ${cases} cases`,
+                        rationale: 'Large switches often indicate missing abstraction',
+                        suggestedCode: '// Consider using a Map<string, Handler> or Strategy pattern',
+                        estimatedImpact: { complexity: -3, maintainability: -4, testability: -3, readability: -2 }
+                    });
+                }
+            }
+        }
+        return suggestions;
+    }
+    /**
+     * Анализ структуры проекта
+     */
+    analyzeProjectStructure(graph, symbols) {
+        const suggestions = [];
+        // God classes (слишком много зависимостей)
+        const dependencyCount = new Map();
+        for (const [file, edges] of graph.edges) {
+            dependencyCount.set(file, edges.length);
+        }
+        for (const [file, count] of dependencyCount) {
+            if (count > CODE_SMELLS.godClass.maxDependencies) {
+                suggestions.push({
+                    id: `god-${this.hashString(file)}`,
+                    type: 'extract-class',
+                    priority: 'high',
+                    effort: 'hard',
+                    file,
+                    title: 'Split god class/module',
+                    description: `File has ${count} dependencies - likely doing too much`,
+                    rationale: 'God classes violate Single Responsibility Principle',
+                    estimatedImpact: { complexity: -6, maintainability: -7, testability: -5, readability: -4 }
+                });
+            }
+        }
+        // Файлы с множеством экспортов разных типов
+        const fileExports = new Map();
+        for (const [, symbol] of symbols) {
+            if (!symbol.exports)
+                continue;
+            const file = symbol.location.filePath;
+            const current = fileExports.get(file) || { functions: 0, classes: 0, types: 0 };
+            if (symbol.kind === SymbolKind.Function)
+                current.functions++;
+            else if (symbol.kind === SymbolKind.Class)
+                current.classes++;
+            else if (symbol.kind === SymbolKind.Interface || symbol.kind === SymbolKind.Type)
+                current.types++;
+            fileExports.set(file, current);
+        }
+        for (const [file, exports] of fileExports) {
+            const total = exports.functions + exports.classes + exports.types;
+            if (total > 10 && exports.classes > 0 && exports.functions > 3) {
+                suggestions.push({
+                    id: `mixed-${this.hashString(file)}`,
+                    type: 'extract-module',
+                    priority: 'medium',
+                    effort: 'moderate',
+                    file,
+                    title: 'Separate concerns into modules',
+                    description: `File exports ${exports.classes} classes, ${exports.functions} functions, ${exports.types} types`,
+                    rationale: 'Mixed exports suggest the file has multiple responsibilities',
+                    estimatedImpact: { complexity: -3, maintainability: -4, testability: -3, readability: -3 }
+                });
+            }
+        }
+        return suggestions;
+    }
+    /**
+     * Генерация кода для извлечения
+     */
+    generateExtractionSuggestion(clone) {
+        const sample = clone.instances[0].code;
+        const lines = sample.split('\n');
+        // Пытаемся определить, что это за код
+        const hasReturn = sample.includes('return');
+        const hasAsync = sample.includes('await');
+        let suggestion = `// Extract to a shared function:\n`;
+        suggestion += `${hasAsync ? 'async ' : ''}function extractedFunction(/* params */)`;
+        suggestion += hasReturn ? ': ReturnType' : ': void';
+        suggestion += ` {\n`;
+        suggestion += lines.map(l => `  ${l}`).join('\n');
+        suggestion += `\n}`;
+        return suggestion;
+    }
+    /**
+     * Приоритизация предложений
+     */
+    prioritizeSuggestions(suggestions) {
+        const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+        const effortOrder = { trivial: 0, easy: 1, moderate: 2, hard: 3 };
+        return suggestions.sort((a, b) => {
+            // Сначала по приоритету
+            const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
+            if (priorityDiff !== 0)
+                return priorityDiff;
+            // При равном приоритете - по усилиям (проще первым)
+            const effortDiff = effortOrder[a.effort] - effortOrder[b.effort];
+            if (effortDiff !== 0)
+                return effortDiff;
+            // При равных усилиях - по общему импакту
+            const impactA = Math.abs(a.estimatedImpact.complexity + a.estimatedImpact.maintainability);
+            const impactB = Math.abs(b.estimatedImpact.complexity + b.estimatedImpact.maintainability);
+            return impactB - impactA;
+        });
+    }
+    /**
+     * Расчёт сводки
+     */
+    calculateSummary(suggestions) {
+        const byPriority = { critical: 0, high: 0, medium: 0, low: 0 };
+        const byType = {};
+        let totalEffortHours = 0;
+        let totalComplexityReduction = 0;
+        let totalMaintainabilityGain = 0;
+        for (const s of suggestions) {
+            byPriority[s.priority]++;
+            byType[s.type] = (byType[s.type] || 0) + 1;
+            // Оценка усилий в часах
+            const effortHours = { trivial: 0.25, easy: 0.5, moderate: 2, hard: 4 };
+            totalEffortHours += effortHours[s.effort];
+            totalComplexityReduction += Math.abs(s.estimatedImpact.complexity);
+            totalMaintainabilityGain += Math.abs(s.estimatedImpact.maintainability);
+        }
+        // Форматирование времени
+        let estimatedTotalEffort;
+        if (totalEffortHours < 8) {
+            estimatedTotalEffort = `${totalEffortHours.toFixed(1)} hours`;
+        }
+        else {
+            const days = totalEffortHours / 8;
+            estimatedTotalEffort = `${days.toFixed(1)} days`;
+        }
+        return {
+            totalSuggestions: suggestions.length,
+            byPriority,
+            byType: byType,
+            estimatedTotalEffort,
+            potentialImprovements: {
+                complexityReduction: totalComplexityReduction,
+                maintainabilityGain: totalMaintainabilityGain
+            }
+        };
+    }
+    /**
+     * Хеширование строки
+     */
+    hashString(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash;
+        }
+        return Math.abs(hash).toString(16).substring(0, 8);
+    }
+}
+//# sourceMappingURL=index.js.map