archicore 0.1.0

package/dist/analyzers/dead-code.js

@@ -0,0 +1,327 @@
+/**
+ * Dead Code Detector
+ *
+ * Обнаружение неиспользуемого кода:
+ * - Неиспользуемые экспорты
+ * - Неиспользуемые переменные
+ * - Unreachable code
+ * - Пустые функции/классы
+ * - Закомментированный код
+ */
+import { SymbolKind } from '../types/index.js';
+import { Logger } from '../utils/logger.js';
+export class DeadCodeDetector {
+    /**
+     * Анализ мёртвого кода
+     */
+    async analyze(graph, symbols, fileContents) {
+        Logger.progress('Analyzing dead code...');
+        const unusedExports = this.findUnusedExports(graph, symbols);
+        const unusedVariables = this.findUnusedVariables(symbols, fileContents);
+        const unreachableCode = this.findUnreachableCode(fileContents);
+        const emptyBlocks = this.findEmptyBlocks(fileContents);
+        const commentedCode = this.findCommentedCode(fileContents);
+        const summary = this.calculateSummary(unusedExports, unusedVariables, unreachableCode, emptyBlocks, commentedCode);
+        Logger.success(`Dead code analysis complete: ${summary.totalIssues} issues found`);
+        return {
+            unusedExports,
+            unusedVariables,
+            unreachableCode,
+            emptyBlocks,
+            commentedCode,
+            summary
+        };
+    }
+    /**
+     * Поиск неиспользуемых экспортов
+     */
+    findUnusedExports(graph, symbols) {
+        const unusedExports = [];
+        const usedSymbols = new Set();
+        // Собираем все используемые символы из графа зависимостей
+        for (const [, edges] of graph.edges) {
+            for (const edge of edges) {
+                usedSymbols.add(edge.to);
+            }
+        }
+        // Проверяем все экспортируемые символы
+        for (const [, symbol] of symbols) {
+            if (symbol.exports) {
+                // Проверяем, используется ли символ
+                const isUsed = usedSymbols.has(symbol.name) ||
+                    usedSymbols.has(`${symbol.location.filePath}:${symbol.name}`);
+                // Пропускаем entry points (index.ts, main.ts и т.д.)
+                const isEntryPoint = symbol.location.filePath.match(/(index|main|app)\.(ts|js|tsx|jsx)$/);
+                if (!isUsed && !isEntryPoint) {
+                    unusedExports.push({
+                        name: symbol.name,
+                        type: symbol.kind,
+                        file: symbol.location.filePath,
+                        line: symbol.location.startLine,
+                        suggestion: this.getSuggestionForUnusedExport(symbol)
+                    });
+                }
+            }
+        }
+        return unusedExports;
+    }
+    /**
+     * Поиск неиспользуемых переменных
+     */
+    findUnusedVariables(_symbols, fileContents) {
+        const unusedVariables = [];
+        for (const [filePath, content] of fileContents) {
+            // Ищем объявления переменных
+            const varPatterns = [
+                /(?:const|let|var)\s+(\w+)\s*[=:]/g, // const x = ...
+                /(?:const|let|var)\s+\{\s*([^}]+)\s*\}/g, // const { x, y } = ...
+                /function\s+(\w+)\s*\(/g, // function foo()
+                /(\w+)\s*:\s*(?:string|number|boolean|any)/g // params with types
+            ];
+            const declaredVars = new Map();
+            for (const pattern of varPatterns) {
+                let match;
+                const lines = content.split('\n');
+                for (let i = 0; i < lines.length; i++) {
+                    pattern.lastIndex = 0;
+                    while ((match = pattern.exec(lines[i])) !== null) {
+                        const varName = match[1];
+                        // Пропускаем _ префикс (намеренно неиспользуемые)
+                        if (varName && !varName.startsWith('_')) {
+                            declaredVars.set(varName, i + 1);
+                        }
+                    }
+                }
+            }
+            // Проверяем использование
+            for (const [varName, line] of declaredVars) {
+                // Создаём regex для поиска использований (не объявлений)
+                const usagePattern = new RegExp(`(?<!(?:const|let|var|function)\\s+)\\b${varName}\\b`, 'g');
+                const usages = content.match(usagePattern);
+                // Если только одно вхождение (само объявление), то переменная не используется
+                if (!usages || usages.length <= 1) {
+                    unusedVariables.push({
+                        name: varName,
+                        file: filePath,
+                        line,
+                        scope: 'local'
+                    });
+                }
+            }
+        }
+        return unusedVariables.slice(0, 100); // Ограничиваем вывод
+    }
+    /**
+     * Поиск недостижимого кода
+     */
+    findUnreachableCode(fileContents) {
+        const unreachable = [];
+        for (const [filePath, content] of fileContents) {
+            const lines = content.split('\n');
+            let inUnreachable = false;
+            let unreachableStart = 0;
+            let braceCount = 0;
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i].trim();
+                // Отслеживаем блоки
+                braceCount += (line.match(/{/g) || []).length;
+                braceCount -= (line.match(/}/g) || []).length;
+                // Код после return/throw/break/continue в том же блоке
+                if (line.match(/^(return|throw|break|continue)\b/) && !line.endsWith('{')) {
+                    inUnreachable = true;
+                    unreachableStart = i + 2;
+                }
+                // Конец блока сбрасывает unreachable
+                if (inUnreachable && line === '}') {
+                    if (unreachableStart < i) {
+                        unreachable.push({
+                            file: filePath,
+                            startLine: unreachableStart,
+                            endLine: i,
+                            reason: 'Code after return/throw/break statement'
+                        });
+                    }
+                    inUnreachable = false;
+                }
+                // Условия, которые всегда false
+                if (line.match(/if\s*\(\s*false\s*\)/)) {
+                    unreachable.push({
+                        file: filePath,
+                        startLine: i + 1,
+                        endLine: i + 1,
+                        reason: 'Condition is always false'
+                    });
+                }
+                // while(false)
+                if (line.match(/while\s*\(\s*false\s*\)/)) {
+                    unreachable.push({
+                        file: filePath,
+                        startLine: i + 1,
+                        endLine: i + 1,
+                        reason: 'Loop condition is always false'
+                    });
+                }
+            }
+        }
+        return unreachable;
+    }
+    /**
+     * Поиск пустых блоков
+     */
+    findEmptyBlocks(fileContents) {
+        const emptyBlocks = [];
+        for (const [filePath, content] of fileContents) {
+            const lines = content.split('\n');
+            for (let i = 0; i < lines.length - 1; i++) {
+                const line = lines[i].trim();
+                const nextLine = lines[i + 1]?.trim() || '';
+                // Пустая функция
+                const funcMatch = line.match(/(?:function\s+(\w+)|(\w+)\s*=\s*(?:async\s+)?(?:function|\([^)]*\)\s*=>))\s*\{\s*$/);
+                if (funcMatch && nextLine === '}') {
+                    emptyBlocks.push({
+                        type: 'function',
+                        name: funcMatch[1] || funcMatch[2],
+                        file: filePath,
+                        line: i + 1
+                    });
+                }
+                // Пустой класс
+                if (line.match(/class\s+\w+.*\{\s*$/) && nextLine === '}') {
+                    const classMatch = line.match(/class\s+(\w+)/);
+                    emptyBlocks.push({
+                        type: 'class',
+                        name: classMatch?.[1],
+                        file: filePath,
+                        line: i + 1
+                    });
+                }
+                // Пустой catch
+                if (line.match(/catch\s*\([^)]*\)\s*\{\s*$/) && nextLine === '}') {
+                    emptyBlocks.push({
+                        type: 'catch',
+                        file: filePath,
+                        line: i + 1
+                    });
+                }
+                // Пустой if/else
+                if (line.match(/(?:if|else)\s*(?:\([^)]*\))?\s*\{\s*$/) && nextLine === '}') {
+                    emptyBlocks.push({
+                        type: 'if',
+                        file: filePath,
+                        line: i + 1
+                    });
+                }
+                // Пустой цикл
+                if (line.match(/(?:for|while)\s*\([^)]*\)\s*\{\s*$/) && nextLine === '}') {
+                    emptyBlocks.push({
+                        type: 'loop',
+                        file: filePath,
+                        line: i + 1
+                    });
+                }
+            }
+        }
+        return emptyBlocks;
+    }
+    /**
+     * Поиск закомментированного кода
+     */
+    findCommentedCode(fileContents) {
+        const commentedCode = [];
+        // Паттерны кода (упрощённо)
+        const codePatterns = [
+            /^\s*\/\/\s*(const|let|var|function|class|if|for|while|return|import|export)\b/,
+            /^\s*\/\/\s*\w+\s*\([^)]*\)\s*[{;]?\s*$/,
+            /^\s*\/\/\s*\w+\.\w+\s*\(/,
+            /^\s*\/\*[\s\S]*?(const|let|var|function|class|if|for|while|return)[\s\S]*?\*\//
+        ];
+        for (const [filePath, content] of fileContents) {
+            const lines = content.split('\n');
+            let commentStart = -1;
+            let commentLines = [];
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                const isCommentedCode = codePatterns.some(p => p.test(line));
+                if (isCommentedCode) {
+                    if (commentStart === -1) {
+                        commentStart = i + 1;
+                    }
+                    commentLines.push(line.replace(/^\s*\/\/\s?/, '').trim());
+                }
+                else {
+                    // Конец блока закомментированного кода
+                    if (commentStart !== -1 && commentLines.length >= 3) {
+                        commentedCode.push({
+                            file: filePath,
+                            startLine: commentStart,
+                            endLine: i,
+                            linesCount: commentLines.length,
+                            preview: commentLines.slice(0, 2).join('\n').substring(0, 100) + '...'
+                        });
+                    }
+                    commentStart = -1;
+                    commentLines = [];
+                }
+            }
+            // Проверяем конец файла
+            if (commentStart !== -1 && commentLines.length >= 3) {
+                commentedCode.push({
+                    file: filePath,
+                    startLine: commentStart,
+                    endLine: lines.length,
+                    linesCount: commentLines.length,
+                    preview: commentLines.slice(0, 2).join('\n').substring(0, 100) + '...'
+                });
+            }
+        }
+        return commentedCode;
+    }
+    /**
+     * Подсказка для неиспользуемого экспорта
+     */
+    getSuggestionForUnusedExport(symbol) {
+        switch (symbol.kind) {
+            case SymbolKind.Function:
+                return 'Удалите функцию или используйте её';
+            case SymbolKind.Class:
+                return 'Удалите класс или создайте экземпляр';
+            case SymbolKind.Interface:
+                return 'Удалите интерфейс или реализуйте его';
+            case SymbolKind.Type:
+                return 'Удалите тип или используйте в аннотациях';
+            case SymbolKind.Variable:
+            case SymbolKind.Constant:
+                return 'Удалите переменную или используйте её';
+            default:
+                return 'Рассмотрите удаление неиспользуемого экспорта';
+        }
+    }
+    /**
+     * Сводка
+     */
+    calculateSummary(unusedExports, unusedVariables, unreachableCode, emptyBlocks, commentedCode) {
+        const unreachableLines = unreachableCode.reduce((sum, u) => sum + (u.endLine - u.startLine + 1), 0);
+        const commentedLines = commentedCode.reduce((sum, c) => sum + c.linesCount, 0);
+        const totalIssues = unusedExports.length +
+            unusedVariables.length +
+            unreachableCode.length +
+            emptyBlocks.length +
+            commentedCode.length;
+        // Оценка времени на очистку (примерно)
+        const estimatedCleanupHours = unusedExports.length * 0.05 +
+            unusedVariables.length * 0.02 +
+            unreachableCode.length * 0.1 +
+            emptyBlocks.length * 0.02 +
+            commentedCode.length * 0.03;
+        return {
+            totalIssues,
+            unusedExportsCount: unusedExports.length,
+            unusedVariablesCount: unusedVariables.length,
+            unreachableCodeLines: unreachableLines,
+            emptyBlocksCount: emptyBlocks.length,
+            commentedCodeLines: commentedLines,
+            estimatedCleanupHours: Math.round(estimatedCleanupHours * 10) / 10
+        };
+    }
+}
+//# sourceMappingURL=dead-code.js.map

