archicore 0.4.2 → 0.4.4

package/dist/cli/commands/interactive.js

@@ -520,6 +520,11 @@ async function handleCommand(input) {
         case 'documentation':
             await handleDocsCommand(args);
             break;
+        case 'narrative':
+        case 'story':
+        case 'explain':
+            await handleNarrativeCommand();
+            break;
         case 'status':
             await handleStatusCommand();
             break;
@@ -965,7 +970,8 @@ async function handleQuery(query) {
                 content: m.content,
             }));
         }
-        const response = await apiFetch(`${config.serverUrl}/api/projects/${state.projectId}/ask`, {
+        // Используем enhanced endpoint для расширенных ответов
+        const response = await apiFetch(`${config.serverUrl}/api/projects/${state.projectId}/ask-enhanced`, {
             method: 'POST',
             body: JSON.stringify({
                 question: query,
@@ -986,6 +992,55 @@ async function handleQuery(query) {
         for (const line of lines) {
             console.log('  ' + line);
         }
+        // Показываем диаграммы если есть
+        if (data.diagrams && data.diagrams.length > 0) {
+            for (const diagram of data.diagrams) {
+                console.log();
+                console.log(colors.secondary(`  📊 ${diagram.title}:`));
+                console.log(diagram.content);
+            }
+        }
+        // Показываем подсказки по производительности если есть
+        if (data.performanceHints && data.performanceHints.length > 0) {
+            console.log();
+            console.log(colors.warning('  ⚡ Подсказки по производительности:'));
+            for (const hint of data.performanceHints) {
+                const icon = hint.severity === 'critical' ? '🔴' :
+                    hint.severity === 'warning' ? '🟡' : '🔵';
+                console.log();
+                console.log(colors.highlight(`  ${icon} ${hint.type}: ${hint.description}`));
+                console.log(colors.muted(`     📍 ${hint.file}:${hint.line}`));
+                console.log(colors.info(`     💡 ${hint.suggestion}`));
+                console.log(colors.muted(`     📈 ${hint.estimatedImpact}`));
+                if (hint.codeExample) {
+                    console.log(colors.dim(hint.codeExample));
+                }
+            }
+        }
+        // Показываем сгенерированные тесты если есть
+        if (data.generatedTests && data.generatedTests.length > 0) {
+            console.log();
+            console.log(colors.success('  🧪 Сгенерированные тесты:'));
+            for (const test of data.generatedTests) {
+                console.log();
+                console.log(colors.muted(`  // Тест для ${test.functionName} (${test.testFramework})`));
+                console.log(colors.dim(`  // Файл: ${test.filePath}`));
+                console.log(colors.dim('  ```' + test.language));
+                const testLines = test.testCode.split('\n');
+                for (const tl of testLines) {
+                    console.log('  ' + tl);
+                }
+                console.log(colors.dim('  ```'));
+            }
+        }
+        // Показываем follow-up suggestions если есть
+        if (data.followUpSuggestions && data.followUpSuggestions.length > 0) {
+            console.log();
+            console.log(colors.secondary('  📌 Связанные вопросы:'));
+            data.followUpSuggestions.forEach((suggestion, i) => {
+                console.log(colors.muted(`     [${i + 1}] ${suggestion.icon} ${suggestion.question}`));
+            });
+        }
         // Save assistant response to history
         if (state.conversationSession) {
             await addMessage(state.conversationSession, 'assistant', answer, {
@@ -1389,6 +1444,101 @@ async function handleDocsCommand(args) {
         throw error;
     }
 }
+/**
+ * /narrative command - AI Narrator: человекопонятное описание проекта
+ *
+ * Показывает:
+ * - Что это за проект
+ * - Стек технологий
+ * - Архитектуру и паттерны
+ * - Проблемные места
+ * - Рекомендации
+ */
+async function handleNarrativeCommand() {
+    if (!state.projectId) {
+        printError('No project indexed');
+        printInfo('Use /index first');
+        return;
+    }
+    const spinner = createSpinner('Analyzing project architecture...').start();
+    try {
+        const config = await loadConfig();
+        const response = await apiFetch(`${config.serverUrl}/api/projects/${state.projectId}/narrative?language=ru`);
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({}));
+            throw new Error(error.error || 'Failed to generate narrative');
+        }
+        const data = await response.json();
+        spinner.succeed('Analysis complete');
+        // Красивый вывод в консоль
+        console.log();
+        console.log(colors.primary('═══════════════════════════════════════════════════════════════'));
+        console.log(colors.primary('                    AI NARRATOR - Анализ проекта'));
+        console.log(colors.primary('═══════════════════════════════════════════════════════════════'));
+        console.log();
+        const report = data.report;
+        // Обзор
+        console.log(colors.highlight('📋 ОБЗОР'));
+        console.log(`   Тип: ${colors.secondary(report.summary.projectType)}`);
+        console.log(`   Язык: ${colors.secondary(report.summary.primaryLanguage)}`);
+        console.log(`   Файлов: ${colors.secondary(String(report.summary.totalFiles))}`);
+        console.log(`   Символов: ${colors.secondary(String(report.summary.totalSymbols))}`);
+        console.log(`   Строк кода: ${colors.secondary(report.summary.linesOfCode.toLocaleString())}`);
+        console.log();
+        // Стек технологий
+        console.log(colors.highlight('🛠️  СТЕК ТЕХНОЛОГИЙ'));
+        if (report.techStack.frontend.length > 0) {
+            console.log(`   Frontend: ${colors.secondary(report.techStack.frontend.join(', '))}`);
+        }
+        if (report.techStack.backend.length > 0) {
+            console.log(`   Backend: ${colors.secondary(report.techStack.backend.join(', '))}`);
+        }
+        if (report.techStack.database.length > 0) {
+            console.log(`   Database: ${colors.secondary(report.techStack.database.join(', '))}`);
+        }
+        console.log();
+        // Архитектура
+        console.log(colors.highlight('🏗️  АРХИТЕКТУРА'));
+        console.log(`   Паттерн: ${colors.secondary(report.architecture.detected)} (${report.architecture.confidence}%)`);
+        if (report.architecture.patterns.length > 0) {
+            console.log('   Используются:');
+            for (const pattern of report.architecture.patterns.slice(0, 5)) {
+                console.log(`     • ${pattern.name} (${pattern.confidence}%)`);
+            }
+        }
+        console.log();
+        // Проблемы
+        if (report.problems.length > 0) {
+            console.log(colors.highlight('⚠️  ПРОБЛЕМНЫЕ МЕСТА'));
+            for (const problem of report.problems.slice(0, 5)) {
+                const icon = problem.severity === 'critical' ? '🔴' :
+                    problem.severity === 'warning' ? '🟡' : '🔵';
+                console.log(`   ${icon} ${colors.error(problem.title)}`);
+                console.log(`      ${problem.description}`);
+                console.log(`      💡 ${colors.muted(problem.suggestion)}`);
+                console.log();
+            }
+        }
+        // Рекомендации
+        if (report.recommendations.length > 0) {
+            console.log(colors.highlight('💡 РЕКОМЕНДАЦИИ'));
+            for (let i = 0; i < Math.min(report.recommendations.length, 5); i++) {
+                console.log(`   ${i + 1}. ${report.recommendations[i]}`);
+            }
+            console.log();
+        }
+        console.log(colors.primary('═══════════════════════════════════════════════════════════════'));
+        console.log();
+        // Также выводим полный Markdown нарратив
+        printInfo('Полный отчёт в формате Markdown:');
+        console.log();
+        console.log(colors.muted(data.narrative));
+    }
+    catch (error) {
+        spinner.fail('Analysis failed');
+        printError(error instanceof Error ? error.message : 'Unknown error');
+    }
+}
 /**
  * /history command - View and search conversation history
  *

package/dist/cli/ui/prompt.js

@@ -70,6 +70,7 @@ export function printHelp() {
     console.log();
     const commands = [
         ['/index', 'Index current project'],
+        ['/narrative', 'AI Narrator - describe architecture'],
         ['/analyze [desc]', 'Run impact analysis'],
         ['/search <query>', 'Semantic code search'],
         ['/dead-code', 'Find dead code'],

package/dist/cli/utils/upload-utils.js

@@ -14,17 +14,21 @@ function debugLog(message) {
         debugLog(` ${message}`);
     }
 }
-// Лимиты для chunked upload (оптимизировано для очень больших проектов и нестабильных соединений)
-const MAX_PAYLOAD_SIZE = 3 * 1024 * 1024; // 3MB per chunk (уменьшено для надёжности на медленных соединениях)
-const MAX_SYMBOLS_PER_CHUNK = 1500; // Меньше символов на chunk для стабильности
-const MAX_FILES_PER_CHUNK = 30; // Меньше файлов на chunk для стабильности
-const UPLOAD_TIMEOUT = 300000; // 5 минут на chunk (увеличено для медленных соединений)
-const MAX_RETRIES = 7; // Ещё больше попыток для нестабильных сетей
-// Лимиты для минимальной загрузки
-const MINIMAL_MAX_SYMBOLS = 10000;
-const MINIMAL_MAX_FILES = 500;
+// Лимиты для single request upload (оптимизировано для средних проектов)
+// ВАЖНО: chunked upload требует одного инстанса сервера (in-memory sessions)
+// Для PM2 cluster mode используем single request до 50K символов
+const MAX_PAYLOAD_SIZE = 50 * 1024 * 1024; // 50MB - увеличено для single request
+const SINGLE_REQUEST_MAX_SYMBOLS = 50000; // До 50K символов - single request
+const UPLOAD_TIMEOUT = 600000; // 10 минут для больших проектов
+const MAX_RETRIES = 5; // Retry для нестабильных соединений
+// Лимиты для chunked upload (только для очень больших проектов >50K символов)
+const MAX_SYMBOLS_PER_CHUNK = 5000; // Больше символов на chunk
+const MAX_FILES_PER_CHUNK = 100; // Больше файлов на chunk
+// Лимиты для минимальной загрузки (fallback)
+const MINIMAL_MAX_SYMBOLS = 20000;
+const MINIMAL_MAX_FILES = 1000;
 // Порог для "очень большого" проекта (пропускаем fileContents)
-const VERY_LARGE_PROJECT_SYMBOLS = 30000;
+const VERY_LARGE_PROJECT_SYMBOLS = 100000;
 /**
  * Определение размера JSON в байтах
  */
@@ -221,21 +225,43 @@ export async function uploadIndexData(projectId, data, onProgress) {
     const url = `${config.serverUrl}/api/projects/${projectId}/upload-index`;
     // Оценка размера данных
     const estimatedSize = estimateJsonSize(data);
-    const isLargeProject = estimatedSize > MAX_PAYLOAD_SIZE ||
-        data.symbols.length > MAX_SYMBOLS_PER_CHUNK * 2;
     onProgress?.({
         phase: 'preparing',
         current: 0,
         total: 100,
-        message: `Preparing upload (${(estimatedSize / 1024 / 1024).toFixed(1)} MB)...`,
+        message: `Preparing upload (${(estimatedSize / 1024 / 1024).toFixed(1)} MB, ${data.symbols.length} symbols)...`,
     });
-    // Для небольших проектов - обычная загрузка
-    if (!isLargeProject) {
+    // ВАЖНО: Chunked upload НЕ работает с PM2 cluster mode (разные процессы = разная память)
+    // Поэтому для проектов до 50K символов ВСЕГДА используем single request
+    // Если payload слишком большой - урезаем данные вместо chunked upload
+    if (data.symbols.length <= SINGLE_REQUEST_MAX_SYMBOLS) {
+        // Проект средний - используем single request
+        // Если payload > 50MB, урезаем fileContents
+        let uploadData = data;
+        if (estimatedSize > MAX_PAYLOAD_SIZE) {
+            debugLog(` Payload ${(estimatedSize / 1024 / 1024).toFixed(1)}MB exceeds limit, trimming fileContents`);
+            onProgress?.({
+                phase: 'preparing',
+                current: 0,
+                total: 100,
+                message: `Optimizing payload (trimming file contents)...`,
+            });
+            // Урезаем fileContents чтобы уместиться в лимит
+            const maxFileContents = Math.floor(data.fileContents.length * (MAX_PAYLOAD_SIZE / estimatedSize));
+            uploadData = {
+                ...data,
+                fileContents: data.fileContents.slice(0, Math.max(maxFileContents, 100)),
+            };
+            const newSize = estimateJsonSize(uploadData);
+            debugLog(` Trimmed payload to ${(newSize / 1024 / 1024).toFixed(1)}MB (${uploadData.fileContents.length} files)`);
+        }
         debugLog(` Using single request upload for ${data.symbols.length} symbols`);
-        return uploadSingleRequest(url, projectId, data, config.accessToken || '', onProgress);
+        return uploadSingleRequest(url, projectId, uploadData, config.accessToken || '', onProgress);
     }
-    // Для больших проектов - chunked upload
-    debugLog(` Using chunked upload for large project (${data.symbols.length} symbols)`);
+    // Проект очень большой (>50K символов) - chunked upload
+    // ВНИМАНИЕ: требует PM2 -i 1 (один инстанс)
+    debugLog(` Using chunked upload for very large project (${data.symbols.length} symbols)`);
+    console.log('  ⚠ Very large project (>50K symbols). Chunked upload requires single server instance (PM2 -i 1).');
     return uploadChunked(url, projectId, data, config.accessToken || '', onProgress);
 }
 /**

package/dist/orchestrator/index.js

@@ -391,6 +391,72 @@ A: "✅ Компонент Comments найден в 3 файлах:
                 prompt += `- ${bc.name}: ${bc.description}\n`;
             }
         }
+        // === SMART CONTEXT: умный контекст от ContextBuilder ===
+        if (context?.smartContext) {
+            const sc = context.smartContext;
+            prompt += '\n\n###SMART CONTEXT (ТОЧНЫЙ ПОИСК)###\n';
+            prompt += `Намерение пользователя: ${sc.intent}\n`;
+            prompt += `Проект: ${sc.projectStats.totalFiles} файлов, ${sc.projectStats.totalSymbols} символов\n`;
+            prompt += `Языки: ${sc.projectStats.languages.join(', ')}\n`;
+            // Найденные символы с кодом
+            if (sc.symbols.length > 0) {
+                prompt += `\n## НАЙДЕННЫЕ СИМВОЛЫ (${sc.symbols.length}):\n`;
+                prompt += `⚠️ ЭТО ТОЧНЫЕ РЕЗУЛЬТАТЫ ПОИСКА - используй их в ответе!\n\n`;
+                for (const sym of sc.symbols.slice(0, 5)) {
+                    const cleanPath = sanitizePath(sym.file);
+                    prompt += `### ${sym.type.toUpperCase()}: ${sym.name}\n`;
+                    prompt += `📍 Файл: ${cleanPath}:${sym.line}\n`;
+                    prompt += `Уверенность: ${Math.round(sym.confidence * 100)}%\n`;
+                    prompt += '```\n' + sym.snippet + '\n```\n';
+                    if (sym.usedIn.length > 0) {
+                        prompt += `📎 Используется в ${sym.usedIn.length} местах:\n`;
+                        for (const usage of sym.usedIn.slice(0, 3)) {
+                            const usageCleanPath = sanitizePath(usage.file);
+                            prompt += `   - ${usageCleanPath}:${usage.line}: \`${usage.snippet}\`\n`;
+                        }
+                        if (sym.usedIn.length > 3) {
+                            prompt += `   ... и ещё ${sym.usedIn.length - 3} мест(а)\n`;
+                        }
+                    }
+                    if (sym.calledBy.length > 0) {
+                        prompt += `📞 Вызывается из: ${sym.calledBy.slice(0, 5).map(f => sanitizePath(f)).join(', ')}\n`;
+                    }
+                    prompt += '\n';
+                }
+                if (sc.symbols.length > 5) {
+                    prompt += `... и ещё ${sc.symbols.length - 5} символов найдено\n`;
+                }
+            }
+            // Найденные проблемы (баги, уязвимости)
+            if (sc.issues.length > 0) {
+                prompt += `\n## НАЙДЕННЫЕ ПРОБЛЕМЫ (${sc.issues.length}):\n`;
+                prompt += `⚠️ ОБЯЗАТЕЛЬНО УПОМЯНИ ЭТИ ПРОБЛЕМЫ В ОТВЕТЕ!\n\n`;
+                const severityIcons = {
+                    critical: '🔴 CRITICAL',
+                    high: '🟠 HIGH',
+                    medium: '🟡 MEDIUM',
+                    low: '🔵 LOW'
+                };
+                for (const issue of sc.issues.slice(0, 10)) {
+                    const cleanPath = sanitizePath(issue.file);
+                    prompt += `${severityIcons[issue.severity]}: ${issue.message}\n`;
+                    prompt += `   📍 ${cleanPath}:${issue.line}\n`;
+                    prompt += `   Код: \`${issue.snippet}\`\n`;
+                    prompt += `   💡 ${issue.suggestion}\n\n`;
+                }
+                if (sc.issues.length > 10) {
+                    prompt += `... и ещё ${sc.issues.length - 10} проблем\n`;
+                }
+            }
+            // Зависимости
+            if (sc.dependencies.length > 0) {
+                prompt += `\n## ЗАВИСИМОСТИ:\n`;
+                for (const dep of sc.dependencies.slice(0, 10)) {
+                    prompt += `   ${sanitizePath(dep.from)} → ${sanitizePath(dep.to)}\n`;
+                }
+            }
+            prompt += '\n###END SMART CONTEXT###\n';
+        }
         if (context?.semanticMemory && context.semanticMemory.length > 0) {
             const totalResults = context.semanticMemory.length;
             const maxResults = Math.min(totalResults, 30); // Увеличено с 10 до 30
@@ -419,7 +485,7 @@ A: "✅ Компонент Comments найден в 3 файлах:
             }
             prompt += '\n###END PROJECT FILES###';
         }
-        else {
+        else if (!context?.smartContext) {
             prompt += '\n\n###PROJECT FILES: EMPTY###\nNo code indexed. Respond: "Проект не проиндексирован. Запустите индексацию."';
         }
         return prompt;

package/dist/server/routes/api.js

@@ -528,6 +528,54 @@ apiRouter.post('/projects/:id/ask', authMiddleware, checkProjectAccess, async (r
         res.status(500).json({ error: 'Failed to process question' });
     }
 });
+/**
+ * POST /api/projects/:id/ask-enhanced
+ * Задать вопрос AI-архитектору с расширенным ответом
+ * Включает: follow-up suggestions, диаграммы, тесты, performance hints
+ */
+apiRouter.post('/projects/:id/ask-enhanced', authMiddleware, checkProjectAccess, async (req, res) => {
+    try {
+        const { id } = req.params;
+        const { question, language } = req.body;
+        const userId = getUserId(req);
+        if (!question) {
+            res.status(400).json({ error: 'Question is required' });
+            return;
+        }
+        // Input validation
+        if (typeof question !== 'string') {
+            res.status(400).json({ error: 'Invalid question format' });
+            return;
+        }
+        const MAX_QUESTION_LENGTH = 5000;
+        if (question.length > MAX_QUESTION_LENGTH) {
+            res.status(400).json({ error: `Question too long. Maximum ${MAX_QUESTION_LENGTH} characters.` });
+            return;
+        }
+        // Sanitize question
+        const sanitizedQuestion = question
+            .replace(/\0/g, '')
+            .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, '');
+        // Check request limit
+        if (userId) {
+            const usageResult = await authService.checkAndUpdateUsage(userId, 'request');
+            if (!usageResult.allowed) {
+                res.status(429).json({
+                    error: 'Request limit reached',
+                    message: `You have reached your daily request limit (${usageResult.limit})`,
+                    usage: { used: usageResult.limit, limit: usageResult.limit, remaining: 0 }
+                });
+                return;
+            }
+        }
+        const enhancedResponse = await projectService.askArchitectEnhanced(id, sanitizedQuestion, language || 'en');
+        res.json(enhancedResponse);
+    }
+    catch (error) {
+        Logger.error('Failed to ask architect (enhanced):', error);
+        res.status(500).json({ error: 'Failed to process question' });
+    }
+});
 /**
  * GET /api/projects/:id/stats
  * Получить статистику проекта
@@ -755,6 +803,28 @@ apiRouter.post('/projects/:id/documentation', authMiddleware, checkProjectAccess
         res.status(500).json({ error: 'Failed to generate documentation' });
     }
 });
+/**
+ * GET /api/projects/:id/narrative
+ * AI Narrator - человекопонятное описание архитектуры проекта
+ */
+apiRouter.get('/projects/:id/narrative', authMiddleware, checkProjectAccess, async (req, res) => {
+    try {
+        const { id } = req.params;
+        const language = req.query.language || 'ru';
+        const report = await projectService.getNarrative(id, language);
+        res.json({
+            success: true,
+            report,
+            // Отдельно текстовый нарратив для удобства
+            narrative: language === 'ru' ? report.narrativeRu : report.narrative,
+        });
+    }
+    catch (error) {
+        Logger.error('Failed to generate narrative:', error);
+        const errorMessage = error instanceof Error ? error.message : 'Failed to generate narrative';
+        res.status(500).json({ error: errorMessage });
+    }
+});
 /**
  * GET /api/projects/:id/index-progress
  * Server-Sent Events endpoint for real-time indexing progress

package/dist/server/services/project-service.d.ts

@@ -12,6 +12,8 @@ import { DuplicationResult } from '../../analyzers/duplication.js';
 import { SecurityResult } from '../../analyzers/security.js';
 import { RefactoringResult } from '../../refactoring/index.js';
 import { ExportData } from '../../export/index.js';
+import { NarratorReport } from '../../analyzers/ai-narrator.js';
+import { EnhancedResponse } from '../../analyzers/response-enhancer.js';
 export interface Project {
     id: string;
     name: string;
@@ -89,6 +91,11 @@ export declare class ProjectService {
     }>;
     semanticSearch(projectId: string, query: string, limit?: number): Promise<unknown[]>;
     askArchitect(projectId: string, question: string, language?: 'en' | 'ru'): Promise<string>;
+    /**
+     * Расширенный ответ архитектора с дополнительными инструментами
+     * Включает: follow-up suggestions, диаграммы, тесты, performance hints
+     */
+    askArchitectEnhanced(projectId: string, question: string, language?: 'en' | 'ru'): Promise<EnhancedResponse>;
     getStatistics(projectId: string): Promise<{
         project: Project;
         indexStats: ProjectStats | null;
@@ -188,5 +195,9 @@ export declare class ProjectService {
      * Построить текстовое представление структуры файлов
      */
     private buildFileStructure;
+    /**
+     * AI Narrator - человекопонятное описание архитектуры проекта
+     */
+    getNarrative(projectId: string, _language?: 'en' | 'ru'): Promise<NarratorReport>;
 }
 //# sourceMappingURL=project-service.d.ts.map

package/dist/server/services/project-service.js

@@ -22,6 +22,9 @@ import { DuplicationDetector } from '../../analyzers/duplication.js';
 import { SecurityAnalyzer } from '../../analyzers/security.js';
 import { RefactoringEngine } from '../../refactoring/index.js';
 import { GitHubService } from '../../github/github-service.js';
+import { AINarrator } from '../../analyzers/ai-narrator.js';
+import { ContextBuilder } from '../../analyzers/context-builder.js';
+import { createResponseEnhancer } from '../../analyzers/response-enhancer.js';
 /**
  * Sanitize file paths to hide server directories
  * Converts absolute paths to relative project paths
@@ -430,6 +433,20 @@ export class ProjectService {
         const projectMetadata = analyzeProjectStack(project.path);
         // Загружаем содержимое файлов для полного контекста
         const fileContents = await this.getFileContents(projectId);
+        // === SMART CONTEXT: используем ContextBuilder для умного поиска ===
+        let smartContext = null;
+        if (data.symbols && data.graph) {
+            try {
+                const contextBuilder = new ContextBuilder(data.symbols, data.graph, fileContents, {
+                    framework: projectMetadata?.framework,
+                });
+                smartContext = await contextBuilder.buildContext(question);
+                Logger.info(`Smart context: intent=${smartContext.intent}, symbols=${smartContext.symbols.length}, issues=${smartContext.issues.length}`);
+            }
+            catch (err) {
+                Logger.warn('Smart context builder failed:', err);
+            }
+        }
         // Ищем релевантный контекст (если есть семантическая память)
         let searchResults = [];
         if (data.semanticMemory) {
@@ -490,15 +507,72 @@ export class ProjectService {
                 }
             }
         }
-        Logger.debug(`Passing ${searchResults.length} context items + project metadata to AI`);
+        Logger.debug(`Passing ${searchResults.length} context items + smart context + project metadata to AI`);
         const answer = await data.orchestrator.answerArchitecturalQuestion(question, {
             architecture: data.architecture.getModel(),
             semanticMemory: searchResults,
             language,
-            projectMetadata: projectMetadata || undefined
+            projectMetadata: projectMetadata || undefined,
+            smartContext: smartContext || undefined
         });
         return answer;
     }
+    /**
+     * Расширенный ответ архитектора с дополнительными инструментами
+     * Включает: follow-up suggestions, диаграммы, тесты, performance hints
+     */
+    async askArchitectEnhanced(projectId, question, language = 'en') {
+        const project = this.projects.get(projectId);
+        if (!project) {
+            throw new Error(`Project not found: ${projectId}`);
+        }
+        const data = await this.getProjectData(projectId);
+        const fileContents = await this.getFileContents(projectId);
+        // Строим умный контекст
+        let smartContext = null;
+        if (data.symbols && data.graph) {
+            const contextBuilder = new ContextBuilder(data.symbols, data.graph, fileContents);
+            smartContext = await contextBuilder.buildContext(question);
+        }
+        // Получаем базовый ответ
+        const answer = await this.askArchitect(projectId, question, language);
+        // Создаём энхансер
+        if (!data.graph || !data.symbols) {
+            // Возвращаем минимальный ответ без улучшений
+            return {
+                answer,
+                followUpSuggestions: [],
+                diagrams: [],
+                generatedTests: [],
+                performanceHints: [],
+                metadata: {
+                    intent: 'general',
+                    processingTime: 0,
+                    symbolsAnalyzed: 0,
+                    filesAnalyzed: 0,
+                },
+            };
+        }
+        const enhancer = createResponseEnhancer(data.graph, data.symbols, fileContents);
+        // Если контекст есть - улучшаем ответ
+        if (smartContext) {
+            return enhancer.enhance(answer, smartContext);
+        }
+        // Fallback - минимальный ответ
+        return {
+            answer,
+            followUpSuggestions: [],
+            diagrams: [],
+            generatedTests: [],
+            performanceHints: [],
+            metadata: {
+                intent: 'general',
+                processingTime: 0,
+                symbolsAnalyzed: 0,
+                filesAnalyzed: 0,
+            },
+        };
+    }
     async getStatistics(projectId) {
         const project = this.projects.get(projectId);
         if (!project) {
@@ -1080,5 +1154,26 @@ ${functions.slice(0, 30).map(f => `- \`${f.name}\` - ${sanitizePath(f.filePath)}
         };
         return renderTree(tree);
     }
+    /**
+     * AI Narrator - человекопонятное описание архитектуры проекта
+     */
+    async getNarrative(projectId, _language = 'ru') {
+        const project = this.projects.get(projectId);
+        if (!project) {
+            throw new Error(`Project not found: ${projectId}`);
+        }
+        const data = await this.getProjectData(projectId);
+        if (!data.graph || !data.symbols) {
+            throw new Error('Project not indexed. Please index first via CLI.');
+        }
+        const fileContents = await this.getFileContents(projectId);
+        // Анализируем стек технологий
+        const { analyzeProjectStack } = await import('../../utils/project-analyzer.js');
+        const projectMetadata = analyzeProjectStack(project.path);
+        const narrator = new AINarrator();
+        const report = await narrator.analyze(data.graph, data.symbols, fileContents, projectMetadata || undefined);
+        Logger.success(`AI Narrator generated report for: ${project.name}`);
+        return report;
+    }
 }
 //# sourceMappingURL=project-service.js.map

package/dist/types/index.d.ts

@@ -233,6 +233,50 @@ export interface LLMContext {
     recentChanges?: Change[];
     language?: 'en' | 'ru';
     projectMetadata?: ProjectMetadata;
+    smartContext?: {
+        intent: string;
+        query: string;
+        symbols: Array<{
+            name: string;
+            type: string;
+            file: string;
+            line: number;
+            snippet: string;
+            usedIn: Array<{
+                file: string;
+                line: number;
+                snippet: string;
+            }>;
+            calls: string[];
+            calledBy: string[];
+            confidence: number;
+        }>;
+        relevantFiles: Array<{
+            path: string;
+            relevance: number;
+            snippet?: string;
+        }>;
+        issues: Array<{
+            type: 'bug' | 'warning' | 'smell' | 'security';
+            severity: 'critical' | 'high' | 'medium' | 'low';
+            file: string;
+            line: number;
+            message: string;
+            snippet: string;
+            suggestion: string;
+        }>;
+        dependencies: Array<{
+            from: string;
+            to: string;
+            type: string;
+        }>;
+        projectStats: {
+            totalFiles: number;
+            totalSymbols: number;
+            languages: string[];
+            framework?: string;
+        };
+    };
 }
 export interface LLMResponse {
     content: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archicore",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "AI Software Architect - code analysis, impact prediction, semantic search",
   "main": "dist/index.js",
   "type": "module",