archicore 0.2.1 → 0.2.3

package/dist/cli/commands/init.js

@@ -63,22 +63,38 @@ export async function initProject(dir, name) {
     const spinner = createSpinner('Initializing ArchiCore...').start();
     try {
         const config = await loadConfig();
-        // Create project on server
-        const response = await fetch(`${config.serverUrl}/api/projects`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ name: projectName, path: dir }),
-        });
         let projectId;
         let serverName = projectName;
-        if (response.ok) {
-            const data = await response.json();
-            projectId = data.id || data.project?.id;
-            serverName = data.name || data.project?.name || projectName;
+        let serverAvailable = false;
+        // Try to create project on server (only if we have a token)
+        try {
+            const headers = { 'Content-Type': 'application/json' };
+            if (config.accessToken) {
+                headers['Authorization'] = `Bearer ${config.accessToken}`;
+            }
+            const response = await fetch(`${config.serverUrl}/api/projects`, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({ name: projectName, path: dir }),
+            });
+            if (response.ok) {
+                const data = await response.json();
+                projectId = data.id || data.project?.id;
+                serverName = data.name || data.project?.name || projectName;
+                serverAvailable = true;
+            }
+            else if (response.status === 401 || response.status === 403) {
+                // Not authenticated - that's OK, will sync on first /index
+                spinner.update('Creating local config (login required for sync)...');
+                serverAvailable = true; // Server is available, just not authenticated
+            }
+            else {
+                spinner.warn('Server returned error, creating local config only');
+            }
         }