package/dist/analyzers/duplication.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Code Duplication Detector
+ *
+ * Оптимизированное обнаружение дублирования кода:
+ * - Использует хеширование строк (Rabin-Karp подход)
+ * - Ограничивает размер анализа для больших проектов
+ * - Не хранит весь код в памяти
+ */
+export interface DuplicationResult {
+    clones: CodeClone[];
+    summary: DuplicationSummary;
+}
+export interface CodeClone {
+    id: string;
+    type: 'exact' | 'similar' | 'structural';
+    instances: CloneInstance[];
+    linesCount: number;
+    similarity: number;
+    suggestion: string;
+}
+export interface CloneInstance {
+    file: string;
+    startLine: number;
+    endLine: number;
+    code: string;
+}
+export interface DuplicationSummary {
+    totalClones: number;
+    totalDuplicatedLines: number;
+    duplicationPercentage: number;
+    filesAffected: number;
+    estimatedRefactorHours: number;
+}
+export declare class DuplicationDetector {
+    private readonly MIN_LINES;
+    private readonly WINDOW_SIZES;
+    private readonly MAX_CLONES;
+    private readonly MAX_FILES;
+    private readonly MAX_LINES_PER_FILE;
+    /**
+     * Анализ дублирования
+     */
+    analyze(fileContents: Map<string, string>): Promise<DuplicationResult>;
+    /**
+     * Ограничение файлов для анализа
+     */
+    private limitFiles;
+    /**
+     * Быстрый алгоритм для больших проектов
+     * Использует только хеширование строк
+     */
+    private findClonesQuick;
+    /**
+     * Обычный алгоритм для средних проектов
+     */
+    private findClonesNormal;
+    /**
+     * Расширение блока вниз пока строки совпадают
+     */
+    private expandBlock;
+    /**
+     * Получить блок кода по номерам строк
+     */
+    private getCodeBlock;
+    /**
+     * Нормализация одной строки
+     */
+    private normalizeLine;
+    /**
+     * Нормализация блока строк
+     */
+    private normalizeBlock;
+    /**
+     * Быстрое хеширование
+     */
+    private quickHash;
+    /**
+     * Фильтрация перекрывающихся блоков
+     */
+    private filterOverlapping;
+    /**
+     * Удаление дубликатов клонов (перекрывающихся)
+     */
+    private deduplicateClones;
+    /**
+     * Подсчёт статистики
+     */
+    private calculateSummary;
+}
+//# sourceMappingURL=duplication.d.ts.map