archicore 0.2.2 → 0.2.4

package/dist/cli/commands/interactive.js

@@ -29,51 +29,6 @@ const COMMANDS = [
     { name: 'logout', aliases: [], description: 'Log out from ArchiCore' },
     { name: 'exit', aliases: ['quit', 'q'], description: 'Exit ArchiCore CLI' },
 ];
-// Get all command names and aliases for autocomplete
-function getAllCommandNames() {
-    const names = [];
-    for (const cmd of COMMANDS) {
-        names.push('/' + cmd.name);
-        for (const alias of cmd.aliases) {
-            names.push('/' + alias);
-        }
-    }
-    return names.sort();
-}
-/**
- * Tab autocomplete function for readline
- * Works on Linux, Windows, and macOS
- */
-function completer(line) {
-    // If line starts with /, autocomplete commands
-    if (line.startsWith('/')) {
-        const allCommands = getAllCommandNames();
-        const hits = allCommands.filter((cmd) => cmd.startsWith(line));
-        // If exact match or no matches, return the line as-is
-        if (hits.length === 0) {
-            return [allCommands, line];
-        }
-        // Show matching commands with descriptions
-        if (hits.length > 1) {
-            console.log();
-            for (const hit of hits) {
-                const cmdName = hit.slice(1); // Remove leading /
-                const cmd = COMMANDS.find(c => c.name === cmdName || c.aliases.includes(cmdName));
-                if (cmd) {
-                    const desc = colors.dim(cmd.description);
-                    console.log(`  ${colors.primary(hit.padEnd(18))} ${desc}`);
-                }
-                else {
-                    console.log(`  ${colors.primary(hit)}`);
-                }
-            }
-            console.log();
-        }
-        return [hits, line];
-    }
-    // For non-command input, no autocomplete
-    return [[], line];
-}
 const state = {
     running: true,
     projectId: null,
@@ -177,31 +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('  Press Tab to autocomplete commands.'));
+    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 with Tab autocomplete
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-        terminal: true,
-        completer: completer,
-    });
-    // 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);
@@ -209,57 +200,147 @@ 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 with Tab autocomplete
-            const newRl = readline.createInterface({
-                input: process.stdin,
-                output: process.stdout,
-                terminal: true,
-                completer: completer,
-            });
-            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 SIGINT (Ctrl+C)
-    process.on('SIGINT', () => {
-        console.log();
-        state.running = false;
-        rl.close();
+        // 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);
     });
 }
 /**

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

package/dist/cli/ui/autocomplete.js

@@ -0,0 +1,250 @@
+/**
+ * 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';
+import { colors } from './colors.js';
+/**
+ * Create an interactive input with autocomplete
+ */
+export function createAutocompleteInput(options) {
+    return new Promise((resolve) => {
+        const { commands, prompt = '> ' } = options;
+        const state = {
+            input: '',
+            cursorPos: 0,
+            selectedIndex: 0,
+            filteredCommands: [],
+            showMenu: false,
+        };
+        // Filter commands based on input
+        const filterCommands = (input) => {
+            if (!input.startsWith('/'))
+                return [];
+            const query = input.slice(1).toLowerCase();
+            if (!query) {
+                return commands.slice(0, 8); // Show first 8 commands
+            }
+            return commands.filter(cmd => cmd.name.toLowerCase().startsWith(query) ||
+                cmd.aliases.some(a => a.toLowerCase().startsWith(query))).slice(0, 8);
+        };
+        // Render the current state
+        const render = () => {
+            // Clear previous output
+            readline.clearLine(process.stdout, 0);
+            readline.cursorTo(process.stdout, 0);
+            // Render prompt and input
+            const displayPrompt = colors.primary(prompt);
+            process.stdout.write(displayPrompt + state.input);
+            // If showing menu, render it below
+            if (state.showMenu && state.filteredCommands.length > 0) {
+                console.log(); // New line for menu
+                for (let i = 0; i < state.filteredCommands.length; i++) {
+                    const cmd = state.filteredCommands[i];
+                    const isSelected = i === state.selectedIndex;
+                    const cmdName = `/${cmd.name}`.padEnd(18);
+                    const desc = cmd.description;
+                    if (isSelected) {
+                        console.log(`  ${colors.menuItemSelected(cmdName)} ${colors.muted(desc)}`);
+                    }
+                    else {
+                        console.log(`  ${colors.menuItem(cmdName)} ${colors.menuDescription(desc)}`);
+                    }
+                }
+                // Hint at bottom
+                console.log(colors.dim('  ↑↓ navigate • Tab/Enter select • Esc cancel'));
+                // Move cursor back to input line
+                const menuLines = state.filteredCommands.length + 2;
+                readline.moveCursor(process.stdout, 0, -menuLines);
+                readline.cursorTo(process.stdout, prompt.length + state.cursorPos);
+            }
+        };
+        // Clear the menu from display
+        const clearMenu = () => {
+            if (state.showMenu && state.filteredCommands.length > 0) {
+                const menuLines = state.filteredCommands.length + 2;
+                for (let i = 0; i < menuLines; i++) {
+                    readline.moveCursor(process.stdout, 0, 1);
+                    readline.clearLine(process.stdout, 0);
+                }
+                readline.moveCursor(process.stdout, 0, -menuLines);
+            }
+        };
+        // Update state based on input
+        const updateState = () => {
+            state.filteredCommands = filterCommands(state.input);
+            state.showMenu = state.input.startsWith('/') && state.filteredCommands.length > 0;
+            state.selectedIndex = Math.min(state.selectedIndex, Math.max(0, state.filteredCommands.length - 1));
+        };
+        // Handle selection
+        const selectItem = () => {
+            if (state.filteredCommands.length > 0 && state.selectedIndex < state.filteredCommands.length) {
+                const selected = state.filteredCommands[state.selectedIndex];
+                state.input = '/' + selected.name + ' ';
+                state.cursorPos = state.input.length;
+                state.showMenu = false;
+                state.filteredCommands = [];
+            }
+        };
+        // Set up raw mode for keystroke capture
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        process.stdin.setEncoding('utf8');
+        // Initial render
+        process.stdout.write(colors.primary(prompt));
+        const handleKeypress = (key) => {
+            const code = key.charCodeAt(0);
+            // Ctrl+C - exit
+            if (key === '\x03') {
+                clearMenu();
+                console.log();
+                process.stdin.setRawMode(false);
+                process.exit(0);
+            }
+            // Enter - submit or select
+            if (key === '\r' || key === '\n') {
+                if (state.showMenu && state.filteredCommands.length > 0) {
+                    clearMenu();
+                    selectItem();
+                    render();
+                }
+                else {
+                    clearMenu();
+                    console.log();
+                    process.stdin.setRawMode(false);
+                    process.stdin.removeListener('data', handleKeypress);
+                    resolve(state.input);
+                }
+                return;
+            }
+            // Tab - autocomplete
+            if (key === '\t') {
+                if (state.showMenu && state.filteredCommands.length > 0) {
+                    clearMenu();
+                    selectItem();
+                    render();
+                }
+                return;
+            }
+            // Escape - close menu or clear input
+            if (key === '\x1b' || key === '\x1b\x1b') {
+                if (state.showMenu) {
+                    clearMenu();
+                    state.showMenu = false;
+                    render();
+                }
+                else if (state.input) {
+                    clearMenu();
+                    state.input = '';
+                    state.cursorPos = 0;
+                    updateState();
+                    render();
+                }
+                return;
+            }
+            // Arrow keys (escape sequences)
+            if (key.startsWith('\x1b[')) {
+                const seq = key.slice(2);
+                // Up arrow
+                if (seq === 'A') {
+                    if (state.showMenu && state.selectedIndex > 0) {
+                        clearMenu();
+                        state.selectedIndex--;
+                        render();
+                    }
+                    return;
+                }
+                // Down arrow
+                if (seq === 'B') {
+                    if (state.showMenu && state.selectedIndex < state.filteredCommands.length - 1) {
+                        clearMenu();
+                        state.selectedIndex++;
+                        render();
+                    }
+                    return;
+                }
+                // Left arrow
+                if (seq === 'D') {
+                    if (state.cursorPos > 0) {
+                        state.cursorPos--;
+                        readline.cursorTo(process.stdout, prompt.length + state.cursorPos);
+                    }
+                    return;
+                }
+                // Right arrow
+                if (seq === 'C') {
+                    if (state.cursorPos < state.input.length) {
+                        state.cursorPos++;
+                        readline.cursorTo(process.stdout, prompt.length + state.cursorPos);
+                    }
+                    return;
+                }
+                return;
+            }
+            // Backspace
+            if (key === '\x7f' || key === '\b') {
+                if (state.cursorPos > 0) {
+                    clearMenu();
+                    state.input = state.input.slice(0, state.cursorPos - 1) + state.input.slice(state.cursorPos);
+                    state.cursorPos--;
+                    updateState();
+                    render();
+                }
+                return;
+            }
+            // Regular character
+            if (code >= 32 && code < 127) {
+                clearMenu();
+                state.input = state.input.slice(0, state.cursorPos) + key + state.input.slice(state.cursorPos);
+                state.cursorPos++;
+                state.selectedIndex = 0; // Reset selection on new input
+                updateState();
+                render();
+                return;
+            }
+        };
+        process.stdin.on('data', handleKeypress);
+    });
+}
+/**
+ * Simple readline-based input with inline suggestions
+ * More compatible fallback for environments where raw mode doesn't work well
+ */
+export function createSimpleAutocomplete(rl, commands, prompt) {
+    // This is used as the completer function for readline
+    const completer = (line) => {
+        if (line.startsWith('/')) {
+            const allCommands = [];
+            for (const cmd of commands) {
+                allCommands.push('/' + cmd.name);
+                for (const alias of cmd.aliases) {
+                    allCommands.push('/' + alias);
+                }
+            }
+            const hits = allCommands.filter(c => c.startsWith(line));
+            if (hits.length > 1) {
+                console.log();
+                for (const hit of hits) {
+                    const cmdName = hit.slice(1);
+                    const cmd = commands.find(c => c.name === cmdName || c.aliases.includes(cmdName));
+                    if (cmd) {
+                        console.log(`  ${colors.menuItem(hit.padEnd(18))} ${colors.menuDescription(cmd.description)}`);
+                    }
+                }
+                console.log();
+                process.stdout.write(prompt + line);
+            }
+            return [hits, line];
+        }
+        return [[], line];
+    };
+    // Return the completer function
+    rl._completer = completer;
+}
+//# sourceMappingURL=autocomplete.js.map

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

