archicore 0.4.2 → 0.4.4

package/dist/analyzers/context-builder.js

@@ -0,0 +1,708 @@
+/**
+ * ArchiCore Context Builder
+ *
+ * Автоматически собирает релевантный контекст из проекта
+ * для умных ответов ИИ в диалоге
+ */
+import { Logger } from '../utils/logger.js';
+// Паттерны для определения намерения
+const INTENT_PATTERNS = [
+    // Поиск символа
+    { pattern: /где\s+(функци[яю]|метод|класс|переменн[ая]|интерфейс)\s+(\w+)/i, intent: 'find_symbol' },
+    { pattern: /найди?\s+(функци[яю]|метод|класс)\s+(\w+)/i, intent: 'find_symbol' },
+    { pattern: /where\s+is\s+(function|method|class|variable)\s+(\w+)/i, intent: 'find_symbol' },
+    { pattern: /find\s+(function|method|class)\s+(\w+)/i, intent: 'find_symbol' },
+    { pattern: /покажи\s+(функци[яю]|метод|класс)\s+(\w+)/i, intent: 'find_symbol' },
+    // Поиск использования
+    { pattern: /где\s+используется\s+(\w+)/i, intent: 'find_usage' },
+    { pattern: /кто\s+вызывает\s+(\w+)/i, intent: 'find_usage' },
+    { pattern: /where\s+is\s+(\w+)\s+used/i, intent: 'find_usage' },
+    { pattern: /who\s+calls\s+(\w+)/i, intent: 'find_usage' },
+    // Объяснение потока
+    { pattern: /как\s+работает\s+(\w+)/i, intent: 'explain_flow' },
+    { pattern: /объясни\s+(\w+)/i, intent: 'explain_flow' },
+    { pattern: /how\s+does\s+(\w+)\s+work/i, intent: 'explain_flow' },
+    { pattern: /explain\s+(\w+)/i, intent: 'explain_flow' },
+    // Поиск багов
+    { pattern: /найди\s+(баги?|ошибки?|проблемы?)/i, intent: 'find_bugs' },
+    { pattern: /есть\s+ли\s+(баги?|ошибки?|проблемы?)/i, intent: 'find_bugs' },
+    { pattern: /find\s+(bugs?|errors?|issues?|problems?)/i, intent: 'find_bugs' },
+    { pattern: /check\s+for\s+(bugs?|errors?)/i, intent: 'find_bugs' },
+    { pattern: /что\s+не\s+так/i, intent: 'find_bugs' },
+    // Архитектура
+    { pattern: /архитектур[аы]/i, intent: 'architecture' },
+    { pattern: /структур[аы]\s+проекта/i, intent: 'architecture' },
+    { pattern: /architecture/i, intent: 'architecture' },
+    { pattern: /project\s+structure/i, intent: 'architecture' },
+    // Поиск файла
+    { pattern: /где\s+файл\s+(\w+)/i, intent: 'find_file' },
+    { pattern: /найди\s+файл\s+(\w+)/i, intent: 'find_file' },
+    { pattern: /where\s+is\s+file\s+(\w+)/i, intent: 'find_file' },
+    // Рефакторинг
+    { pattern: /как\s+улучшить/i, intent: 'refactor' },
+    { pattern: /как\s+рефакторить/i, intent: 'refactor' },
+    { pattern: /how\s+to\s+(improve|refactor)/i, intent: 'refactor' },
+];
+// Паттерны багов
+const BUG_PATTERNS = [
+    {
+        name: 'console-log-in-production',
+        pattern: /console\.(log|debug|info)\s*\(/,
+        type: 'smell',
+        severity: 'low',
+        message: 'Console.log в production коде',
+        suggestion: 'Используй Logger или удали debug вывод',
+    },
+    {
+        name: 'todo-fixme',
+        pattern: /(TODO|FIXME|HACK|XXX):/i,
+        type: 'warning',
+        severity: 'low',
+        message: 'Незавершённая задача в коде',
+        suggestion: 'Завершить или создать issue',
+    },
+    {
+        name: 'empty-catch',
+        pattern: /catch\s*\([^)]*\)\s*\{\s*\}/,
+        type: 'bug',
+        severity: 'medium',
+        message: 'Пустой catch блок - ошибки игнорируются',
+        suggestion: 'Добавь обработку или логирование ошибки',
+    },
+    {
+        name: 'hardcoded-password',
+        pattern: /(password|secret|api.?key)\s*[:=]\s*['"][^'"]+['"]/i,
+        type: 'security',
+        severity: 'critical',
+        message: 'Захардкоженный пароль/ключ',
+        suggestion: 'Используй переменные окружения',
+    },
+    {
+        name: 'sql-injection',
+        pattern: /(query|execute)\s*\(\s*[`"'].*\$\{/,
+        type: 'security',
+        severity: 'critical',
+        message: 'Возможная SQL инъекция',
+        suggestion: 'Используй параметризованные запросы',
+    },
+    {
+        name: 'eval-usage',
+        pattern: /\beval\s*\(/,
+        type: 'security',
+        severity: 'high',
+        message: 'Использование eval() - риск инъекции',
+        suggestion: 'Избегай eval, используй безопасные альтернативы',
+    },
+    {
+        name: 'any-type',
+        pattern: /:\s*any\b/,
+        type: 'smell',
+        severity: 'low',
+        message: 'Использование типа any',
+        suggestion: 'Добавь конкретный тип',
+    },
+    {
+        name: 'magic-number',
+        pattern: /[=<>]\s*\d{3,}\b/,
+        type: 'smell',
+        severity: 'low',
+        message: 'Magic number в коде',
+        suggestion: 'Вынеси в именованную константу',
+    },
+    {
+        name: 'no-await',
+        pattern: /async\s+\w+[^}]+\breturn\s+\w+\s*\.\s*\w+\s*\([^)]*\)\s*;?\s*\}/,
+        type: 'bug',
+        severity: 'medium',
+        message: 'Возможно отсутствует await',
+        suggestion: 'Проверь, нужен ли await для async функции',
+    },
+];
+export class ContextBuilder {
+    symbols;
+    graph;
+    fileContents;
+    projectStats;
+    constructor(symbols, graph, fileContents, projectStats) {
+        this.symbols = symbols;
+        this.graph = graph;
+        this.fileContents = fileContents;
+        this.projectStats = {
+            totalFiles: fileContents.size,
+            totalSymbols: symbols.size,
+            languages: this.detectLanguages(),
+            framework: projectStats?.framework,
+        };
+    }
+    /**
+     * Главный метод - строит контекст для вопроса пользователя
+     */
+    async buildContext(userQuery) {
+        Logger.debug(`Building context for: "${userQuery}"`);
+        const intent = this.detectIntent(userQuery);
+        const entities = this.extractEntities(userQuery);
+        const context = {
+            intent,
+            query: userQuery,
+            symbols: [],
+            relevantFiles: [],
+            dependencies: [],
+            issues: [],
+            projectStats: this.projectStats,
+        };
+        // В зависимости от намерения собираем нужный контекст
+        switch (intent) {
+            case 'find_symbol':
+            case 'find_usage':
+                context.symbols = this.searchSymbols(entities);
+                context.dependencies = this.getSymbolDependencies(context.symbols);
+                break;
+            case 'explain_flow':
+                context.symbols = this.searchSymbols(entities);
+                context.dependencies = this.getCallChain(entities);
+                context.relevantFiles = this.getRelevantFiles(entities);
+                break;
+            case 'find_bugs':
+                context.issues = this.findBugs(entities);
+                context.relevantFiles = this.getFilesWithIssues(context.issues);
+                break;
+            case 'architecture':
+                context.relevantFiles = this.getArchitectureFiles();
+                context.dependencies = this.getMainDependencies();
+                break;
+            case 'find_file':
+                context.relevantFiles = this.searchFiles(entities);
+                break;
+            case 'refactor':
+                context.symbols = this.searchSymbols(entities);
+                context.issues = this.findIssuesInSymbols(context.symbols);
+                break;
+            default:
+                // Общий вопрос - ищем по ключевым словам
+                context.symbols = this.searchSymbols(entities);
+                context.relevantFiles = this.getRelevantFiles(entities);
+        }
+        Logger.debug(`Context built: ${context.symbols.length} symbols, ${context.relevantFiles.length} files, ${context.issues.length} issues`);
+        return context;
+    }
+    /**
+     * Определение намерения пользователя
+     */
+    detectIntent(query) {
+        for (const { pattern, intent } of INTENT_PATTERNS) {
+            if (pattern.test(query)) {
+                return intent;
+            }
+        }
+        return 'general';
+    }
+    /**
+     * Извлечение сущностей из запроса (имена функций, файлов и т.д.)
+     */
+    extractEntities(query) {
+        const entities = [];
+        // Извлекаем слова в кавычках
+        const quoted = query.match(/['"`]([^'"`]+)['"`]/g);
+        if (quoted) {
+            entities.push(...quoted.map(q => q.slice(1, -1)));
+        }
+        // Извлекаем camelCase и PascalCase слова
+        const camelCase = query.match(/\b[a-z]+(?:[A-Z][a-z]+)+\b/g);
+        if (camelCase) {
+            entities.push(...camelCase);
+        }
+        const pascalCase = query.match(/\b[A-Z][a-z]+(?:[A-Z][a-z]+)+\b/g);
+        if (pascalCase) {
+            entities.push(...pascalCase);
+        }
+        // Извлекаем слова после ключевых слов
+        const afterKeywords = query.match(/(?:функци[яю]|метод|класс|файл|function|method|class|file)\s+(\w+)/gi);
+        if (afterKeywords) {
+            for (const match of afterKeywords) {
+                const word = match.split(/\s+/).pop();
+                if (word)
+                    entities.push(word);
+            }
+        }
+        // Извлекаем пути к файлам
+        const filePaths = query.match(/[\w\-./\\]+\.(ts|js|php|py|vue|jsx|tsx)/gi);
+        if (filePaths) {
+            entities.push(...filePaths);
+        }
+        return [...new Set(entities)];
+    }
+    /**
+     * Поиск символов по названию (fuzzy)
+     */
+    searchSymbols(entities) {
+        const results = [];
+        const searchTerms = entities.map(e => e.toLowerCase());
+        if (searchTerms.length === 0) {
+            return results;
+        }
+        for (const [name, symbol] of this.symbols) {
+            const nameLower = name.toLowerCase();
+            for (const term of searchTerms) {
+                const confidence = this.calculateMatchConfidence(nameLower, term);
+                if (confidence > 0.3) {
+                    const fileContent = this.fileContents.get(symbol.filePath) || '';
+                    const lines = fileContent.split('\n');
+                    const snippet = this.getSnippet(lines, symbol.location.startLine, 3);
+                    results.push({
+                        name,
+                        type: symbol.kind,
+                        file: symbol.filePath,
+                        line: symbol.location.startLine,
+                        snippet,
+                        usedIn: this.findUsages(name),
+                        calls: this.findCalls(name),
+                        calledBy: this.findCalledBy(name),
+                        confidence,
+                    });
+                    break;
+                }
+            }
+        }
+        // Сортируем по релевантности
+        results.sort((a, b) => b.confidence - a.confidence);
+        return results.slice(0, 10);
+    }
+    /**
+     * Расчёт схожести строк (fuzzy matching)
+     */
+    calculateMatchConfidence(str, query) {
+        // Точное совпадение
+        if (str === query)
+            return 1;
+        // Содержит полностью
+        if (str.includes(query))
+            return 0.9;
+        // Начинается с
+        if (str.startsWith(query))
+            return 0.85;
+        // Заканчивается на
+        if (str.endsWith(query))
+            return 0.8;
+        // Частичное совпадение (для camelCase)
+        const strParts = str.split(/(?=[A-Z])|_|-/).map(p => p.toLowerCase());
+        const queryParts = query.split(/(?=[A-Z])|_|-/).map(p => p.toLowerCase());
+        let matches = 0;
+        for (const qPart of queryParts) {
+            if (strParts.some(sPart => sPart.includes(qPart))) {
+                matches++;
+            }
+        }
+        if (matches > 0) {
+            return 0.5 + (matches / queryParts.length) * 0.3;
+        }
+        return 0;
+    }
+    /**
+     * Получение сниппета кода вокруг строки
+     */
+    getSnippet(lines, line, context) {
+        const start = Math.max(0, line - context - 1);
+        const end = Math.min(lines.length, line + context);
+        return lines
+            .slice(start, end)
+            .map((l, i) => {
+            const lineNum = start + i + 1;
+            const marker = lineNum === line ? '→' : ' ';
+            return `${marker}${lineNum.toString().padStart(4)}│ ${l}`;
+        })
+            .join('\n');
+    }
+    /**
+     * Поиск мест использования символа
+     */
+    findUsages(symbolName) {
+        const usages = [];
+        const regex = new RegExp(`\\b${this.escapeRegex(symbolName)}\\b`, 'g');
+        for (const [file, content] of this.fileContents) {
+            const lines = content.split('\n');
+            for (let i = 0; i < lines.length; i++) {
+                if (regex.test(lines[i])) {
+                    // Пропускаем определение самого символа
+                    const symbol = this.symbols.get(symbolName);
+                    if (symbol && symbol.filePath === file && symbol.location.startLine === i + 1) {
+                        continue;
+                    }
+                    usages.push({
+                        file,
+                        line: i + 1,
+                        snippet: lines[i].trim().substring(0, 100),
+                    });
+                }
+            }
+        }
+        return usages.slice(0, 10);
+    }
+    /**
+     * Что вызывает данный символ
+     */
+    findCalls(symbolName) {
+        const symbol = this.symbols.get(symbolName);
+        if (!symbol)
+            return [];
+        const calls = [];
+        const node = this.graph.nodes.get(symbol.filePath);
+        if (node) {
+            const edges = this.graph.edges.get(symbol.filePath) || [];
+            for (const edge of edges) {
+                if (typeof edge === 'object' && 'target' in edge) {
+                    calls.push(edge.target);
+                }
+                else if (typeof edge === 'string') {
+                    calls.push(edge);
+                }
+            }
+        }
+        return calls.slice(0, 10);
+    }
+    /**
+     * Кто вызывает данный символ
+     */
+    findCalledBy(symbolName) {
+        const calledBy = [];
+        const symbol = this.symbols.get(symbolName);
+        if (!symbol)
+            return [];
+        for (const [file, edges] of this.graph.edges) {
+            for (const edge of edges) {
+                const target = typeof edge === 'object' && 'to' in edge
+                    ? edge.to
+                    : String(edge);
+                if (target === symbol.filePath || target.includes(symbolName)) {
+                    calledBy.push(file);
+                    break;
+                }
+            }
+        }
+        return calledBy.slice(0, 10);
+    }
+    /**
+     * Получение зависимостей для символов
+     */
+    getSymbolDependencies(symbols) {
+        const deps = [];
+        const files = new Set(symbols.map(s => s.file));
+        for (const file of files) {
+            const edges = this.graph.edges.get(file) || [];
+            for (const edge of edges) {
+                const target = typeof edge === 'object' && 'target' in edge
+                    ? edge.target
+                    : String(edge);
+                deps.push({
+                    from: file,
+                    to: target,
+                    type: 'imports',
+                });
+            }
+        }
+        return deps.slice(0, 20);
+    }
+    /**
+     * Получение цепочки вызовов
+     */
+    getCallChain(entities) {
+        const chain = [];
+        const visited = new Set();
+        const traverse = (file, depth) => {
+            if (depth > 3 || visited.has(file))
+                return;
+            visited.add(file);
+            const edges = this.graph.edges.get(file) || [];
+            for (const edge of edges) {
+                const target = typeof edge === 'object' && 'target' in edge
+                    ? edge.target
+                    : String(edge);
+                chain.push({
+                    from: file,
+                    to: target,
+                    type: 'calls',
+                });
+                traverse(target, depth + 1);
+            }
+        };
+        for (const entity of entities) {
+            const symbol = this.symbols.get(entity);
+            if (symbol) {
+                traverse(symbol.filePath, 0);
+            }
+        }
+        return chain;
+    }
+    /**
+     * Поиск релевантных файлов
+     */
+    getRelevantFiles(entities) {
+        const files = [];
+        const searchTerms = entities.map(e => e.toLowerCase());
+        for (const [path, content] of this.fileContents) {
+            let relevance = 0;
+            for (const term of searchTerms) {
+                if (path.toLowerCase().includes(term)) {
+                    relevance += 0.5;
+                }
+                if (content.toLowerCase().includes(term)) {
+                    relevance += 0.3;
+                }
+            }
+            if (relevance > 0) {
+                files.push({
+                    path,
+                    relevance,
+                    snippet: content.substring(0, 200) + '...',
+                });
+            }
+        }
+        files.sort((a, b) => b.relevance - a.relevance);
+        return files.slice(0, 10);
+    }
+    /**
+     * Поиск багов в коде
+     */
+    findBugs(entities) {
+        const issues = [];
+        const filesToCheck = entities.length > 0
+            ? this.getRelevantFiles(entities).map(f => f.path)
+            : Array.from(this.fileContents.keys());
+        for (const file of filesToCheck.slice(0, 50)) {
+            const content = this.fileContents.get(file);
+            if (!content)
+                continue;
+            const lines = content.split('\n');
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                for (const bugPattern of BUG_PATTERNS) {
+                    if (bugPattern.pattern.test(line)) {
+                        issues.push({
+                            type: bugPattern.type,
+                            severity: bugPattern.severity,
+                            file,
+                            line: i + 1,
+                            message: bugPattern.message,
+                            snippet: line.trim().substring(0, 100),
+                            suggestion: bugPattern.suggestion,
+                        });
+                    }
+                }
+            }
+        }
+        // Сортируем по severity
+        const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+        issues.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);
+        return issues.slice(0, 20);
+    }
+    /**
+     * Получение файлов с проблемами
+     */
+    getFilesWithIssues(issues) {
+        const fileMap = new Map();
+        for (const issue of issues) {
+            const count = fileMap.get(issue.file) || 0;
+            fileMap.set(issue.file, count + 1);
+        }
+        return Array.from(fileMap.entries())
+            .map(([path, count]) => ({
+            path,
+            relevance: count,
+        }))
+            .sort((a, b) => b.relevance - a.relevance);
+    }
+    /**
+     * Получение файлов архитектуры
+     */
+    getArchitectureFiles() {
+        const architecturePatterns = [
+            /index\.(ts|js|php)$/,
+            /main\.(ts|js|php)$/,
+            /app\.(ts|js|vue|php)$/,
+            /router/i,
+            /routes/i,
+            /controller/i,
+            /service/i,
+            /model/i,
+            /config/i,
+        ];
+        const files = [];
+        for (const path of this.fileContents.keys()) {
+            for (const pattern of architecturePatterns) {
+                if (pattern.test(path)) {
+                    files.push({
+                        path,
+                        relevance: 1,
+                    });
+                    break;
+                }
+            }
+        }
+        return files.slice(0, 15);
+    }
+    /**
+     * Получение основных зависимостей проекта
+     */
+    getMainDependencies() {
+        const deps = [];
+        const entryPoints = ['index', 'main', 'app', 'server'];
+        for (const [file, edges] of this.graph.edges) {
+            const isEntryPoint = entryPoints.some(ep => file.toLowerCase().includes(ep));
+            if (isEntryPoint || edges.length > 5) {
+                for (const edge of edges.slice(0, 5)) {
+                    const target = typeof edge === 'object' && 'target' in edge
+                        ? edge.target
+                        : String(edge);
+                    deps.push({
+                        from: file,
+                        to: target,
+                        type: 'imports',
+                    });
+                }
+            }
+        }
+        return deps.slice(0, 30);
+    }
+    /**
+     * Поиск файлов по имени
+     */
+    searchFiles(entities) {
+        const files = [];
+        for (const path of this.fileContents.keys()) {
+            for (const entity of entities) {
+                if (path.toLowerCase().includes(entity.toLowerCase())) {
+                    files.push({
+                        path,
+                        relevance: path.toLowerCase() === entity.toLowerCase() ? 1 : 0.5,
+                    });
+                    break;
+                }
+            }
+        }
+        files.sort((a, b) => b.relevance - a.relevance);
+        return files.slice(0, 10);
+    }
+    /**
+     * Поиск проблем в найденных символах
+     */
+    findIssuesInSymbols(symbols) {
+        const issues = [];
+        for (const symbol of symbols) {
+            const content = this.fileContents.get(symbol.file);
+            if (!content)
+                continue;
+            const lines = content.split('\n');
+            const startLine = Math.max(0, symbol.line - 1);
+            const endLine = Math.min(lines.length, symbol.line + 50);
+            for (let i = startLine; i < endLine; i++) {
+                const line = lines[i];
+                for (const bugPattern of BUG_PATTERNS) {
+                    if (bugPattern.pattern.test(line)) {
+                        issues.push({
+                            type: bugPattern.type,
+                            severity: bugPattern.severity,
+                            file: symbol.file,
+                            line: i + 1,
+                            message: bugPattern.message,
+                            snippet: line.trim().substring(0, 100),
+                            suggestion: bugPattern.suggestion,
+                        });
+                    }
+                }
+            }
+        }
+        return issues;
+    }
+    /**
+     * Определение языков в проекте
+     */
+    detectLanguages() {
+        const extensions = new Map();
+        for (const path of this.fileContents.keys()) {
+            const ext = path.split('.').pop()?.toLowerCase() || '';
+            extensions.set(ext, (extensions.get(ext) || 0) + 1);
+        }
+        const langMap = {
+            ts: 'TypeScript',
+            tsx: 'TypeScript/React',
+            js: 'JavaScript',
+            jsx: 'JavaScript/React',
+            php: 'PHP',
+            py: 'Python',
+            vue: 'Vue.js',
+            java: 'Java',
+            go: 'Go',
+            rs: 'Rust',
+            rb: 'Ruby',
+            cs: 'C#',
+        };
+        return Array.from(extensions.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5)
+            .map(([ext]) => langMap[ext] || ext)
+            .filter(Boolean);
+    }
+    /**
+     * Escape regex special characters
+     */
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    /**
+     * Форматирование контекста для LLM промпта
+     */
+    formatForLLM(context) {
+        const parts = [];
+        parts.push(`## Контекст проекта`);
+        parts.push(`Языки: ${context.projectStats.languages.join(', ')}`);
+        parts.push(`Файлов: ${context.projectStats.totalFiles}, Символов: ${context.projectStats.totalSymbols}`);
+        parts.push('');
+        if (context.symbols.length > 0) {
+            parts.push(`## Найденные символы (${context.symbols.length})`);
+            for (const sym of context.symbols.slice(0, 5)) {
+                parts.push(`### ${sym.type} ${sym.name}`);
+                parts.push(`Файл: ${sym.file}:${sym.line}`);
+                parts.push('```');
+                parts.push(sym.snippet);
+                parts.push('```');
+                if (sym.usedIn.length > 0) {
+                    parts.push(`Используется в: ${sym.usedIn.map(u => `${u.file}:${u.line}`).join(', ')}`);
+                }
+                parts.push('');
+            }
+        }
+        if (context.issues.length > 0) {
+            parts.push(`## Найденные проблемы (${context.issues.length})`);
+            for (const issue of context.issues.slice(0, 10)) {
+                const icon = issue.severity === 'critical' ? '🔴' :
+                    issue.severity === 'high' ? '🟠' :
+                        issue.severity === 'medium' ? '🟡' : '🔵';
+                parts.push(`${icon} **${issue.message}** (${issue.severity})`);
+                parts.push(`   ${issue.file}:${issue.line}`);
+                parts.push(`   \`${issue.snippet}\``);
+                parts.push(`   💡 ${issue.suggestion}`);
+                parts.push('');
+            }
+        }
+        if (context.relevantFiles.length > 0) {
+            parts.push(`## Релевантные файлы`);
+            for (const file of context.relevantFiles.slice(0, 5)) {
+                parts.push(`- ${file.path}`);
+            }
+            parts.push('');
+        }
+        if (context.dependencies.length > 0) {
+            parts.push(`## Зависимости`);
+            for (const dep of context.dependencies.slice(0, 10)) {
+                parts.push(`- ${dep.from} → ${dep.to}`);
+            }
+        }
+        return parts.join('\n');
+    }
+}
+/**
+ * Создание билдера контекста из данных проекта
+ */
+export function createContextBuilder(symbols, graph, fileContents, projectStats) {
+    return new ContextBuilder(symbols, graph, fileContents, projectStats);
+}
+//# sourceMappingURL=context-builder.js.map