archicore 0.2.4 → 0.2.5

package/dist/cli/commands/interactive.js

@@ -10,6 +10,8 @@ import { printFormattedError, printStartupError, } from '../utils/error-handler.
 import { isInitialized, getLocalProject } from './init.js';
 import { requireAuth, logout } from './auth.js';
 import { colors, icons, createSpinner, printHelp, printGoodbye, printSection, printSuccess, printError, printWarning, printInfo, printKeyValue, header, } from '../ui/index.js';
+import { createSession, loadLastSession, addMessage, getContextMessages, listSessions, searchHistory, exportSessionAsText, clearAllHistory, } from '../utils/conversation-history.js';
+import { uploadIndexData, analyzeNetworkError, analyzeHttpError, } from '../utils/upload-utils.js';
 // Command registry with descriptions (like Claude CLI)
 const COMMANDS = [
     { name: 'index', aliases: ['i'], description: 'Index your codebase for analysis' },
@@ -23,6 +25,8 @@ const COMMANDS = [
     { name: 'rules', aliases: [], description: 'Check architectural rules' },
     { name: 'docs', aliases: ['documentation'], description: 'Generate architecture documentation' },
     { name: 'export', aliases: [], description: 'Export analysis results' },
+    { name: 'history', aliases: ['hist'], description: 'View and search conversation history' },
+    { name: 'resume', aliases: [], description: 'Resume previous conversation session' },
     { name: 'status', aliases: [], description: 'Show connection and project status' },
     { name: 'clear', aliases: ['cls'], description: 'Clear the screen' },
     { name: 'help', aliases: ['h'], description: 'Show available commands' },
@@ -36,6 +40,7 @@ const state = {
     projectPath: process.cwd(),
     history: [],
     user: null,
+    conversationSession: null,
 };
 // Track token usage for session
 let sessionTokensUsed = 0;
@@ -124,6 +129,23 @@ export async function startInteractiveMode() {
         process.exit(1);
     }
     state.user = user;
+    // Initialize or resume conversation session
+    const lastSession = await loadLastSession(state.projectId || undefined);
+    if (lastSession) {
+        // Check if last session was recent (within 1 hour)
+        const lastActivity = new Date(lastSession.lastActivityAt).getTime();
+        const oneHourAgo = Date.now() - 60 * 60 * 1000;
+        if (lastActivity > oneHourAgo) {
+            state.conversationSession = lastSession;
+            console.log(colors.muted(`  ${icons.info} Resuming previous session (${lastSession.messages.length} messages)`));
+        }
+        else {
+            state.conversationSession = await createSession(state.projectId || undefined, state.projectName || undefined);
+        }
+    }
+    else {
+        state.conversationSession = await createSession(state.projectId || undefined, state.projectName || undefined);
+    }
     // Print welcome
     console.log();
     console.log(header('ArchiCore', 'AI Software Architect'));
@@ -134,6 +156,7 @@ export async function startInteractiveMode() {
     console.log();
     console.log(colors.muted('  Type / to see commands, or ask a question about your code.'));
     console.log(colors.muted('  Press Tab to autocomplete. Type ? for shortcuts.'));
+    console.log(colors.muted('  Use /history to view past conversations, /resume to continue.'));
     console.log();
     // Interactive input with real-time autocomplete
     await startInteractiveInput(state);
@@ -473,6 +496,13 @@ async function handleCommand(input) {
             await logout();
             state.running = false;
             break;
+        case 'history':
+        case 'hist':
+            await handleHistoryCommand(args);
+            break;
+        case 'resume':
+            await handleResumeCommand(args);
+            break;
         default:
             printFormattedError(`Unknown command: /${command}`, {
                 suggestion: 'Use /help to see available commands',
@@ -496,11 +526,24 @@ async function handleIndexCommand() {
             if (response.ok) {
                 const data = await response.json();
                 state.projectId = data.id || data.project?.id;
+                registerSpinner.succeed('Project registered');
+            }
+            else {
+                const errorBody = await response.json().catch(() => ({}));
+                const errorDetails = analyzeHttpError(response.status, errorBody);
+                registerSpinner.fail('Failed to register project');
+                printError(errorDetails.message);
+                printInfo(errorDetails.suggestion);
+                console.log(colors.dim(`  Technical: ${errorDetails.technicalDetails}`));
+                return;
             }
-            registerSpinner.succeed('Project registered');
         }
-        catch {
+        catch (error) {
+            const errorDetails = analyzeNetworkError(error);
             registerSpinner.fail('Failed to register project');
+            printError(errorDetails.message);
+            printInfo(errorDetails.suggestion);
+            console.log(colors.dim(`  Technical: ${errorDetails.technicalDetails}`));
             return;
         }
     }
@@ -524,22 +567,28 @@ async function handleIndexCommand() {
         indexSpinner.update(`Found ${symbols.size} symbols, building graph...`);
         // Строим граф зависимостей
         const graph = codeIndex.buildDependencyGraph(asts, symbols);
-        indexSpinner.update('Reading file contents...');
-        // Читаем содержимое файлов
+        // Определяем размер проекта для оптимизации
+        const isLargeProject = symbols.size > 50000 || asts.size > 1000;
+        // Читаем содержимое файлов (с оптимизацией для больших проектов)
         const fileContents = [];
-        for (const [filePath] of asts) {
-            try {
-                const fullPath = pathModule.default.isAbsolute(filePath)
-                    ? filePath
-                    : pathModule.default.join(state.projectPath, filePath);
-                const content = await fs.readFile(fullPath, 'utf-8');
-                fileContents.push([filePath, content]);
-            }
-            catch {
-                // Игнорируем ошибки чтения
+        if (!isLargeProject) {
+            indexSpinner.update('Reading file contents...');
+            for (const [filePath] of asts) {
+                try {
+                    const fullPath = pathModule.default.isAbsolute(filePath)
+                        ? filePath
+                        : pathModule.default.join(state.projectPath, filePath);
+                    const content = await fs.readFile(fullPath, 'utf-8');
+                    fileContents.push([filePath, content]);
+                }
+                catch {
+                    // Игнорируем ошибки чтения отдельных файлов
+                }
             }
         }
-        indexSpinner.update('Uploading to server...');
+        else {
+            indexSpinner.update('Large project detected, skipping file contents for faster upload...');
+        }
         // Конвертируем Maps в массивы для JSON
         const astsArray = Array.from(asts.entries());
         const symbolsArray = Array.from(symbols.entries());
@@ -547,89 +596,78 @@ async function handleIndexCommand() {
             nodes: Array.from(graph.nodes.entries()),
             edges: Array.from(graph.edges.entries()),
         };
-        // Отправляем на сервер
-        const response = await fetch(`${config.serverUrl}/api/projects/${state.projectId}/upload-index`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${config.accessToken}`,
+        const indexData = {
+            asts: astsArray,
+            symbols: symbolsArray,
+            graph: graphData,
+            fileContents,
+            statistics: {
+                totalFiles: asts.size,
+                totalSymbols: symbols.size,
             },
-            body: JSON.stringify({
-                asts: astsArray,
-                symbols: symbolsArray,
-                graph: graphData,
-                fileContents,
-                statistics: {
-                    totalFiles: asts.size,
-                    totalSymbols: symbols.size,
-                },
-            }),
+        };
+        // Загружаем на сервер с прогрессом и обработкой ошибок
+        const uploadResult = await uploadIndexData(state.projectId, indexData, (progress) => {
+            indexSpinner.update(progress.message);
         });
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => ({}));
-            // If access denied, re-register project with current user
-            if (response.status === 403 && errorData.error?.includes('Access denied')) {
-                indexSpinner.update('Re-registering project with current user...');
-                // Clear old project ID and re-register
-                const reRegisterResponse = await fetch(`${config.serverUrl}/api/projects`, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'Authorization': `Bearer ${config.accessToken}`,
-                    },
-                    body: JSON.stringify({ name: state.projectName, path: state.projectPath }),
-                });
-                if (reRegisterResponse.ok) {
-                    const reData = await reRegisterResponse.json();
-                    state.projectId = reData.id || reData.project?.id;
-                    // Retry upload with new project ID
-                    indexSpinner.update('Uploading to server...');
-                    const retryResponse = await fetch(`${config.serverUrl}/api/projects/${state.projectId}/upload-index`, {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                            'Authorization': `Bearer ${config.accessToken}`,
-                        },
-                        body: JSON.stringify({
-                            asts: astsArray,
-                            symbols: symbolsArray,
-                            graph: graphData,
-                            fileContents,
-                            statistics: {
-                                totalFiles: asts.size,
-                                totalSymbols: symbols.size,
+        if (!uploadResult.success) {
+            // Детальная обработка ошибок
+            indexSpinner.fail('Indexing failed');
+            // Debug output to see what's in the result
+            console.log(colors.dim(`  [DEBUG] uploadResult: ${JSON.stringify(uploadResult, null, 2)}`));
+            if (uploadResult.errorDetails) {
+                const { code, message, suggestion, technicalDetails } = uploadResult.errorDetails;
+                console.log();
+                console.log(colors.error(`  ${icons.error} Error: ${message}`));
+                console.log(colors.warning(`  ${icons.info} ${suggestion}`));
+                if (code === 'FORBIDDEN') {
+                    // Пробуем перерегистрировать проект
+                    console.log(colors.muted('  Attempting to re-register project...'));
+                    try {
+                        const reRegisterResponse = await fetch(`${config.serverUrl}/api/projects`, {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json',
+                                'Authorization': `Bearer ${config.accessToken}`,
                             },
-                        }),
-                    });
-                    if (!retryResponse.ok) {
-                        throw new Error('Upload failed after re-registration');
+                            body: JSON.stringify({ name: state.projectName, path: state.projectPath }),
+                        });
+                        if (reRegisterResponse.ok) {
+                            const reData = await reRegisterResponse.json();
+                            state.projectId = reData.id || reData.project?.id;
+                            printInfo('Project re-registered. Run /index again to complete indexing.');
+                            // Обновляем локальный конфиг
+                            const localProjectRetry = await getLocalProject(state.projectPath);
+                            if (localProjectRetry && state.projectId) {
+                                localProjectRetry.id = state.projectId;
+                                await fs.writeFile(pathModule.default.join(state.projectPath, '.archicore', 'project.json'), JSON.stringify(localProjectRetry, null, 2));
+                            }
+                        }
                     }
-                    // Use retry response for data
-                    const retryData = await retryResponse.json();
-                    indexSpinner.succeed('Project re-registered and indexed');
-                    printKeyValue('Files', String(retryData.statistics?.filesCount || asts.size));
-                    printKeyValue('Symbols', String(retryData.statistics?.symbolsCount || symbols.size));
-                    // Update local config with new project ID
-                    const localProjectRetry = await getLocalProject(state.projectPath);
-                    if (localProjectRetry && state.projectId) {
-                        localProjectRetry.id = state.projectId;
-                        localProjectRetry.indexed = true;
-                        await fs.writeFile(pathModule.default.join(state.projectPath, '.archicore', 'project.json'), JSON.stringify(localProjectRetry, null, 2));
+                    catch {
+                        // Игнорируем ошибку перерегистрации
                     }
-                    return; // Exit early - already handled
-                }
-                else {
-                    throw new Error('Failed to re-register project');
                 }
+                console.log(colors.dim(`  [${code}] ${technicalDetails}`));
             }
             else {
-                throw new Error(errorData.error || 'Upload failed');
+                printError(uploadResult.error || 'Unknown upload error');
             }
+            return;
         }
-        const data = await response.json();
         indexSpinner.succeed('Project indexed and uploaded');
-        printKeyValue('Files', String(data.statistics?.filesCount || asts.size));
-        printKeyValue('Symbols', String(data.statistics?.symbolsCount || symbols.size));
+        // Показываем статистику
+        const stats = uploadResult.statistics;
+        if (stats) {
+            printKeyValue('Files', String(stats.filesCount));
+            printKeyValue('Symbols', String(stats.symbolsCount));
+            if (stats.nodesCount) {
+                printKeyValue('Graph nodes', String(stats.nodesCount));
+            }
+            if (stats.edgesCount) {
+                printKeyValue('Graph edges', String(stats.edgesCount));
+            }
+        }
         // Обновляем локальный конфиг
         const localProject = await getLocalProject(state.projectPath);
         if (localProject) {
@@ -640,7 +678,28 @@ async function handleIndexCommand() {
     }
     catch (error) {
         indexSpinner.fail('Indexing failed');
-        printError(String(error));
+        // Детальный анализ ошибки
+        const errorStr = String(error);
+        if (errorStr.includes('ENOENT') || errorStr.includes('no such file')) {
+            printError('File not found during indexing');
+            printInfo('Some files may have been deleted during the indexing process. Try again.');
+        }
+        else if (errorStr.includes('ENOMEM') || errorStr.includes('heap out of memory')) {
+            printError('Out of memory');
+            printInfo('The project is too large to index. Try increasing Node.js memory limit:');
+            console.log(colors.muted('  NODE_OPTIONS="--max-old-space-size=4096" archicore'));
+        }
+        else if (errorStr.includes('EACCES') || errorStr.includes('permission denied')) {
+            printError('Permission denied');
+            printInfo('Check that you have read access to all project files.');
+        }
+        else {
+            // Общая ошибка
+            const errorDetails = analyzeNetworkError(error);
+            printError(errorDetails.message);
+            printInfo(errorDetails.suggestion);
+            console.log(colors.dim(`  Technical: ${errorDetails.technicalDetails}`));
+        }
     }
 }
 async function handleAnalyzeCommand(args) {
@@ -790,12 +849,30 @@ async function handleQuery(query) {
         printInfo('Use /projects to list and select a project first');
         return;
     }
+    // Save user message to history
+    if (state.conversationSession) {
+        await addMessage(state.conversationSession, 'user', query, {
+            tokens: estimateTokens(query),
+        });
+    }
     const spinner = createSpinner('Thinking...').start();
     try {
         const config = await loadConfig();
+        // Get context from conversation history for better responses
+        let contextMessages = [];
+        if (state.conversationSession) {
+            const history = getContextMessages(state.conversationSession, 10, 3000);
+            contextMessages = history.slice(0, -1).map(m => ({
+                role: m.role,
+                content: m.content,
+            }));
+        }
         const response = await apiFetch(`${config.serverUrl}/api/projects/${state.projectId}/ask`, {
             method: 'POST',
-            body: JSON.stringify({ question: query }),
+            body: JSON.stringify({
+                question: query,
+                context: contextMessages.length > 0 ? contextMessages : undefined,
+            }),
         });
         if (!response.ok)
             throw new Error('Query failed');
@@ -811,6 +888,12 @@ async function handleQuery(query) {
         for (const line of lines) {
             console.log('  ' + line);
         }
+        // Save assistant response to history
+        if (state.conversationSession) {
+            await addMessage(state.conversationSession, 'assistant', answer, {
+                tokens: estimateTokens(answer),
+            });
+        }
         showTokenUsage();
     }
     catch (error) {
@@ -1203,4 +1286,168 @@ async function handleDocsCommand(args) {
         throw error;
     }
 }
+/**
+ * /history command - View and search conversation history
+ *
+ * Usage:
+ *   /history           - Show recent sessions
+ *   /history search <query>  - Search in history
+ *   /history export    - Export current session
+ *   /history clear     - Clear all history
+ */
+async function handleHistoryCommand(args) {
+    const subcommand = args[0]?.toLowerCase();
+    switch (subcommand) {
+        case 'search': {
+            const query = args.slice(1).join(' ');
+            if (!query) {
+                printError('Usage: /history search <query>');
+                return;
+            }
+            const spinner = createSpinner('Searching history...').start();
+            const results = await searchHistory(query, { limit: 15 });
+            spinner.stop();
+            if (results.length === 0) {
+                printWarning('No matches found');
+                return;
+            }
+            printSection(`Search Results (${results.length})`);
+            for (const { session, message } of results) {
+                const date = new Date(message.timestamp).toLocaleDateString();
+                const time = new Date(message.timestamp).toLocaleTimeString();
+                const role = message.role === 'user' ? colors.primary('You') : colors.secondary('ArchiCore');
+                const projectName = session.projectName || 'Unknown project';
+                console.log();
+                console.log(`  ${colors.dim(`[${date} ${time}]`)} ${role} ${colors.dim(`in ${projectName}`)}`);
+                // Show snippet with highlighted query
+                const content = message.content.slice(0, 200);
+                const queryLower = query.toLowerCase();
+                const contentLower = content.toLowerCase();
+                const idx = contentLower.indexOf(queryLower);
+                if (idx >= 0) {
+                    const before = content.slice(0, idx);
+                    const match = content.slice(idx, idx + query.length);
+                    const after = content.slice(idx + query.length);
+                    console.log(`  ${before}${colors.highlight(match)}${after}${content.length >= 200 ? '...' : ''}`);
+                }
+                else {
+                    console.log(`  ${content}${content.length >= 200 ? '...' : ''}`);
+                }
+            }
+            break;
+        }
+        case 'export': {
+            if (!state.conversationSession) {
+                printError('No active session to export');
+                return;
+            }
+            const { writeFile } = await import('fs/promises');
+            const exportContent = exportSessionAsText(state.conversationSession);
+            const filename = `archicore-conversation-${state.conversationSession.id}.txt`;
+            await writeFile(filename, exportContent);
+            printSuccess(`Session exported to ${filename}`);
+            break;
+        }
+        case 'clear': {
+            const count = await clearAllHistory();
+            printSuccess(`Cleared ${count} session(s) from history`);
+            // Create a new session
+            state.conversationSession = await createSession(state.projectId || undefined, state.projectName || undefined);
+            break;
+        }
+        case 'context': {
+            // Show current context being sent to AI
+            if (!state.conversationSession) {
+                printError('No active session');
+                return;
+            }
+            const contextMessages = getContextMessages(state.conversationSession, 10, 2000);
+            printSection(`Context (${contextMessages.length} messages)`);
+            for (const msg of contextMessages) {
+                const role = msg.role === 'user' ? colors.primary('You') : colors.secondary('ArchiCore');
+                const time = new Date(msg.timestamp).toLocaleTimeString();
+                const preview = msg.content.slice(0, 100).replace(/\n/g, ' ');
+                console.log(`  ${colors.dim(`[${time}]`)} ${role}: ${preview}${msg.content.length > 100 ? '...' : ''}`);
+            }
+            break;
+        }
+        default: {
+            // Show recent sessions
+            const sessions = await listSessions({ limit: 10 });
+            if (sessions.length === 0) {
+                printInfo('No conversation history yet');
+                return;
+            }
+            printSection('Recent Sessions');
+            for (const session of sessions) {
+                const startDate = new Date(session.startedAt);
+                const isActive = state.conversationSession?.id === session.id;
+                const activeMarker = isActive ? colors.success(' (active)') : '';
+                console.log();
+                console.log(`  ${colors.primary(session.id)}${activeMarker}`);
+                console.log(`    ${colors.dim('Project:')} ${session.projectName || 'N/A'}`);
+                console.log(`    ${colors.dim('Started:')} ${startDate.toLocaleString()}`);
+                console.log(`    ${colors.dim('Messages:')} ${session.messages.length}`);
+                if (session.metadata?.commandsUsed && session.metadata.commandsUsed.length > 0) {
+                    console.log(`    ${colors.dim('Commands:')} ${session.metadata.commandsUsed.slice(0, 5).join(', ')}`);
+                }
+            }
+            console.log();
+            console.log(colors.muted('  Use /resume <session_id> to continue a session'));
+            console.log(colors.muted('  Use /history search <query> to search in history'));
+            console.log(colors.muted('  Use /history export to save current session'));
+            break;
+        }
+    }
+}
+/**
+ * /resume command - Resume a previous conversation session
+ */
+async function handleResumeCommand(args) {
+    const sessionId = args[0];
+    if (!sessionId) {
+        // Show recent sessions to choose from
+        const sessions = await listSessions({ limit: 5 });
+        if (sessions.length === 0) {
+            printInfo('No sessions available to resume');
+            return;
+        }
+        printSection('Available Sessions');
+        for (const session of sessions) {
+            const date = new Date(session.startedAt).toLocaleString();
+            const messages = session.messages.length;
+            console.log(`  ${colors.primary(session.id)}`);
+            console.log(`    ${session.projectName || 'Unknown'} - ${messages} messages - ${date}`);
+        }
+        console.log();
+        printInfo('Usage: /resume <session_id>');
+        return;
+    }
+    const spinner = createSpinner('Loading session...').start();
+    try {
+        const { loadSession } = await import('../utils/conversation-history.js');
+        const session = await loadSession(sessionId);
+        if (!session) {
+            spinner.fail('Session not found');
+            return;
+        }
+        state.conversationSession = session;
+        spinner.succeed(`Resumed session with ${session.messages.length} messages`);
+        // Show last few messages for context
+        const recentMessages = session.messages.slice(-5);
+        if (recentMessages.length > 0) {
+            console.log();
+            console.log(colors.muted('  Recent messages:'));
+            for (const msg of recentMessages) {
+                const role = msg.role === 'user' ? colors.primary('You') : colors.secondary('ArchiCore');
+                const preview = msg.content.slice(0, 80).replace(/\n/g, ' ');
+                console.log(`    ${role}: ${preview}${msg.content.length > 80 ? '...' : ''}`);
+            }
+        }
+    }
+    catch (error) {
+        spinner.fail('Failed to load session');
+        printError(String(error));
+    }
+}
 //# sourceMappingURL=interactive.js.map

package/dist/cli/utils/conversation-history.d.ts

@@ -0,0 +1,84 @@
+/**
+ * ArchiCore CLI - Conversation History Management
+ *
+ * Сохранение и загрузка истории диалогов между сессиями
+ */
+export interface ConversationMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    timestamp: string;
+    command?: string;
+    tokens?: number;
+}
+export interface ConversationSession {
+    id: string;
+    projectId?: string;
+    projectName?: string;
+    startedAt: string;
+    lastActivityAt: string;
+    messages: ConversationMessage[];
+    metadata?: {
+        totalTokens?: number;
+        commandsUsed?: string[];
+    };
+}
+/**
+ * Создать новую сессию разговора
+ */
+export declare function createSession(projectId?: string, projectName?: string): Promise<ConversationSession>;
+/**
+ * Сохранить сессию на диск
+ */
+export declare function saveSession(session: ConversationSession): Promise<void>;
+/**
+ * Загрузить сессию с диска
+ */
+export declare function loadSession(sessionId: string): Promise<ConversationSession | null>;
+/**
+ * Загрузить последнюю сессию для проекта
+ */
+export declare function loadLastSession(projectId?: string): Promise<ConversationSession | null>;
+/**
+ * Добавить сообщение в сессию
+ */
+export declare function addMessage(session: ConversationSession, role: 'user' | 'assistant' | 'system', content: string, options?: {
+    command?: string;
+    tokens?: number;
+}): Promise<void>;
+/**
+ * Получить контекст для AI (последние N сообщений)
+ */
+export declare function getContextMessages(session: ConversationSession, maxMessages?: number, maxTokens?: number): ConversationMessage[];
+/**
+ * Получить список всех сессий
+ */
+export declare function listSessions(options?: {
+    projectId?: string;
+    limit?: number;
+    search?: string;
+}): Promise<ConversationSession[]>;
+/**
+ * Поиск по истории сообщений
+ */
+export declare function searchHistory(query: string, options?: {
+    projectId?: string;
+    limit?: number;
+    role?: 'user' | 'assistant';
+}): Promise<Array<{
+    session: ConversationSession;
+    message: ConversationMessage;
+    index: number;
+}>>;
+/**
+ * Удалить сессию
+ */
+export declare function deleteSession(sessionId: string): Promise<boolean>;
+/**
+ * Очистить всю историю
+ */
+export declare function clearAllHistory(): Promise<number>;
+/**
+ * Экспорт сессии в текстовый формат
+ */
+export declare function exportSessionAsText(session: ConversationSession): string;
+//# sourceMappingURL=conversation-history.d.ts.map