@@ -19,6 +19,9 @@ export declare const colors: {
     brand: import("chalk").ChalkInstance;
     link: import("chalk").ChalkInstance;
     code: import("chalk").ChalkInstance;
+    menuItem: import("chalk").ChalkInstance;
+    menuItemSelected: import("chalk").ChalkInstance;
+    menuDescription: import("chalk").ChalkInstance;
 };
 export declare const icons: {
     success: string;

package/dist/cli/ui/colors.js

@@ -3,28 +3,32 @@
  */
 import chalk from 'chalk';
 export const colors = {
-    // Primary colors
-    primary: chalk.hex('#7C3AED'), // Purple
-    secondary: chalk.hex('#06B6D4'), // Cyan
-    accent: chalk.hex('#F59E0B'), // Amber
+    // Primary colors - ArchiCore brand (sky blue from logo #0ea5e9)
+    primary: chalk.hex('#0ea5e9'), // Sky Blue (logo color)
+    secondary: chalk.hex('#38bdf8'), // Lighter Sky Blue
+    accent: chalk.hex('#7dd3fc'), // Even lighter for accents
     // Status colors
-    success: chalk.hex('#10B981'), // Green
-    warning: chalk.hex('#F59E0B'), // Amber
-    error: chalk.hex('#EF4444'), // Red
-    info: chalk.hex('#3B82F6'), // Blue
+    success: chalk.hex('#22c55e'), // Green
+    warning: chalk.hex('#f59e0b'), // Amber
+    error: chalk.hex('#ef4444'), // Red
+    info: chalk.hex('#0ea5e9'), // Sky Blue (same as primary)
     // Text colors
-    dim: chalk.gray,
-    muted: chalk.hex('#6B7280'),
+    dim: chalk.hex('#64748b'), // Slate
+    muted: chalk.hex('#94a3b8'), // Light slate
     highlight: chalk.bold.white,
     // Impact levels
-    critical: chalk.hex('#DC2626'), // Red
-    high: chalk.hex('#EA580C'), // Orange
-    medium: chalk.hex('#CA8A04'), // Yellow
-    low: chalk.hex('#16A34A'), // Green
+    critical: chalk.hex('#dc2626'), // Red
+    high: chalk.hex('#ea580c'), // Orange
+    medium: chalk.hex('#eab308'), // Yellow
+    low: chalk.hex('#22c55e'), // Green
     // Special
-    brand: chalk.hex('#7C3AED').bold,
-    link: chalk.hex('#3B82F6').underline,
-    code: chalk.hex('#F472B6'), // Pink
+    brand: chalk.hex('#0ea5e9').bold, // Sky Blue bold
+    link: chalk.hex('#38bdf8').underline,
+    code: chalk.hex('#7dd3fc'), // Light sky blue
+    // Menu colors (for autocomplete)
+    menuItem: chalk.hex('#0ea5e9'),
+    menuItemSelected: chalk.hex('#0ea5e9').bold.inverse,
+    menuDescription: chalk.hex('#64748b'),
 };
 export const icons = {
     // Status

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

@@ -7,4 +7,5 @@ export * from './table.js';
 export * from './spinner.js';
 export * from './prompt.js';
 export * from './progress.js';
+export * from './autocomplete.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/cli/ui/index.js

@@ -7,4 +7,5 @@ export * from './table.js';
 export * from './spinner.js';
 export * from './prompt.js';
 export * from './progress.js';
+export * from './autocomplete.js';
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archicore",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "AI Software Architect - code analysis, impact prediction, semantic search",
   "main": "dist/index.js",
   "type": "module",
@@ -18,6 +18,8 @@
   },
   "scripts": {
     "build": "tsc",
+    "build:frontend": "node scripts/build-frontend.js",
+    "build:all": "npm run build && npm run build:frontend",
     "dev": "tsx watch src/index.ts",
     "start": "node dist/index.js",
     "server": "tsx src/server/index.ts",
@@ -93,7 +95,11 @@
     "@types/multer": "^2.0.0",
     "@types/node": "^22.10.2",
     "@types/pg": "^8.11.6",
+    "clean-css": "^5.3.3",
+    "html-minifier-terser": "^7.2.0",
+    "javascript-obfuscator": "^4.1.1",
     "tsx": "^4.19.2",
-    "typescript": "^5.7.2"
+    "typescript": "^5.7.2",
+    "vite": "^5.4.11"
   }
 }