-        else {
-            // Server might not be running, that's OK - we can still create local config
-            spinner.warn('Server not available, creating local config only');
+        catch (fetchError) {
+            // Network error - server not reachable
+            spinner.warn('Server not reachable, creating local config only');
         }
         // Create local config
         const localConfig = {
@@ -91,8 +107,15 @@ export async function initProject(dir, name) {
         await saveLocalProject(dir, localConfig);
         // Add .archicore to .gitignore if git repo
         await addToGitignore(dir);
+        // Show appropriate success message
         if (projectId) {
-            spinner.succeed('ArchiCore initialized');
+            spinner.succeed('ArchiCore initialized and synced');
+        }
+        else if (serverAvailable) {
+            spinner.succeed('ArchiCore initialized (will sync after login)');
+        }
+        else {
+            spinner.succeed('ArchiCore initialized locally');
         }
         console.log();
         printKeyValue('Directory', dir);

package/dist/cli/commands/interactive.js

@@ -10,6 +10,25 @@ 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';
+// Command registry with descriptions (like Claude CLI)
+const COMMANDS = [
+    { name: 'index', aliases: ['i'], description: 'Index your codebase for analysis' },
+    { name: 'analyze', aliases: ['impact'], description: 'Analyze impact of changes' },
+    { name: 'search', aliases: ['s'], description: 'Search code semantically' },
+    { name: 'dead-code', aliases: ['deadcode'], description: 'Find unused code' },
+    { name: 'security', aliases: ['sec'], description: 'Scan for security vulnerabilities' },
+    { name: 'metrics', aliases: ['stats'], description: 'Show code metrics and statistics' },
+    { name: 'duplication', aliases: ['duplicates'], description: 'Detect code duplication' },
+    { name: 'refactoring', aliases: ['refactor'], description: 'Get refactoring suggestions' },
+    { name: 'rules', aliases: [], description: 'Check architectural rules' },
+    { name: 'docs', aliases: ['documentation'], description: 'Generate architecture documentation' },
+    { name: 'export', aliases: [], description: 'Export analysis results' },
+    { 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' },
+    { name: 'logout', aliases: [], description: 'Log out from ArchiCore' },
+    { name: 'exit', aliases: ['quit', 'q'], description: 'Exit ArchiCore CLI' },
+];
 const state = {
     running: true,
     projectId: null,
@@ -113,29 +132,67 @@ export async function startInteractiveMode() {
         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(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();
-    // Start REPL
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-        terminal: true,
-    });
-    // Keep the process alive
-    rl.ref?.();
-    const prompt = () => {
-        const prefix = state.projectName
+    // Interactive input with real-time autocomplete
+    await startInteractiveInput(state);
+}
+/**
+ * Start interactive input loop with real-time command suggestions
+ */
+async function startInteractiveInput(state) {
+    const getPromptPrefix = () => {
+        return 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();
+    const promptStr = () => `${getPromptPrefix()}${colors.primary(icons.arrow)} `;
+    // State for current input
+    let currentInput = '';
+    let menuVisible = false;
+    let selectedIndex = 0;
+    let filteredCommands = [];
+    // Filter commands based on input
+    const filterCommands = (input) => {
+        if (!input.startsWith('/'))
+            return [];
+        const query = input.slice(1).toLowerCase();
+        if (!query)
+            return COMMANDS.slice(0, 10);
+        return COMMANDS.filter(cmd => cmd.name.toLowerCase().startsWith(query) ||
+            cmd.aliases.some(a => a.toLowerCase().startsWith(query))).slice(0, 10);
+    };
+    // Render the menu
+    const renderMenu = () => {
+        if (filteredCommands.length === 0)
             return;
+        console.log();
+        for (let i = 0; i < filteredCommands.length; i++) {
+            const cmd = filteredCommands[i];
+            const isSelected = i === selectedIndex;
+            const nameStr = `/${cmd.name}`.padEnd(18);
+            if (isSelected) {
+                console.log(`  ${colors.highlight(nameStr)} ${colors.muted(cmd.description)}`);
+            }
+            else {
+                console.log(`  ${colors.primary(nameStr)} ${colors.dim(cmd.description)}`);
+            }
         }
+        console.log(colors.dim('  ↑↓ select • Tab complete • Enter run'));
+    };
+    // Clear menu lines
+    const clearMenu = (lines) => {
+        for (let i = 0; i < lines; i++) {
+            readline.moveCursor(process.stdout, 0, -1);
+            readline.clearLine(process.stdout, 0);
+        }
+    };
+    // Process submitted input
+    const processInput = async (input) => {
+        const trimmed = input.trim();
+        if (!trimmed)
+            return;
         state.history.push(trimmed);
         try {
             await handleInput(trimmed);
@@ -143,61 +200,206 @@ export async function startInteractiveMode() {
         catch (error) {
             printError(String(error));
         }
-        if (state.running) {
+    };
+    // Use raw mode for real-time input
+    if (process.stdin.isTTY) {
+        readline.emitKeypressEvents(process.stdin);
+        process.stdin.setRawMode(true);
+    }
+    process.stdout.write(promptStr());
+    const handleKeypress = async (str, key) => {
+        // Handle Ctrl+C
+        if (key.ctrl && key.name === 'c') {
+            if (menuVisible) {
+                clearMenu(filteredCommands.length + 2);
+                menuVisible = false;
+            }
             console.log();
-            prompt();
-        }
-        else {
-            rl.close();
+            state.running = false;
+            printGoodbye();
+            process.exit(0);
         }
-    };
-    rl.on('line', (input) => {
-        processLine(input).catch((err) => {
-            printError(String(err));
-            prompt();
-        });
-    });
-    rl.on('close', () => {
-        if (state.running) {
-            // Unexpected close - don't exit, restart readline
+        // Handle Enter
+        if (key.name === 'return') {
+            if (menuVisible && filteredCommands.length > 0) {
+                // Select from menu
+                clearMenu(filteredCommands.length + 2);
+                menuVisible = false;
+                const selected = filteredCommands[selectedIndex];
+                currentInput = '/' + selected.name;
+                readline.clearLine(process.stdout, 0);
+                readline.cursorTo(process.stdout, 0);
+                process.stdout.write(promptStr() + currentInput);
+            }
+            // Submit
+            if (menuVisible) {
+                clearMenu(filteredCommands.length + 2);
+                menuVisible = false;
+            }
             console.log();
-            printWarning('Input stream interrupted, restarting...');
-            // Recreate readline interface
-            const newRl = readline.createInterface({
-                input: process.stdin,
-                output: process.stdout,
-                terminal: true,
-            });
-            newRl.on('line', (input) => {
-                processLine(input).catch((err) => {
-                    printError(String(err));
-                    prompt();
-                });
-            });
-            newRl.on('close', () => {
-                if (!state.running) {
-                    printGoodbye();
-                    process.exit(0);
+            await processInput(currentInput);
+            currentInput = '';
+            selectedIndex = 0;
+            filteredCommands = [];
+            if (state.running) {
+                console.log();
+                process.stdout.write(promptStr());
+            }
+            else {
+                process.stdin.setRawMode(false);
+                process.exit(0);
+            }
+            return;
+        }
+        // Handle Tab - autocomplete
+        if (key.name === 'tab') {
+            if (filteredCommands.length > 0) {
+                if (menuVisible) {
+                    clearMenu(filteredCommands.length + 2);
                 }
-            });
-            console.log();
-            prompt();
+                const selected = filteredCommands[selectedIndex];
+                currentInput = '/' + selected.name + ' ';
+                menuVisible = false;
+                filteredCommands = [];
+                readline.clearLine(process.stdout, 0);
+                readline.cursorTo(process.stdout, 0);
+                process.stdout.write(promptStr() + currentInput);
+            }
+            return;
         }
-        else {
-            printGoodbye();
-            process.exit(0);
+        // Handle Escape - close menu
+        if (key.name === 'escape') {
+            if (menuVisible) {
+                clearMenu(filteredCommands.length + 2);
+                menuVisible = false;
+                filteredCommands = [];
+            }
+            return;
         }
+        // Handle Up arrow
+        if (key.name === 'up') {
+            if (menuVisible && selectedIndex > 0) {
+                clearMenu(filteredCommands.length + 2);
+                selectedIndex--;
+                renderMenu();
+            }
+            return;
+        }
+        // Handle Down arrow
+        if (key.name === 'down') {
+            if (menuVisible && selectedIndex < filteredCommands.length - 1) {
+                clearMenu(filteredCommands.length + 2);
+                selectedIndex++;
+                renderMenu();
+            }
+            return;
+        }
+        // Handle Backspace
+        if (key.name === 'backspace') {
+            if (currentInput.length > 0) {
+                if (menuVisible) {
+                    clearMenu(filteredCommands.length + 2);
+                }
+                currentInput = currentInput.slice(0, -1);
+                readline.clearLine(process.stdout, 0);
+                readline.cursorTo(process.stdout, 0);
+                process.stdout.write(promptStr() + currentInput);
+                // Update menu
+                filteredCommands = filterCommands(currentInput);
+                selectedIndex = 0;
+                menuVisible = currentInput.startsWith('/') && filteredCommands.length > 0;
+                if (menuVisible) {
+                    renderMenu();
+                }
+            }
+            return;
+        }
+        // Regular character input
+        if (str && str.length === 1 && !key.ctrl && !key.meta) {
+            if (menuVisible) {
+                clearMenu(filteredCommands.length + 2);
+            }
+            currentInput += str;
+            readline.clearLine(process.stdout, 0);
+            readline.cursorTo(process.stdout, 0);
+            process.stdout.write(promptStr() + currentInput);
+            // Show menu when typing /
+            filteredCommands = filterCommands(currentInput);
+            selectedIndex = 0;
+            menuVisible = currentInput.startsWith('/') && filteredCommands.length > 0;
+            if (menuVisible) {
+                renderMenu();
+            }
+        }
+    };
+    process.stdin.on('keypress', handleKeypress);
+    // Keep process alive
+    await new Promise((resolve) => {
+        const checkRunning = setInterval(() => {
+            if (!state.running) {
+                clearInterval(checkRunning);
+                resolve();
+            }
+        }, 100);
     });
-    // Handle SIGINT (Ctrl+C)
-    process.on('SIGINT', () => {
-        console.log();
-        state.running = false;
-        rl.close();
-    });
+}
+/**
+ * Display command menu (like Claude CLI's / navigation)
+ */
+function showCommandMenu(filter = '') {
+    const filterLower = filter.toLowerCase();
+    const filtered = COMMANDS.filter(cmd => cmd.name.includes(filterLower) ||
+        cmd.aliases.some(a => a.includes(filterLower)));
+    if (filtered.length === 0) {
+        console.log(colors.muted('  No matching commands'));
+        return;
+    }
+    console.log();
+    for (const cmd of filtered) {
+        const nameWidth = 20;
+        const paddedName = `/${cmd.name}`.padEnd(nameWidth);
+        console.log(`  ${colors.primary(paddedName)} ${colors.muted(cmd.description)}`);
+    }
+    console.log();
+    console.log(colors.dim('  ? for shortcuts'));
 }
 async function handleInput(input) {
+    // Handle "?" for shortcuts
+    if (input === '?') {
+        console.log();
+        console.log(colors.highlight('  Keyboard Shortcuts:'));
+        console.log();
+        console.log(`  ${colors.primary('Tab')}         Autocomplete command`);
+        console.log(`  ${colors.primary('/')}           Show all commands`);
+        console.log(`  ${colors.primary('/command')}    Execute a command`);
+        console.log(`  ${colors.primary('Ctrl+C')}      Exit ArchiCore`);
+        console.log();
+        console.log(colors.highlight('  Quick Commands:'));
+        console.log();
+        console.log(`  ${colors.primary('/i')}          Index project (alias for /index)`);
+        console.log(`  ${colors.primary('/s query')}    Search code (alias for /search)`);
+        console.log(`  ${colors.primary('/q')}          Quit (alias for /exit)`);
+        console.log();
+        return;
+    }
     // Handle slash commands
     if (input.startsWith('/')) {
+        // If just "/" or "/?" - show command menu
+        if (input === '/' || input === '/?') {
+            showCommandMenu();
+            return;
+        }
+        // If partial command (e.g. "/in") - show filtered menu
+        const partialCmd = input.slice(1).split(/\s/)[0];
+        if (partialCmd && !input.includes(' ')) {
+            // Check if it's a complete command
+            const isComplete = COMMANDS.some(cmd => cmd.name === partialCmd || cmd.aliases.includes(partialCmd));
+            if (!isComplete) {
+                // Show filtered suggestions
+                showCommandMenu(partialCmd);
+                return;
+            }
+        }
         await handleCommand(input);
         return;
     }

package/dist/cli/ui/autocomplete.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Interactive Autocomplete Input for ArchiCore CLI
+ *
+ * Shows command suggestions in real-time as user types,
+ * similar to Claude's terminal interface.
+ *
+ * Works on Linux, Windows, and macOS.
+ */
+import * as readline from 'readline';
+export interface CommandItem {
+    name: string;
+    aliases: string[];
+    description: string;
+}
+export interface AutocompleteOptions {
+    commands: CommandItem[];
+    prompt?: string;
+    placeholder?: string;
+}
+/**
+ * Create an interactive input with autocomplete
+ */
+export declare function createAutocompleteInput(options: AutocompleteOptions): Promise<string>;
+/**
+ * Simple readline-based input with inline suggestions
+ * More compatible fallback for environments where raw mode doesn't work well
+ */
+export declare function createSimpleAutocomplete(rl: readline.Interface, commands: CommandItem[], prompt: string): void;
+//# sourceMappingURL=autocomplete.d.ts.map