archicore 0.1.0

package/dist/cli/commands/interactive.js

@@ -0,0 +1,522 @@
+/**
+ * ArchiCore CLI - Interactive Mode
+ *
+ * REPL-style interface similar to Claude Code
+ */
+import * as readline from 'readline';
+import { loadConfig } from '../utils/config.js';
+import { checkServerConnection } from '../utils/session.js';
+import { isInitialized, getLocalProject } from './init.js';
+import { colors, icons, createSpinner, printHelp, printGoodbye, printSection, printSuccess, printError, printWarning, printInfo, printKeyValue, header, } from '../ui/index.js';
+const state = {
+    running: true,
+    projectId: null,
+    projectName: null,
+    projectPath: process.cwd(),
+    history: [],
+};
+export async function startInteractiveMode() {
+    // Check if initialized in current directory
+    const initialized = await isInitialized(state.projectPath);
+    if (!initialized) {
+        console.log();
+        printError('ArchiCore not initialized in this directory');
+        console.log();
+        printInfo('Run `archicore init` to initialize');
+        console.log();
+        process.exit(1);
+    }
+    // Load local project config
+    const localProject = await getLocalProject(state.projectPath);
+    if (localProject) {
+        state.projectId = localProject.id || null;
+        state.projectName = localProject.name;
+    }
+    // Check server connection
+    const spinner = createSpinner('Connecting to ArchiCore...').start();
+    const connected = await checkServerConnection();
+    if (!connected) {
+        spinner.fail('Cannot connect to ArchiCore server');
+        printError('Make sure the server is running: npm run server');
+        process.exit(1);
+    }
+    spinner.succeed('Connected');
+    // Print welcome
+    console.log();
+    console.log(header('ArchiCore', 'AI Software Architect'));
+    if (state.projectName) {
+        console.log(colors.muted(`  Project: ${colors.primary(state.projectName)}`));
+    }
+    console.log();
+    console.log(colors.muted('  Type /help for commands or ask a question about your code.'));
+    console.log();
+    // Start REPL
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: true,
+    });
+    const prompt = () => {
+        const prefix = state.projectName
+            ? colors.muted(`[${state.projectName}] `)
+            : '';
+        process.stdout.write(`${prefix}${colors.primary(icons.arrow)} `);
+    };
+    prompt();
+    const processLine = async (input) => {
+        const trimmed = input.trim();
+        if (!trimmed) {
+            prompt();
+            return;
+        }
+        state.history.push(trimmed);
+        try {
+            await handleInput(trimmed);
+        }
+        catch (error) {
+            printError(String(error));
+        }
+        if (state.running) {
+            console.log();
+            prompt();
+        }
+        else {
+            rl.close();
+        }
+    };
+    rl.on('line', (input) => {
+        processLine(input).catch((err) => {
+            printError(String(err));
+            prompt();
+        });
+    });
+    rl.on('close', () => {
+        if (state.running) {
+            // Unexpected close, try to restart
+            console.log();
+            printWarning('Input stream closed unexpectedly');
+        }
+        else {
+            printGoodbye();
+        }
+        process.exit(0);
+    });
+    // Handle SIGINT (Ctrl+C)
+    process.on('SIGINT', () => {
+        console.log();
+        state.running = false;
+        rl.close();
+    });
+}
+async function handleInput(input) {
+    // Handle slash commands
+    if (input.startsWith('/')) {
+        await handleCommand(input);
+        return;
+    }
+    // Natural language query
+    await handleQuery(input);
+}
+async function handleCommand(input) {
+    const parts = input.slice(1).split(/\s+/);
+    const command = parts[0].toLowerCase();
+    const args = parts.slice(1);
+    switch (command) {
+        case 'help':
+        case 'h':
+            printHelp();
+            break;
+        case 'exit':
+        case 'quit':
+        case 'q':
+            state.running = false;
+            break;
+        case 'clear':
+        case 'cls':
+            console.clear();
+            break;
+        case 'index':
+        case 'i':
+            await handleIndexCommand();
+            break;
+        case 'analyze':
+        case 'impact':
+            await handleAnalyzeCommand(args);
+            break;
+        case 'search':
+        case 's':
+            await handleSearchCommand(args.join(' '));
+            break;
+        case 'dead-code':
+        case 'deadcode':
+            await handleDeadCodeCommand();
+            break;
+        case 'security':
+        case 'sec':
+            await handleSecurityCommand();
+            break;
+        case 'metrics':
+        case 'stats':
+            await handleMetricsCommand();
+            break;
+        case 'export':
+            await handleExportCommand(args);
+            break;
+        case 'status':
+            await handleStatusCommand();
+            break;
+        default:
+            printError(`Unknown command: /${command}`);
+            printInfo('Use /help to see available commands');
+    }
+}
+async function handleIndexCommand() {
+    if (!state.projectId) {
+        // Try to register project first
+        const spinner = createSpinner('Registering project...').start();
+        try {
+            const config = await loadConfig();
+            const response = await fetch(`${config.serverUrl}/api/projects`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ name: state.projectName, path: state.projectPath }),
+            });
+            if (response.ok) {
+                const data = await response.json();
+                state.projectId = data.id || data.project?.id;
+            }
+            spinner.stop();
+        }
+        catch {
+            spinner.fail('Failed to register project');
+            return;
+        }
+    }
+    if (!state.projectId) {
+        printError('Failed to register project with server');
+        return;
+    }
+    const spinner = createSpinner('Indexing project...').start();
+    try {
+        const config = await loadConfig();
+        const response = await fetch(`${config.serverUrl}/api/projects/${state.projectId}/index`, {
+            method: 'POST',
+        });
+        if (!response.ok) {
+            throw new Error('Indexing failed');
+        }
+        const data = await response.json();
+        spinner.succeed('Project indexed');
+        printKeyValue('Files', String(data.statistics?.totalFiles || 0));
+        printKeyValue('Symbols', String(data.statistics?.totalSymbols || 0));
+        // Update local config
+        const { getLocalProject } = await import('./init.js');
+        const localProject = await getLocalProject(state.projectPath);
+        if (localProject) {
+            localProject.id = state.projectId;
+            localProject.indexed = true;
+            const fs = await import('fs/promises');
+            const path = await import('path');
+            await fs.writeFile(path.join(state.projectPath, '.archicore', 'project.json'), JSON.stringify(localProject, null, 2));
+        }
+    }
+    catch (error) {
+        spinner.fail('Indexing failed');
+        printError(String(error));
+    }
+}
+async function handleAnalyzeCommand(args) {
+    if (!state.projectId) {
+        printError('No project selected');
+        printInfo('Use /projects select <id> first');
+        return;
+    }
+    const description = args.join(' ') || 'General analysis';
+    const spinner = createSpinner('Analyzing impact...').start();
+    try {
+        const config = await loadConfig();
+        const response = await fetch(`${config.serverUrl}/api/projects/${state.projectId}/analyze`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                description,
+                files: [],
+                symbols: [],
+                type: 'modify',
+            }),
+        });
+        if (!response.ok)
+            throw new Error('Analysis failed');
+        const data = await response.json();
+        spinner.succeed('Analysis complete');
+        printSection('Impact Analysis');
+        const impact = data.impact;
+        // Affected components
+        const affected = impact.affectedNodes || [];
+        console.log(`  ${colors.highlight('Affected Components:')} ${affected.length}`);
+        const byLevel = {
+            critical: affected.filter((n) => n.impactLevel === 'critical'),
+            high: affected.filter((n) => n.impactLevel === 'high'),
+            medium: affected.filter((n) => n.impactLevel === 'medium'),
+            low: affected.filter((n) => n.impactLevel === 'low'),
+        };
+        if (byLevel.critical.length > 0) {
+            console.log(`  ${colors.critical(`${icons.severityCritical} Critical: ${byLevel.critical.length}`)}`);
+        }
+        if (byLevel.high.length > 0) {
+            console.log(`  ${colors.high(`${icons.severityHigh} High: ${byLevel.high.length}`)}`);
+        }
+        if (byLevel.medium.length > 0) {
+            console.log(`  ${colors.medium(`${icons.severityMedium} Medium: ${byLevel.medium.length}`)}`);
+        }
+        if (byLevel.low.length > 0) {
+            console.log(`  ${colors.low(`${icons.severityLow} Low: ${byLevel.low.length}`)}`);
+        }
+        // Risks
+        if (impact.risks?.length > 0) {
+            console.log();
+            console.log(`  ${colors.highlight('Risks:')}`);
+            for (const risk of impact.risks.slice(0, 5)) {
+                console.log(`  ${colors.warning(icons.warning)} ${risk.description}`);
+            }
+        }
+        // Recommendations
+        if (impact.recommendations?.length > 0) {
+            console.log();
+            console.log(`  ${colors.highlight('Recommendations:')}`);
+            for (const rec of impact.recommendations.slice(0, 3)) {
+                console.log(`  ${colors.info(icons.info)} ${rec.description}`);
+            }
+        }
+    }
+    catch (error) {
+        spinner.fail('Analysis failed');
+        throw error;
+    }
+}
+async function handleSearchCommand(query) {
+    if (!state.projectId) {
+        printError('No project selected');
+        printInfo('Use /projects select <id> first');
+        return;
+    }
+    if (!query) {
+        printError('Usage: /search <query>');
+        return;
+    }
+    const spinner = createSpinner('Searching...').start();
+    try {
+        const config = await loadConfig();
+        const response = await fetch(`${config.serverUrl}/api/projects/${state.projectId}/search`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ query, limit: 10 }),
+        });
+        if (!response.ok)
+            throw new Error('Search failed');
+        const data = await response.json();
+        const results = data.results || [];
+        spinner.succeed(`Found ${results.length} results`);
+        if (results.length === 0) {
+            printWarning('No results found');
+            return;
+        }
+        console.log();
+        for (const [i, result] of results.entries()) {
+            const score = ((result.score || 0) * 100).toFixed(0);
+            const file = result.chunk?.metadata?.filePath || result.filePath || 'unknown';
+            const line = result.chunk?.metadata?.startLine || result.line || '';
+            console.log(`  ${colors.secondary(`${i + 1}.`)} ${colors.highlight(file)}${line ? `:${line}` : ''}`);
+            console.log(`     ${colors.muted(`${score}% match`)}`);
+            if (result.context || result.chunk?.content) {
+                const preview = (result.context || result.chunk?.content || '')
+                    .slice(0, 100)
+                    .replace(/\n/g, ' ');
+                console.log(`     ${colors.dim(preview)}${preview.length >= 100 ? '...' : ''}`);
+            }
+            console.log();
+        }
+    }
+    catch (error) {
+        spinner.fail('Search failed');
+        throw error;
+    }
+}
+async function handleQuery(query) {
+    if (!state.projectId) {
+        printError('No project selected');
+        printInfo('Use /projects to list and select a project first');
+        return;
+    }
+    const spinner = createSpinner('Thinking...').start();
+    try {
+        const config = await loadConfig();
+        const response = await fetch(`${config.serverUrl}/api/projects/${state.projectId}/ask`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ question: query }),
+        });
+        if (!response.ok)
+            throw new Error('Query failed');
+        const data = await response.json();
+        spinner.stop();
+        console.log();
+        console.log(colors.primary('  ' + icons.lightning + ' ArchiCore'));
+        console.log();
+        // Format the answer
+        const answer = data.answer || data.response || 'No response';
+        const lines = answer.split('\n');
+        for (const line of lines) {
+            console.log('  ' + line);
+        }
+    }
+    catch (error) {
+        spinner.fail('Query failed');
+        throw error;
+    }
+}
+async function handleDeadCodeCommand() {
+    if (!state.projectId) {
+        printError('No project selected');
+        return;
+    }
+    const spinner = createSpinner('Analyzing dead code...').start();
+    try {
+        const config = await loadConfig();
+        const response = await fetch(`${config.serverUrl}/api/projects/${state.projectId}/dead-code`);
+        if (!response.ok)
+            throw new Error('Analysis failed');
+        const data = await response.json();
+        const result = data.deadCode;
+        spinner.succeed('Analysis complete');
+        printSection('Dead Code');
+        console.log(`  Unused exports: ${result.unusedExports?.length || 0}`);
+        console.log(`  Unused variables: ${result.unusedVariables?.length || 0}`);
+        console.log(`  Unreachable code: ${result.unreachableCode?.length || 0}`);
+        if (result.unusedExports?.length > 0) {
+            console.log();
+            console.log(colors.muted('  Top unused exports:'));
+            for (const item of result.unusedExports.slice(0, 5)) {
+                console.log(`    ${colors.warning(icons.warning)} ${item.name} ${colors.dim(`(${item.filePath})`)}`);
+            }
+        }
+    }
+    catch (error) {
+        spinner.fail('Analysis failed');
+        throw error;
+    }
+}
+async function handleSecurityCommand() {
+    if (!state.projectId) {
+        printError('No project selected');
+        return;
+    }
+    const spinner = createSpinner('Analyzing security...').start();
+    try {
+        const config = await loadConfig();
+        const response = await fetch(`${config.serverUrl}/api/projects/${state.projectId}/security`);
+        if (!response.ok)
+            throw new Error('Analysis failed');
+        const data = await response.json();
+        const vulns = data.security?.vulnerabilities || [];
+        spinner.succeed('Analysis complete');
+        printSection('Security');
+        if (vulns.length === 0) {
+            printSuccess('No vulnerabilities found!');
+            return;
+        }
+        const counts = {
+            critical: vulns.filter((v) => v.severity === 'critical').length,
+            high: vulns.filter((v) => v.severity === 'high').length,
+            medium: vulns.filter((v) => v.severity === 'medium').length,
+            low: vulns.filter((v) => v.severity === 'low').length,
+        };
+        console.log(`  ${colors.critical(`Critical: ${counts.critical}`)}`);
+        console.log(`  ${colors.high(`High: ${counts.high}`)}`);
+        console.log(`  ${colors.medium(`Medium: ${counts.medium}`)}`);
+        console.log(`  ${colors.low(`Low: ${counts.low}`)}`);
+        if (counts.critical > 0 || counts.high > 0) {
+            console.log();
+            console.log(colors.muted('  Critical/High issues:'));
+            for (const v of vulns.filter((v) => v.severity === 'critical' || v.severity === 'high').slice(0, 5)) {
+                console.log(`    ${colors.error(icons.error)} ${v.type}: ${v.description}`);
+            }
+        }
+    }
+    catch (error) {
+        spinner.fail('Analysis failed');
+        throw error;
+    }
+}
+async function handleMetricsCommand() {
+    if (!state.projectId) {
+        printError('No project selected');
+        return;
+    }
+    const spinner = createSpinner('Calculating metrics...').start();
+    try {
+        const config = await loadConfig();
+        const response = await fetch(`${config.serverUrl}/api/projects/${state.projectId}/metrics`);
+        if (!response.ok)
+            throw new Error('Analysis failed');
+        const data = await response.json();
+        const metrics = data.metrics;
+        spinner.succeed('Metrics calculated');
+        printSection('Code Metrics');
+        if (metrics.summary) {
+            console.log(`  Files: ${metrics.summary.totalFiles || 0}`);
+            console.log(`  Lines: ${metrics.summary.totalLines || 0}`);
+            console.log(`  Avg Complexity: ${(metrics.summary.avgComplexity || 0).toFixed(2)}`);
+            console.log(`  Avg Maintainability: ${(metrics.summary.avgMaintainability || 0).toFixed(1)}`);
+        }
+    }
+    catch (error) {
+        spinner.fail('Analysis failed');
+        throw error;
+    }
+}
+async function handleExportCommand(args) {
+    if (!state.projectId) {
+        printError('No project selected');
+        return;
+    }
+    const format = args[0] || 'json';
+    const output = args[1] || `archicore-export.${format === 'markdown' ? 'md' : format}`;
+    const spinner = createSpinner(`Exporting as ${format}...`).start();
+    try {
+        const config = await loadConfig();
+        const response = await fetch(`${config.serverUrl}/api/projects/${state.projectId}/export`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ format }),
+        });
+        if (!response.ok)
+            throw new Error('Export failed');
+        const data = await response.json();
+        const { writeFile } = await import('fs/promises');
+        const content = format === 'json'
+            ? JSON.stringify(data.data || data, null, 2)
+            : data.content || JSON.stringify(data, null, 2);
+        await writeFile(output, content);
+        spinner.succeed('Export complete');
+        printKeyValue('Output', output);
+    }
+    catch (error) {
+        spinner.fail('Export failed');
+        throw error;
+    }
+}
+async function handleStatusCommand() {
+    const config = await loadConfig();
+    printSection('Status');
+    const connected = await checkServerConnection();
+    console.log(`  Server: ${connected ? colors.success('Connected') : colors.error('Disconnected')}`);
+    console.log(`  URL: ${colors.muted(config.serverUrl)}`);
+    if (state.projectId) {
+        console.log(`  Project: ${colors.primary(state.projectName || state.projectId)}`);
+    }
+    else {
+        console.log(`  Project: ${colors.muted('None selected')}`);
+    }
+}
+//# sourceMappingURL=interactive.js.map

package/dist/cli/commands/projects.d.ts

@@ -0,0 +1,6 @@
+/**
+ * ArchiCore CLI - Projects Commands
+ */
+import { Command } from 'commander';
+export declare function registerProjectsCommand(program: Command): void;
+//# sourceMappingURL=projects.d.ts.map