archicore 0.4.2 → 0.4.4

package/dist/analyzers/ai-narrator.js

@@ -0,0 +1,632 @@
+/**
+ * AI Narrator
+ *
+ * Генерирует человекопонятное описание архитектуры проекта:
+ * - Что это за проект
+ * - Какая архитектура используется
+ * - Где проблемные места
+ * - Конкретные рекомендации
+ */
+import { Logger } from '../utils/logger.js';
+export class AINarrator {
+    /**
+     * Анализирует проект и генерирует нарратив
+     */
+    async analyze(graph, symbols, fileContents, projectMetadata) {
+        Logger.progress('AI Narrator analyzing project...');
+        // 1. Анализ структуры файлов
+        const fileAnalysis = this.analyzeFiles(graph, fileContents);
+        // 2. Определение стека технологий
+        const techStack = this.detectTechStack(fileAnalysis, projectMetadata);
+        // 3. Анализ символов и их распределения (используется для статистики)
+        this.analyzeSymbols(symbols);
+        // 4. Определение архитектуры
+        const architecture = this.detectArchitecture(graph, symbols, fileAnalysis);
+        // 5. Поиск проблем
+        const problems = this.findProblems(graph, symbols, fileContents, fileAnalysis);
+        // 6. Генерация рекомендаций
+        const recommendations = this.generateRecommendations(problems, architecture);
+        // 7. Генерация нарратива
+        const narrative = this.generateNarrative(fileAnalysis, techStack, architecture, problems, recommendations, 'en');
+        const narrativeRu = this.generateNarrative(fileAnalysis, techStack, architecture, problems, recommendations, 'ru');
+        Logger.success('AI Narrator analysis complete');
+        return {
+            summary: {
+                projectType: this.detectProjectType(techStack, fileAnalysis),
+                primaryLanguage: fileAnalysis.primaryLanguage,
+                secondaryLanguages: fileAnalysis.secondaryLanguages,
+                totalFiles: fileAnalysis.totalFiles,
+                totalSymbols: symbols.size,
+                linesOfCode: fileAnalysis.totalLines,
+            },
+            techStack,
+            architecture,
+            problems,
+            recommendations,
+            narrative,
+            narrativeRu,
+        };
+    }
+    /**
+     * Анализ файловой структуры
+     */
+    analyzeFiles(graph, fileContents) {
+        const filesByLanguage = new Map();
+        const filesByDirectory = new Map();
+        const largeFiles = [];
+        let totalLines = 0;
+        for (const [filePath, content] of fileContents) {
+            // Подсчёт строк
+            const lines = content.split('\n').length;
+            totalLines += lines;
+            // Большие файлы (> 500 строк)
+            if (lines > 500) {
+                largeFiles.push({ path: filePath, lines });
+            }
+            // Язык по расширению
+            const ext = filePath.split('.').pop()?.toLowerCase() || 'unknown';
+            const lang = this.extToLanguage(ext);
+            filesByLanguage.set(lang, (filesByLanguage.get(lang) || 0) + 1);
+            // Директория
+            const dir = filePath.split(/[/\\]/).slice(0, -1).join('/') || '/';
+            if (!filesByDirectory.has(dir)) {
+                filesByDirectory.set(dir, []);
+            }
+            filesByDirectory.get(dir).push(filePath);
+        }
+        // Определяем основной язык
+        const sortedLanguages = [...filesByLanguage.entries()]
+            .sort((a, b) => b[1] - a[1]);
+        const primaryLanguage = sortedLanguages[0]?.[0] || 'unknown';
+        const secondaryLanguages = sortedLanguages.slice(1, 4).map(([lang]) => lang);
+        return {
+            totalFiles: fileContents.size || graph.nodes.size,
+            totalLines,
+            primaryLanguage,
+            secondaryLanguages,
+            filesByLanguage,
+            filesByDirectory,
+            largeFiles: largeFiles.sort((a, b) => b.lines - a.lines).slice(0, 10),
+        };
+    }
+    /**
+     * Определение стека технологий
+     */
+    detectTechStack(fileAnalysis, projectMetadata) {
+        const frontend = [];
+        const backend = [];
+        const database = [];
+        const infrastructure = [];
+        // Из метаданных проекта
+        if (projectMetadata?.framework)
+            frontend.push(projectMetadata.framework);
+        if (projectMetadata?.backend)
+            backend.push(projectMetadata.backend);
+        if (projectMetadata?.database)
+            database.push(projectMetadata.database);
+        // Из зависимостей
+        const deps = projectMetadata?.dependencies || {};
+        const depNames = Object.keys(deps);
+        // Frontend frameworks
+        if (depNames.some(d => d.includes('vue')))
+            frontend.push('Vue.js');
+        if (depNames.some(d => d.includes('react')))
+            frontend.push('React');
+        if (depNames.some(d => d.includes('angular')))
+            frontend.push('Angular');
+        if (depNames.some(d => d.includes('svelte')))
+            frontend.push('Svelte');
+        if (depNames.some(d => d === 'next'))
+            frontend.push('Next.js');
+        if (depNames.some(d => d === 'nuxt'))
+            frontend.push('Nuxt.js');
+        // Backend frameworks
+        if (depNames.some(d => d.includes('express')))
+            backend.push('Express.js');
+        if (depNames.some(d => d.includes('fastify')))
+            backend.push('Fastify');
+        if (depNames.some(d => d.includes('nest')))
+            backend.push('NestJS');
+        if (depNames.some(d => d.includes('koa')))
+            backend.push('Koa');
+        // Из структуры файлов
+        const dirs = [...fileAnalysis.filesByDirectory.keys()].join(' ');
+        // PHP frameworks
+        if (dirs.includes('laravel') || dirs.includes('app/Http'))
+            backend.push('Laravel');
+        if (dirs.includes('symfony'))
+            backend.push('Symfony');
+        if (dirs.includes('bitrix') || dirs.includes('local/modules'))
+            backend.push('Bitrix');
+        if (dirs.includes('yii'))
+            backend.push('Yii');
+        if (dirs.includes('wordpress') || dirs.includes('wp-content'))
+            backend.push('WordPress');
+        // Database
+        if (depNames.some(d => d.includes('mysql') || d.includes('mysql2')))
+            database.push('MySQL');
+        if (depNames.some(d => d.includes('postgres') || d.includes('pg')))
+            database.push('PostgreSQL');
+        if (depNames.some(d => d.includes('mongodb') || d.includes('mongoose')))
+            database.push('MongoDB');
+        if (depNames.some(d => d.includes('redis')))
+            database.push('Redis');
+        if (depNames.some(d => d.includes('sqlite')))
+            database.push('SQLite');
+        // Infrastructure
+        if (depNames.some(d => d.includes('docker')))
+            infrastructure.push('Docker');
+        if (dirs.includes('kubernetes') || dirs.includes('k8s'))
+            infrastructure.push('Kubernetes');
+        if (depNames.some(d => d.includes('aws-sdk')))
+            infrastructure.push('AWS');
+        // Дедупликация
+        return {
+            frontend: [...new Set(frontend)],
+            backend: [...new Set(backend)],
+            database: [...new Set(database)],
+            infrastructure: [...new Set(infrastructure)],
+        };
+    }
+    /**
+     * Анализ символов
+     */
+    analyzeSymbols(symbols) {
+        const byKind = new Map();
+        const byFile = new Map();
+        const complexSymbols = [];
+        for (const symbol of symbols.values()) {
+            // По типу
+            byKind.set(symbol.kind, (byKind.get(symbol.kind) || 0) + 1);
+            // По файлу
+            byFile.set(symbol.filePath, (byFile.get(symbol.filePath) || 0) + 1);
+            // Сложные символы (много ссылок)
+            if (symbol.references.length > 20) {
+                complexSymbols.push(symbol);
+            }
+        }
+        return { byKind, byFile, complexSymbols };
+    }
+    /**
+     * Определение архитектуры
+     */
+    detectArchitecture(_graph, _symbols, fileAnalysis) {
+        const patterns = [];
+        const layers = [];
+        let detectedArch = 'Unknown';
+        let confidence = 0;
+        const dirs = [...fileAnalysis.filesByDirectory.keys()];
+        const allFiles = [...fileAnalysis.filesByDirectory.values()].flat();
+        // MVC Detection
+        const hasControllers = dirs.some(d => d.includes('controller') || d.includes('Controller'));
+        const hasModels = dirs.some(d => d.includes('model') || d.includes('Model') || d.includes('entities'));
+        const hasViews = dirs.some(d => d.includes('view') || d.includes('View') || d.includes('templates'));
+        if (hasControllers && hasModels) {
+            patterns.push({
+                name: 'MVC',
+                confidence: hasViews ? 90 : 70,
+                evidence: [
+                    hasControllers ? 'Controllers directory found' : '',
+                    hasModels ? 'Models directory found' : '',
+                    hasViews ? 'Views directory found' : '',
+                ].filter(Boolean),
+                files: dirs.filter(d => d.includes('controller') || d.includes('model') || d.includes('view')),
+            });
+        }
+        // Clean Architecture Detection
+        const hasDomain = dirs.some(d => d.includes('domain') || d.includes('entities'));
+        const hasUseCases = dirs.some(d => d.includes('usecase') || d.includes('use-case') || d.includes('application'));
+        const hasInfra = dirs.some(d => d.includes('infrastructure') || d.includes('infra'));
+        if (hasDomain && (hasUseCases || hasInfra)) {
+            patterns.push({
+                name: 'Clean Architecture',
+                confidence: hasUseCases && hasInfra ? 85 : 60,
+                evidence: [
+                    hasDomain ? 'Domain layer found' : '',
+                    hasUseCases ? 'Use Cases layer found' : '',
+                    hasInfra ? 'Infrastructure layer found' : '',
+                ].filter(Boolean),
+                files: dirs.filter(d => d.includes('domain') || d.includes('usecase') || d.includes('infrastructure')),
+            });
+        }
+        // Repository Pattern
+        const hasRepositories = dirs.some(d => d.includes('repositor'));
+        if (hasRepositories) {
+            patterns.push({
+                name: 'Repository Pattern',
+                confidence: 80,
+                evidence: ['Repository directory/files found'],
+                files: dirs.filter(d => d.includes('repositor')),
+            });
+        }
+        // Service Layer
+        const hasServices = dirs.some(d => d.includes('service') || d.includes('Service'));
+        if (hasServices) {
+            patterns.push({
+                name: 'Service Layer',
+                confidence: 85,
+                evidence: ['Services directory found'],
+                files: dirs.filter(d => d.includes('service')),
+            });
+        }
+        // Определяем основную архитектуру
+        if (patterns.length > 0) {
+            const bestPattern = patterns.sort((a, b) => b.confidence - a.confidence)[0];
+            detectedArch = bestPattern.name;
+            confidence = bestPattern.confidence;
+        }
+        // Формируем слои
+        const layerMappings = [
+            { name: 'Presentation', patterns: ['controller', 'view', 'component', 'page'], role: 'UI and API endpoints' },
+            { name: 'Application', patterns: ['service', 'usecase', 'handler'], role: 'Business logic orchestration' },
+            { name: 'Domain', patterns: ['model', 'entity', 'domain', 'core'], role: 'Business rules and entities' },
+            { name: 'Infrastructure', patterns: ['repository', 'database', 'api', 'external'], role: 'External integrations' },
+        ];
+        for (const mapping of layerMappings) {
+            const layerFiles = allFiles.filter(f => mapping.patterns.some(p => f.toLowerCase().includes(p)));
+            if (layerFiles.length > 0) {
+                layers.push({
+                    name: mapping.name,
+                    files: layerFiles,
+                    coverage: Math.round((layerFiles.length / allFiles.length) * 100),
+                    role: mapping.role,
+                });
+            }
+        }
+        return {
+            detected: detectedArch,
+            confidence,
+            layers,
+            patterns,
+        };
+    }
+    /**
+     * Поиск проблем
+     */
+    findProblems(graph, symbols, _fileContents, fileAnalysis) {
+        const problems = [];
+        // 1. Большие файлы (God Objects)
+        for (const { path, lines } of fileAnalysis.largeFiles) {
+            if (lines > 1000) {
+                problems.push({
+                    severity: 'critical',
+                    title: 'God Object',
+                    description: `File ${this.shortPath(path)} has ${lines} lines - likely too many responsibilities`,
+                    files: [path],
+                    suggestion: 'Split into smaller, focused modules with single responsibility',
+                });
+            }
+            else if (lines > 500) {
+                problems.push({
+                    severity: 'warning',
+                    title: 'Large File',
+                    description: `File ${this.shortPath(path)} has ${lines} lines`,
+                    files: [path],
+                    suggestion: 'Consider breaking into smaller modules',
+                });
+            }
+        }
+        // 2. Файлы с большим количеством символов (высокая сложность)
+        const symbolsPerFile = new Map();
+        for (const symbol of symbols.values()) {
+            symbolsPerFile.set(symbol.filePath, (symbolsPerFile.get(symbol.filePath) || 0) + 1);
+        }
+        for (const [file, count] of symbolsPerFile) {
+            if (count > 50) {
+                problems.push({
+                    severity: 'warning',
+                    title: 'High Complexity',
+                    description: `File ${this.shortPath(file)} has ${count} symbols - may be too complex`,
+                    files: [file],
+                    suggestion: 'Extract related functions into separate modules',
+                });
+            }
+        }
+        // 3. Circular dependencies (если есть в графе)
+        const visited = new Set();
+        const recursionStack = new Set();
+        const cycles = [];
+        const detectCycle = (nodeId, path = []) => {
+            if (recursionStack.has(nodeId)) {
+                const cycleStart = path.indexOf(nodeId);
+                if (cycleStart !== -1) {
+                    cycles.push(path.slice(cycleStart));
+                }
+                return;
+            }
+            if (visited.has(nodeId))
+                return;
+            visited.add(nodeId);
+            recursionStack.add(nodeId);
+            const edges = graph.edges.get(nodeId) || [];
+            for (const edge of edges) {
+                detectCycle(edge.to, [...path, nodeId]);
+            }
+            recursionStack.delete(nodeId);
+        };
+        for (const nodeId of graph.nodes.keys()) {
+            detectCycle(nodeId);
+        }
+        if (cycles.length > 0) {
+            problems.push({
+                severity: 'critical',
+                title: 'Circular Dependencies',
+                description: `Found ${cycles.length} circular dependency chains`,
+                files: cycles.flat().slice(0, 10),
+                suggestion: 'Break cycles by introducing interfaces or restructuring modules',
+            });
+        }
+        // 4. Файлы без очевидной структуры
+        const unstructuredDirs = [...fileAnalysis.filesByDirectory.entries()]
+            .filter(([dir, files]) => {
+            // Много файлов в одной директории без подпапок
+            return files.length > 20 && !dir.includes('/');
+        });
+        if (unstructuredDirs.length > 0) {
+            problems.push({
+                severity: 'info',
+                title: 'Flat Structure',
+                description: 'Many files in root directories without clear organization',
+                files: unstructuredDirs.flatMap(([, files]) => files.slice(0, 5)),
+                suggestion: 'Organize files into feature-based or layer-based directories',
+            });
+        }
+        return problems.sort((a, b) => {
+            const severityOrder = { critical: 0, warning: 1, info: 2 };
+            return severityOrder[a.severity] - severityOrder[b.severity];
+        });
+    }
+    /**
+     * Генерация рекомендаций
+     */
+    generateRecommendations(problems, architecture) {
+        const recommendations = [];
+        // Из проблем
+        const criticalProblems = problems.filter(p => p.severity === 'critical');
+        if (criticalProblems.length > 0) {
+            recommendations.push(`Address ${criticalProblems.length} critical issues first: ${criticalProblems.map(p => p.title).join(', ')}`);
+        }
+        // Архитектурные
+        if (architecture.confidence < 50) {
+            recommendations.push('Define clear architectural boundaries - current structure is unclear');
+        }
+        if (!architecture.patterns.some(p => p.name === 'Repository Pattern')) {
+            recommendations.push('Consider implementing Repository Pattern to separate data access logic');
+        }
+        if (architecture.layers.length < 3) {
+            recommendations.push('Structure code into clear layers (Presentation, Business, Data) for better maintainability');
+        }
+        // Общие best practices
+        if (problems.some(p => p.title === 'God Object')) {
+            recommendations.push('Apply Single Responsibility Principle - each module should do one thing well');
+        }
+        return recommendations;
+    }
+    /**
+     * Генерация человекопонятного текста
+     */
+    generateNarrative(fileAnalysis, techStack, architecture, problems, recommendations, language) {
+        if (language === 'ru') {
+            return this.generateNarrativeRu(fileAnalysis, techStack, architecture, problems, recommendations);
+        }
+        const lines = [];
+        // Header
+        lines.push('# Project Architecture Analysis\n');
+        // Summary
+        const projectType = this.detectProjectType(techStack, fileAnalysis);
+        lines.push(`## Overview\n`);
+        lines.push(`This is a **${projectType}** with ${fileAnalysis.totalFiles} files and approximately ${fileAnalysis.totalLines.toLocaleString()} lines of code.\n`);
+        // Tech Stack
+        lines.push(`## Technology Stack\n`);
+        if (techStack.frontend.length > 0) {
+            lines.push(`- **Frontend:** ${techStack.frontend.join(', ')}`);
+        }
+        if (techStack.backend.length > 0) {
+            lines.push(`- **Backend:** ${techStack.backend.join(', ')}`);
+        }
+        if (techStack.database.length > 0) {
+            lines.push(`- **Database:** ${techStack.database.join(', ')}`);
+        }
+        lines.push('');
+        // Architecture
+        lines.push(`## Architecture\n`);
+        lines.push(`**Detected Pattern:** ${architecture.detected} (${architecture.confidence}% confidence)\n`);
+        if (architecture.layers.length > 0) {
+            lines.push('**Layers:**');
+            for (const layer of architecture.layers) {
+                lines.push(`- ${layer.name}: ${layer.files.length} files (${layer.coverage}%) - ${layer.role}`);
+            }
+        }
+        lines.push('');
+        // Problems
+        if (problems.length > 0) {
+            lines.push(`## Issues Found\n`);
+            const criticalCount = problems.filter(p => p.severity === 'critical').length;
+            const warningCount = problems.filter(p => p.severity === 'warning').length;
+            lines.push(`Found **${criticalCount} critical** and **${warningCount} warning** issues:\n`);
+            for (const problem of problems.slice(0, 5)) {
+                const icon = problem.severity === 'critical' ? '🔴' : problem.severity === 'warning' ? '🟡' : '🔵';
+                lines.push(`${icon} **${problem.title}**: ${problem.description}`);
+                lines.push(`   → ${problem.suggestion}\n`);
+            }
+        }
+        // Recommendations
+        if (recommendations.length > 0) {
+            lines.push(`## Recommendations\n`);
+            for (let i = 0; i < Math.min(recommendations.length, 5); i++) {
+                lines.push(`${i + 1}. ${recommendations[i]}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Генерация нарратива на русском
+     */
+    generateNarrativeRu(fileAnalysis, techStack, architecture, problems, recommendations) {
+        const lines = [];
+        // Заголовок
+        lines.push('# Анализ архитектуры проекта\n');
+        // Обзор
+        const projectType = this.detectProjectType(techStack, fileAnalysis);
+        lines.push(`## Обзор\n`);
+        lines.push(`Это **${this.translateProjectType(projectType)}** с ${fileAnalysis.totalFiles} файлами и примерно ${fileAnalysis.totalLines.toLocaleString()} строками кода.\n`);
+        lines.push(`Основной язык: **${fileAnalysis.primaryLanguage}**`);
+        if (fileAnalysis.secondaryLanguages.length > 0) {
+            lines.push(`Дополнительные: ${fileAnalysis.secondaryLanguages.join(', ')}`);
+        }
+        lines.push('');
+        // Стек технологий
+        lines.push(`## Стек технологий\n`);
+        if (techStack.frontend.length > 0) {
+            lines.push(`- **Frontend:** ${techStack.frontend.join(', ')}`);
+        }
+        if (techStack.backend.length > 0) {
+            lines.push(`- **Backend:** ${techStack.backend.join(', ')}`);
+        }
+        if (techStack.database.length > 0) {
+            lines.push(`- **База данных:** ${techStack.database.join(', ')}`);
+        }
+        if (techStack.infrastructure.length > 0) {
+            lines.push(`- **Инфраструктура:** ${techStack.infrastructure.join(', ')}`);
+        }
+        lines.push('');
+        // Архитектура
+        lines.push(`## Архитектура\n`);
+        lines.push(`**Обнаружен паттерн:** ${architecture.detected} (уверенность ${architecture.confidence}%)\n`);
+        if (architecture.layers.length > 0) {
+            lines.push('**Слои:**');
+            for (const layer of architecture.layers) {
+                lines.push(`- ${this.translateLayer(layer.name)}: ${layer.files.length} файлов (${layer.coverage}%)`);
+            }
+        }
+        if (architecture.patterns.length > 0) {
+            lines.push('\n**Используемые паттерны:**');
+            for (const pattern of architecture.patterns) {
+                lines.push(`- ${pattern.name} (${pattern.confidence}%)`);
+            }
+        }
+        lines.push('');
+        // Проблемы
+        if (problems.length > 0) {
+            lines.push(`## Проблемные места\n`);
+            const criticalCount = problems.filter(p => p.severity === 'critical').length;
+            const warningCount = problems.filter(p => p.severity === 'warning').length;
+            lines.push(`Найдено **${criticalCount} критических** и **${warningCount} предупреждений**:\n`);
+            for (const problem of problems.slice(0, 7)) {
+                const icon = problem.severity === 'critical' ? '🔴' : problem.severity === 'warning' ? '🟡' : '🔵';
+                lines.push(`${icon} **${this.translateProblem(problem.title)}**`);
+                lines.push(`   ${problem.description}`);
+                lines.push(`   💡 ${this.translateSuggestion(problem.suggestion)}\n`);
+            }
+        }
+        // Рекомендации
+        if (recommendations.length > 0) {
+            lines.push(`## Рекомендации\n`);
+            for (let i = 0; i < Math.min(recommendations.length, 5); i++) {
+                lines.push(`${i + 1}. ${this.translateRecommendation(recommendations[i])}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    // Вспомогательные методы
+    extToLanguage(ext) {
+        const map = {
+            'ts': 'TypeScript', 'tsx': 'TypeScript',
+            'js': 'JavaScript', 'jsx': 'JavaScript', 'mjs': 'JavaScript',
+            'vue': 'Vue', 'svelte': 'Svelte',
+            'php': 'PHP',
+            'py': 'Python',
+            'java': 'Java', 'kt': 'Kotlin',
+            'cs': 'C#',
+            'go': 'Go',
+            'rs': 'Rust',
+            'rb': 'Ruby',
+            'swift': 'Swift',
+            'css': 'CSS', 'scss': 'SCSS', 'less': 'LESS',
+            'html': 'HTML',
+            'sql': 'SQL',
+            'json': 'JSON', 'yaml': 'YAML', 'yml': 'YAML',
+        };
+        return map[ext] || ext.toUpperCase();
+    }
+    shortPath(path) {
+        const parts = path.split(/[/\\]/);
+        return parts.length > 3
+            ? `.../${parts.slice(-3).join('/')}`
+            : path;
+    }
+    detectProjectType(techStack, fileAnalysis) {
+        const { frontend, backend } = techStack;
+        const { primaryLanguage } = fileAnalysis;
+        if (frontend.length > 0 && backend.length > 0) {
+            return `Full-stack ${frontend[0]} + ${backend[0]} application`;
+        }
+        if (frontend.length > 0) {
+            return `${frontend[0]} frontend application`;
+        }
+        if (backend.length > 0) {
+            return `${backend[0]} backend application`;
+        }
+        if (primaryLanguage === 'PHP') {
+            return 'PHP web application';
+        }
+        if (primaryLanguage === 'Python') {
+            return 'Python application';
+        }
+        return `${primaryLanguage} project`;
+    }
+    translateProjectType(type) {
+        return type
+            .replace('Full-stack', 'Полнoстековое')
+            .replace('frontend application', 'фронтенд приложение')
+            .replace('backend application', 'бэкенд приложение')
+            .replace('web application', 'веб-приложение')
+            .replace('application', 'приложение')
+            .replace('project', 'проект');
+    }
+    translateLayer(layer) {
+        const map = {
+            'Presentation': 'Представление',
+            'Application': 'Приложение',
+            'Domain': 'Домен',
+            'Infrastructure': 'Инфраструктура',
+        };
+        return map[layer] || layer;
+    }
+    translateProblem(title) {
+        const map = {
+            'God Object': 'God Object (слишком большой файл)',
+            'Large File': 'Большой файл',
+            'High Complexity': 'Высокая сложность',
+            'Circular Dependencies': 'Циклические зависимости',
+            'Flat Structure': 'Плоская структура',
+        };
+        return map[title] || title;
+    }
+    translateSuggestion(suggestion) {
+        return suggestion
+            .replace('Split into smaller', 'Разбейте на меньшие')
+            .replace('Consider breaking', 'Рассмотрите разбиение')
+            .replace('Extract related functions', 'Вынесите связанные функции')
+            .replace('Break cycles by', 'Разорвите циклы через')
+            .replace('Organize files into', 'Организуйте файлы в')
+            .replace('focused modules', 'модули с одной ответственностью')
+            .replace('feature-based', 'фича-ориентированные')
+            .replace('layer-based', 'слой-ориентированные')
+            .replace('directories', 'директории');
+    }
+    translateRecommendation(rec) {
+        return rec
+            .replace('Address', 'Решите')
+            .replace('critical issues first', 'критические проблемы в первую очередь')
+            .replace('Define clear architectural boundaries', 'Определите чёткие архитектурные границы')
+            .replace('current structure is unclear', 'текущая структура неясна')
+            .replace('Consider implementing', 'Рассмотрите внедрение')
+            .replace('to separate data access logic', 'для разделения логики доступа к данным')
+            .replace('Structure code into clear layers', 'Структурируйте код в чёткие слои')
+            .replace('for better maintainability', 'для лучшей поддерживаемости')
+            .replace('Apply Single Responsibility Principle', 'Применяйте принцип единой ответственности')
+            .replace('each module should do one thing well', 'каждый модуль должен делать одно дело хорошо');
+    }
+}
+//# sourceMappingURL=ai-narrator.js.map