codehere 0.1.1 → 0.2.2

package/dist/session.js

@@ -1,325 +1,617 @@
 /**
- * Interactive Session System
- * Seamless REPL-like interface for natural interaction
+ * Interactive Session — the main codehere experience
+ *
+ * Uses raw stdin for live command palette.
+ * Pattern copied from test-real.mjs which is verified working.
  */
-import * as readline from 'readline';
-import { chatWithContext } from './chat.js';
-import { searchIntelligent } from './search.js';
-import { generateAndApplyEdit } from './edit.js';
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join, basename } from 'path';
+import ora from 'ora';
+import chalk from 'chalk';
+// Brand colors
+const brandBlue = chalk.rgb(74, 144, 226); // #4a90e2
+const brandCoral = chalk.rgb(255, 154, 118); // #ff9a76
+import { chatWithContextStream } from './chat.js';
+import { createMarkdownStream } from './infrastructure/ux/stream-markdown.js';
 import { reviewFile } from './review.js';
 import { planTask, formatPlan } from './planner.js';
 import { IntelligentRouter } from './application/services/intelligent-router.js';
-import { colors, success, error, warning, info, newline, formatNumber, formatPercent, createWelcomeMessage, createSessionWelcome, } from './ui.js';
-import { sessionTokenTracker } from './infrastructure/cost/session-token-tracker.js';
-import { cleanResponse } from './formatter.js';
-/**
- * Start interactive session
- */
+import { colors, error, warning, createCodehereLogo, SLASH_COMMANDS, } from './ui.js';
+import { getVersion } from './utils/version.js';
+const stdin = process.stdin;
+const stdout = process.stdout;
+// Build palette command list from SLASH_COMMANDS
+const PALETTE_CMDS = SLASH_COMMANDS.map(c => ({
+    sig: `/${c.name}${c.args ? ' ' + c.args : ''}`,
+    name: c.name,
+    desc: c.description,
+    noKey: c.noKey,
+}));
+// Dynamic: leave room for prompt + header lines
+function maxPalette() {
+    const rows = process.stdout.rows || 24;
+    return Math.min(rows - 8, 20); // 8 lines reserved for header/prompt/footer
+}
+// ── State detection ─────────────────────────────────────────────────────────
+function detectState() {
+    const cwd = process.cwd();
+    const name = basename(cwd);
+    const settingsPath = join(process.env.HOME || '', '.claude', 'settings.json');
+    let hasHooks = false;
+    try {
+        hasHooks = existsSync(settingsPath) && readFileSync(settingsPath, 'utf-8').includes('codehere');
+    }
+    catch { }
+    const hasApiKey = !!(process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY || process.env.COHERE_API_KEY);
+    const hasEmbeddings = existsSync(join(cwd, '.codehere-cache', 'embeddings.sqlite'));
+    const isGitRepo = existsSync(join(cwd, '.git'));
+    let fileCount = 0;
+    try {
+        const count = (dir, d) => {
+            if (d > 3)
+                return 0;
+            let n = 0;
+            for (const e of readdirSync(dir, { withFileTypes: true })) {
+                if (e.name.startsWith('.') || e.name === 'node_modules' || e.name === 'dist')
+                    continue;
+                if (e.isDirectory())
+                    n += count(join(dir, e.name), d + 1);
+                else
+                    n++;
+            }
+            return n;
+        };
+        fileCount = count(cwd, 0);
+    }
+    catch { }
+    return { name, hasHooks, hasApiKey, hasEmbeddings, isGitRepo, fileCount };
+}
+function printWelcome() {
+    const state = detectState();
+    const logo = createCodehereLogo();
+    const ver = colors.dim(`v${getVersion()}`);
+    console.log();
+    console.log(`  ${logo} ${ver}`);
+    console.log();
+    const badges = [
+        state.hasHooks ? colors.green('● hooks') : colors.dim('○ hooks'),
+        state.hasApiKey ? colors.green('● api') : colors.dim('○ api'),
+        state.hasEmbeddings ? colors.green('● indexed') : colors.dim('○ indexed'),
+    ];
+    console.log('  ' + badges.join('  '));
+    console.log();
+    console.log(colors.dim(`  ${state.name}`) + colors.dim(` · ${state.isGitRepo ? 'git' : 'dir'} · ${state.fileCount} files`));
+    console.log();
+    if (!state.hasHooks)
+        console.log('  ' + colors.yellow('→') + ' ' + colors.cyan('/hook install') + colors.dim(' to activate safety scanning'));
+    else if (!state.hasApiKey)
+        console.log('  ' + colors.yellow('→') + ' ' + colors.cyan('codehere setup') + colors.dim(' to add an API key'));
+    else if (!state.hasEmbeddings)
+        console.log('  ' + colors.yellow('→') + ' Type ' + colors.cyan('/index') + colors.dim(' to enable semantic search'));
+    console.log(colors.dim('  Type / for commands, or ask anything'));
+    console.log();
+}
+// ── Main session ────────────────────────────────────────────────────────────
 export async function startSession() {
-    // Show welcome
-    console.clear();
-    console.log(createSessionWelcome());
-    newline();
-    console.log(colors.dim('Type your questions naturally, or use /commands. Type /help for all commands, exit to quit.'));
-    newline();
-    console.log(colors.dim('Keyboard Shortcuts: ↑/↓ for history, Ctrl+C to cancel, Ctrl+D to exit, Ctrl+L to clear'));
-    newline();
-    console.log(colors.dim('────────────────────────────────────────────────────'));
-    newline();
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-        prompt: colors.cyan('codehere> '),
-        historySize: 100, // Enhanced: Store up to 100 commands for history navigation
-    });
-    const state = {
-        history: [],
-        context: null,
-    };
-    rl.prompt();
-    rl.on('line', async (input) => {
-        const trimmed = input.trim();
-        if (!trimmed) {
-            rl.prompt();
+    printWelcome();
+    // Raw mode
+    if (stdin.isTTY)
+        stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
+    const state = { history: [] };
+    const historyBuf = [];
+    let historyIdx = -1;
+    let line = '';
+    let selected = 0;
+    let pLines = 0;
+    let processing = false;
+    let escBuf = '';
+    let escTimer = null;
+    // ── Render: clear from prompt to end of screen, redraw everything ──
+    // Key insight: truncate all output lines to terminal width to prevent wrapping,
+    // which breaks cursor-up counting.
+    const cols = () => stdout.columns || 80;
+    function truncate(s, maxWidth) {
+        // Strip ANSI to measure visible length, truncate if needed
+        const visible = s.replace(/\x1b\[[0-9;]*m/g, '');
+        if (visible.length <= maxWidth)
+            return s;
+        // Truncate by removing chars from the end (keep ANSI structure intact)
+        let vis = 0;
+        let cut = 0;
+        for (let i = 0; i < s.length; i++) {
+            if (s[i] === '\x1b') {
+                // Skip ANSI sequence
+                const end = s.indexOf('m', i);
+                if (end !== -1) {
+                    i = end;
+                    continue;
+                }
+            }
+            vis++;
+            if (vis >= maxWidth - 1) {
+                cut = i + 1;
+                break;
+            }
+        }
+        return cut > 0 ? s.slice(0, cut) + '\x1b[0m' : s;
+    }
+    function render() {
+        stdout.write('\r\x1b[J');
+        stdout.write(brandBlue('> ') + line);
+        if (line.startsWith('/') && !line.includes(' ')) {
+            const filter = line.slice(1).toLowerCase();
+            const allMatching = PALETTE_CMDS.filter(c => c.name.startsWith(filter));
+            const limit = maxPalette();
+            const filtered = allMatching.slice(0, limit);
+            const overflow = allMatching.length - filtered.length;
+            if (filtered.length > 0) {
+                const maxLen = Math.max(...filtered.map(c => c.sig.length));
+                const w = cols();
+                let drawnLines = 0;
+                for (let i = 0; i < filtered.length; i++) {
+                    const c = filtered[i];
+                    const pad = ' '.repeat(Math.max(1, maxLen - c.sig.length + 2));
+                    const badge = c.noKey ? colors.dim(' (free)') : '';
+                    const prefix = i === selected ? brandBlue('▸') : ' ';
+                    const text = i === selected ? brandBlue(c.sig) : c.sig;
+                    const row = `  ${prefix} ${text}${pad}${colors.dim(c.desc)}${badge}`;
+                    stdout.write('\n' + truncate(row, w));
+                    drawnLines++;
+                }
+                if (overflow > 0) {
+                    stdout.write('\n' + colors.dim(`  ... +${overflow} more (type to filter)`));
+                    drawnLines++;
+                }
+                stdout.write(`\x1b[${drawnLines}A`);
+                stdout.write(`\x1b[${line.length + 3}G`);
+                pLines = drawnLines;
+            }
+            else {
+                stdout.write('\n' + colors.dim('  No matching commands'));
+                stdout.write('\x1b[1A');
+                stdout.write(`\x1b[${line.length + 3}G`);
+                pLines = 1;
+            }
+        }
+        else {
+            pLines = 0;
+        }
+    }
+    // ── Key handler (synchronous for palette, async exec wrapped separately) ──
+    function handle(key) {
+        if (processing)
+            return;
+        // Ctrl+C
+        if (key === '\x03') {
+            if (line.length > 0) {
+                line = '';
+                selected = 0;
+                stdout.write('\r\x1b[J\n');
+                render();
+            }
+            else {
+                stdout.write('\r\x1b[J\n');
+                process.exit(0);
+            }
             return;
         }
-        // Handle exit
-        if (trimmed.toLowerCase() === 'exit' || trimmed.toLowerCase() === 'quit' || trimmed === 'q') {
-            console.log(info('Goodbye! 👋'));
-            rl.close();
+        // Ctrl+D
+        if (key === '\x04') {
+            stdout.write('\r\x1b[J\n' + colors.dim('  See you.') + '\n');
+            process.exit(0);
+        }
+        // Ctrl+L
+        if (key === '\x0c') {
+            line = '';
+            selected = 0;
+            stdout.write('\x1b[2J\x1b[H');
+            printWelcome();
+            render();
             return;
         }
-        // Handle help
-        if (trimmed.toLowerCase() === 'help' || trimmed === '?') {
-            showHelp();
-            showKeyboardShortcuts();
-            rl.prompt();
+        // Arrow up
+        if (key === '\x1b[A') {
+            if (pLines > 0) {
+                selected = Math.max(0, selected - 1);
+            }
+            else if (historyBuf.length > 0 && historyIdx < historyBuf.length - 1) {
+                historyIdx++;
+                line = historyBuf[historyIdx];
+            }
+            render();
             return;
         }
-        // Handle clear
-        if (trimmed.toLowerCase() === 'clear') {
-            console.clear();
-            console.log(createWelcomeMessage());
-            newline();
-            rl.prompt();
+        // Arrow down
+        if (key === '\x1b[B') {
+            if (pLines > 0) {
+                selected = Math.min(pLines - 1, selected + 1);
+            }
+            else {
+                if (historyIdx > 0) {
+                    historyIdx--;
+                    line = historyBuf[historyIdx];
+                }
+                else {
+                    historyIdx = -1;
+                    line = '';
+                }
+            }
+            render();
+            return;
+        }
+        // Tab
+        if (key === '\t' && pLines > 0) {
+            const filter = line.slice(1).toLowerCase();
+            const filtered = PALETTE_CMDS.filter(c => c.name.startsWith(filter)).slice(0, maxPalette());
+            if (filtered[selected]) {
+                line = `/${filtered[selected].name} `;
+                selected = 0;
+            }
+            render();
+            return;
+        }
+        // Enter
+        if (key === '\r' || key === '\n') {
+            // If palette is visible, complete the selected command first
+            if (pLines > 0 && line.startsWith('/') && !line.includes(' ')) {
+                const filter = line.slice(1).toLowerCase();
+                const filtered = PALETTE_CMDS.filter(c => c.name.startsWith(filter)).slice(0, maxPalette());
+                if (filtered[selected]) {
+                    line = `/${filtered[selected].name}`;
+                }
+            }
+            stdout.write('\r\x1b[J\n');
+            const trimmed = line.trim();
+            if (trimmed) {
+                historyBuf.unshift(trimmed);
+                historyIdx = -1;
+            }
+            line = '';
+            selected = 0;
+            pLines = 0;
+            if (!trimmed) {
+                render();
+                return;
+            }
+            // Async execution
+            processing = true;
+            executeInput(trimmed, state).catch(err => {
+                console.log(error('  ' + (err instanceof Error ? err.message : String(err))));
+            }).finally(() => {
+                processing = false;
+                stdin.resume();
+                stdin.ref();
+                if (stdin.isTTY && !stdin.isRaw)
+                    stdin.setRawMode(true);
+                console.log();
+                render();
+            });
             return;
         }
-        // Parse and execute command
-        try {
-            await executeCommand(trimmed, state, rl);
+        // Backspace
+        if (key === '\x7f' || key === '\b') {
+            if (line.length > 0) {
+                line = line.slice(0, -1);
+                selected = 0;
+                render();
+            }
+            return;
         }
-        catch (err) {
-            console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        // Ignore escape sequences
+        if (key.startsWith('\x1b'))
+            return;
+        // Regular character
+        line += key;
+        selected = 0;
+        render();
+    }
+    // ── Initial render ──
+    render();
+    // ── Stdin with escape buffering ──
+    // CRITICAL: raw mode can deliver multiple chars in one data event (fast typing, paste).
+    // We must process each character individually, except escape sequences which are multi-byte.
+    stdin.on('data', (raw) => {
+        if (processing)
+            return;
+        // If the whole chunk is a known escape sequence, handle it directly
+        if (raw.startsWith('\x1b') && raw.length >= 2) {
+            handle(raw);
+            return;
+        }
+        // Otherwise iterate character by character
+        for (let i = 0; i < raw.length; i++) {
+            if (processing)
+                return; // stop if a command started executing mid-chunk
+            const ch = raw[i];
+            if (escBuf.length > 0) {
+                escBuf += ch;
+                if (escTimer)
+                    clearTimeout(escTimer);
+                if (escBuf.length >= 3) {
+                    const seq = escBuf;
+                    escBuf = '';
+                    handle(seq);
+                }
+                else {
+                    escTimer = setTimeout(() => { const seq = escBuf; escBuf = ''; handle(seq); }, 50);
+                }
+                continue;
+            }
+            if (ch === '\x1b') {
+                escBuf = ch;
+                escTimer = setTimeout(() => { const seq = escBuf; escBuf = ''; handle(seq); }, 50);
+                continue;
+            }
+            handle(ch);
         }
-        rl.prompt();
-    });
-    rl.on('close', () => {
-        console.log(newline());
-        console.log(colors.dim('Session ended.'));
-        process.exit(0);
     });
 }
-/**
- * Execute command in session
- */
-async function executeCommand(input, state, rl) {
-    const lower = input.toLowerCase().trim();
-    // SLASH COMMANDS - /command syntax for better discoverability
-    // Support both /command and command syntax
-    if (lower.startsWith('/')) {
-        await handleSlashCommand(input.substring(1), state, rl);
+// ── Command list (for bare / or help) ──────────────────────────────────────
+function printCommandList() {
+    console.log();
+    const maxLen = Math.max(...PALETTE_CMDS.map(c => c.sig.length));
+    for (const cmd of PALETTE_CMDS) {
+        const pad = ' '.repeat(Math.max(1, maxLen - cmd.sig.length + 2));
+        const badge = cmd.noKey ? colors.dim(' (free)') : '';
+        console.log(`  ${colors.cyan(cmd.sig)}${pad}${colors.dim(cmd.desc)}${badge}`);
+    }
+}
+// ── Input dispatcher ────────────────────────────────────────────────────────
+async function executeInput(input, state) {
+    if (input === '/') {
+        printCommandList();
         return;
     }
-    // Detect command type (legacy syntax without slash)
-    if (lower.startsWith('explain ') || lower.startsWith('e ')) {
-        const file = input.substring(lower.startsWith('explain ') ? 8 : 2).trim();
-        await handleExplain(file, rl);
+    if (input.startsWith('/')) {
+        const spaceIdx = input.indexOf(' ');
+        const cmd = (spaceIdx === -1 ? input.slice(1) : input.slice(1, spaceIdx)).toLowerCase();
+        const args = spaceIdx === -1 ? '' : input.slice(spaceIdx + 1).trim();
+        await handleSlash(cmd, args, state);
+        return;
     }
-    else if (lower.startsWith('fix ') || lower.startsWith('edit ')) {
-        const parts = input.substring(lower.startsWith('fix ') ? 4 : 5).trim().split(' ');
-        const file = parts[0];
-        const instruction = parts.slice(1).join(' ');
-        await handleFix(file, instruction, rl);
+    // Exact keywords for REPL control
+    if (/^(exit|quit)$/i.test(input)) {
+        console.log(colors.dim('  See you.'));
+        process.exit(0);
     }
-    else if (lower.startsWith('review ')) {
-        const file = input.substring(7).trim();
-        await handleReview(file, rl);
+    if (/^(help|\?)$/i.test(input)) {
+        printCommandList();
+        return;
     }
-    else if (lower.startsWith('plan ')) {
-        const instruction = input.substring(5).trim();
-        await handlePlan(instruction, rl);
+    if (input.toLowerCase() === 'clear') {
+        stdout.write('\x1b[2J\x1b[H');
+        return;
     }
-    else {
-        // Default: use intelligent router - understands any query
-        await handleSmartQuery(input, state, rl);
+    // Bare command names: "trust ." or "status" → same as "/trust ." or "/status"
+    // Only match unambiguous commands — skip words that are common English ("help", "fix", "run", "plan", "report", "test")
+    const BARE_SAFE = ['trust', 'hook', 'status', 'health', 'setup', 'serve', 'models', 'config', 'index', 'explain', 'review', 'cost', 'undo'];
+    const lower = input.toLowerCase();
+    const firstWord = lower.split(/\s+/)[0];
+    const restArgs = input.slice(firstWord.length).trim();
+    if (BARE_SAFE.includes(firstWord)) {
+        await handleSlash(firstWord, restArgs, state);
+        return;
     }
+    // Everything else → AI query (the router decides what to do)
+    await handleQuery(input, state);
 }
-/**
- * Handle slash commands (/fix, /explain, /review, etc.)
- */
-async function handleSlashCommand(input, state, rl) {
-    const parts = input.trim().split(/\s+/);
-    const command = parts[0].toLowerCase();
-    const args = parts.slice(1).join(' ');
-    switch (command) {
-        case 'fix':
-        case 'edit': {
-            // /fix <file> <instruction>
-            const fixParts = args.split(/\s+/);
-            if (fixParts.length < 2) {
-                console.log(warning('Usage: /fix <file> <instruction>'));
-                console.log(colors.dim('Example: /fix src/utils.ts "add error handling"'));
+// ── Slash commands ──────────────────────────────────────────────────────────
+async function handleSlash(cmd, args, state) {
+    switch (cmd) {
+        case 'ask':
+        case 'q':
+            if (!args) {
+                console.log(colors.dim('  Usage: /ask <question>'));
                 return;
             }
-            const file = fixParts[0];
-            const instruction = fixParts.slice(1).join(' ');
-            await handleFix(file, instruction, rl);
+            await handleQuery(args, state);
             break;
-        }
         case 'explain':
-        case 'e': {
-            // /explain <file>
+        case 'e':
             if (!args) {
-                console.log(warning('Usage: /explain <file>'));
-                console.log(colors.dim('Example: /explain src/auth.ts'));
+                console.log(colors.dim('  Usage: /explain <file>'));
                 return;
             }
-            await handleExplain(args.split(/\s+/)[0], rl);
+            await handleExplain(args);
+            break;
+        case 'fix':
+        case 'edit': {
+            const p = args.split(' ');
+            if (!p[0]) {
+                console.log(colors.dim('  Usage: /fix <file> <instruction>'));
+                return;
+            }
+            await handleFix(p[0], p.slice(1).join(' '));
             break;
         }
         case 'review':
-        case 'r': {
-            // /review <file>
             if (!args) {
-                console.log(warning('Usage: /review <file>'));
-                console.log(colors.dim('Example: /review src/auth.ts'));
+                console.log(colors.dim('  Usage: /review <file>'));
                 return;
             }
-            await handleReview(args.split(/\s+/)[0], rl);
+            await handleReview(args);
             break;
-        }
         case 'plan':
-        case 'p': {
-            // /plan <instruction>
             if (!args) {
-                console.log(warning('Usage: /plan <instruction>'));
-                console.log(colors.dim('Example: /plan "add user authentication"'));
+                console.log(colors.dim('  Usage: /plan <goal>'));
                 return;
             }
-            await handlePlan(args, rl);
+            await handlePlan(args);
+            break;
+        case 'trust': {
+            const { executeTrustCommand } = await import('./presentation/cli/commands/trust-command.js');
+            await executeTrustCommand(args || undefined);
             break;
         }
-        case 'cost': {
-            // /cost - show instant session token stats (like Claude Code)
-            showSessionCostDisplay();
+        case 'report': {
+            const { executeReportCommand } = await import('./presentation/cli/commands/report-command.js');
+            await executeReportCommand(args || undefined);
             break;
         }
-        case 'trust': {
-            // /trust - show trust dashboard
-            try {
-                const { executeTrustCommand } = await import('./presentation/cli/commands/trust-command.js');
-                await executeTrustCommand('status');
+        case 'hook': {
+            const { executeHookCommand } = await import('./presentation/cli/commands/hook-command.js');
+            await executeHookCommand(args.split(' ')[0] || 'status');
+            break;
+        }
+        case 'status': {
+            const { executeStatusCommand } = await import('./presentation/cli/commands/status-command.js');
+            await executeStatusCommand({});
+            break;
+        }
+        case 'suggest': {
+            const { executeSuggestCommand } = await import('./presentation/cli/commands/suggest-command.js');
+            if (!args) {
+                console.log(colors.dim('  Usage: /suggest <query>'));
+                return;
             }
-            catch (err) {
-                console.log(error('Failed to get trust status'));
+            await executeSuggestCommand(args);
+            break;
+        }
+        case 'test': {
+            if (!args) {
+                console.log(colors.dim('  Usage: /test <file>'));
+                return;
             }
+            if (!(await requireKey()))
+                return;
+            await handleQuery(`Generate tests for ${args}`, state);
             break;
         }
-        case 'undo': {
-            // /undo - undo last edit
-            try {
-                const { executeUndoCommand } = await import('./presentation/cli/commands/undo-command.js');
-                await executeUndoCommand('undo');
+        case 'docs': {
+            const { executeDocsCommand } = await import('./presentation/cli/commands/docs-command.js');
+            await executeDocsCommand((args || 'readme'));
+            break;
+        }
+        case 'refactor': {
+            if (!args) {
+                console.log(colors.dim('  Usage: /refactor <goal>'));
+                return;
             }
-            catch (err) {
-                console.log(error('Failed to undo'));
+            if (!(await requireKey()))
+                return;
+            await handleQuery('Refactor: ' + args, state);
+            break;
+        }
+        case 'orchestrate': {
+            const { executeOrchestrateCommand } = await import('./presentation/cli/commands/orchestrate-command.js');
+            if (!args) {
+                console.log(colors.dim('  Usage: /orchestrate <goal>'));
+                return;
             }
+            await executeOrchestrateCommand(args, {});
             break;
         }
-        case 'status': {
-            // /status - show project status
+        case 'run': {
+            const { executeRunCommand } = await import('./presentation/cli/commands/run-command.js');
+            if (!args) {
+                console.log(colors.dim('  Usage: /run <goal>'));
+                return;
+            }
+            await executeRunCommand(args, {});
+            break;
+        }
+        case 'git-review': {
+            if (!(await requireKey()))
+                return;
+            await handleQuery('Review the recent git changes in this project', state);
+            break;
+        }
+        case 'index': {
+            if (!(await requireKey()))
+                return;
+            const { indexRepositoryParallel } = await import('./embed.js');
+            const spinner = startSpinner('Indexing codebase...');
             try {
-                const { executeStatusCommand } = await import('./presentation/cli/commands/status-command.js');
-                await executeStatusCommand();
+                await indexRepositoryParallel(process.cwd(), { useCache: true, maxConcurrency: 5 });
+                spinner.succeed(colors.green('Index built'));
             }
             catch (err) {
-                console.log(error('Failed to get status'));
+                spinner.fail(error('Index failed: ' + (err instanceof Error ? err.message : String(err))));
             }
             break;
         }
-        case 'history':
-        case 'h': {
-            // /history - show command history
-            if (state.history.length === 0) {
-                console.log(colors.dim('No command history yet.'));
-            }
-            else {
-                console.log(colors.bold('Recent Commands:'));
-                state.history.slice(-10).forEach((h, i) => {
-                    console.log(colors.dim(`  ${i + 1}. ${h.command.substring(0, 60)}${h.command.length > 60 ? '...' : ''}`));
-                });
-            }
+        case 'health': {
+            const { performHealthCheck, formatHealthStatus } = await import('./monitoring.js');
+            console.log(formatHealthStatus(performHealthCheck()));
+            break;
+        }
+        case 'setup': {
+            const { executeSetupCommand } = await import('./presentation/cli/commands/setup-command.js');
+            await executeSetupCommand(false);
+            break;
+        }
+        case 'serve': {
+            console.log(colors.dim('  MCP server must run in its own process:'));
+            console.log(colors.cyan('  codehere serve'));
+            break;
+        }
+        case 'config': {
+            const { executeConfigCommand } = await import('./presentation/cli/commands/config-command.js');
+            const parts = args.split(' ');
+            await executeConfigCommand(parts[0], parts[1], parts[2]);
+            break;
+        }
+        case 'cost': {
+            const { executeCostCommand } = await import('./presentation/cli/commands/cost-command.js');
+            await executeCostCommand((args || 'status'));
+            break;
+        }
+        case 'models': {
+            const { executeModelsCommand } = await import('./presentation/cli/commands/models-command.js');
+            await executeModelsCommand({ list: true });
             break;
         }
-        case 'clear': {
-            // /clear - clear screen
-            console.clear();
-            console.log(createWelcomeMessage());
-            newline();
+        case 'undo': {
+            const { executeUndoCommand } = await import('./presentation/cli/commands/undo-command.js');
+            await executeUndoCommand(args ? 'undo' : 'list', args || undefined);
             break;
         }
+        case 'clear':
+            stdout.write('\x1b[2J\x1b[H');
+            break;
         case 'help':
-        case '?': {
-            // /help - show help
-            showSlashCommandHelp();
+        case '?':
+            printCommandList();
             break;
+        case 'exit':
+        case 'quit':
+            console.log(colors.dim('  See you.'));
+            process.exit(0);
+        default: {
+            // Fuzzy match: find closest command
+            const ALL_CMD_NAMES = PALETTE_CMDS.map(c => c.name);
+            const KNOWN = [...ALL_CMD_NAMES, 'q', 'e', 'edit', 'quit'];
+            const match = KNOWN.find(k => k.startsWith(cmd));
+            if (match) {
+                console.log(colors.dim(`  Did you mean /${match}?`));
+            }
+            else {
+                console.log(warning(`  Unknown: /${cmd}`));
+                console.log(colors.dim('  Type / to see commands'));
+            }
         }
-        default:
-            console.log(warning(`Unknown command: /${command}`));
-            console.log(colors.dim('Type /help to see available commands'));
     }
 }
-/**
- * Show instant session cost display (like Claude Code)
- */
-function showSessionCostDisplay() {
-    newline();
-    console.log(colors.bold('Session Usage'));
-    console.log(colors.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-    newline();
-    const stats = sessionTokenTracker.getStats();
-    const formatTokens = (n) => {
-        if (n >= 1000000)
-            return `${(n / 1000000).toFixed(2)}M`;
-        if (n >= 1000)
-            return `${(n / 1000).toFixed(1)}k`;
-        return n.toLocaleString();
-    };
-    // Token display like Claude Code
-    console.log(colors.bold('  Tokens'));
-    console.log(`    Input:   ${colors.cyan('↓ ' + formatTokens(stats.inputTokens).padStart(10))}`);
-    console.log(`    Output:  ${colors.green('↑ ' + formatTokens(stats.outputTokens).padStart(10))}`);
-    if (stats.cacheReads > 0) {
-        console.log(`    Cache:   ${colors.dim('  ' + formatTokens(stats.cacheReads).padStart(10))}`);
-    }
-    newline();
-    // Cost display
-    console.log(colors.bold('  Cost'));
-    console.log(`    Session: ${colors.yellow('$' + stats.totalCost.toFixed(4))}`);
-    newline();
-    // Requests count
-    const requests = sessionTokenTracker.getRequests();
-    console.log(colors.dim(`  ${requests.length} API calls this session`));
-    newline();
-    // Quick summary line (like Claude Code)
-    console.log(colors.dim('  ─────────────────────────────'));
-    console.log(colors.bold('  ') + sessionTokenTracker.getDisplayString());
-    newline();
+// ── Handlers ────────────────────────────────────────────────────────────────
+function startSpinner(text) {
+    return ora({ text: colors.dim(text), spinner: 'dots', color: 'cyan' }).start();
 }
-/**
- * Show slash command help
- */
-function showSlashCommandHelp() {
-    newline();
-    console.log(colors.bold('Slash Commands'));
-    console.log(colors.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-    newline();
-    const commands = [
-        ['/fix <file> <instruction>', 'Apply AI-generated edit to a file'],
-        ['/explain <file>', 'Get AI explanation of a file'],
-        ['/review <file>', 'Review code quality and get suggestions'],
-        ['/plan <instruction>', 'Create an implementation plan'],
-        ['/cost', 'Show cost tracking status'],
-        ['/trust', 'Show agent trust/reliability dashboard'],
-        ['/undo', 'Undo last edit'],
-        ['/status', 'Show project status'],
-        ['/history', 'Show command history'],
-        ['/clear', 'Clear the screen'],
-        ['/help', 'Show this help message'],
-    ];
-    commands.forEach(([cmd, desc]) => {
-        console.log(`  ${colors.cyan(cmd.padEnd(30))} ${colors.dim(desc)}`);
-    });
-    newline();
-    console.log(colors.dim('Tip: You can also just type your question naturally!'));
-    console.log(colors.dim('Example: "how does authentication work?"'));
-    newline();
+async function requireKey() {
+    if (!process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY && !process.env.COHERE_API_KEY && process.env.CODEHERE_FAKE_AI !== '1') {
+        console.log(warning('  No API key set. Run: codehere setup'));
+        return false;
+    }
+    return true;
 }
-/**
- * Handle smart query (intelligent routing)
- */
-async function handleSmartQuery(query, state, rl) {
-    if (!process.env.COHERE_API_KEY) {
-        console.error(error('COHERE_API_KEY not found. Please set it in .env file.'));
+async function handleQuery(query, state) {
+    if (!(await requireKey()))
         return;
-    }
-    process.stdout.write(colors.dim('  Processing...\r'));
+    const spinner = startSpinner('Thinking...');
     try {
-        // Use memory-aware router
         const { container } = await import('./application/services/dependency-container.js');
-        const router = new IntelligentRouter(undefined, // Use default QueryIntentClassifier
-        container.aiService, container.memoryStreamService);
-        // Get conversation context for this session
+        const router = new IntelligentRouter(undefined, container.aiService, container.memoryStreamService);
         const { conversationContextManager } = await import('./infrastructure/context/conversation-context.js');
         const { sessionManager } = await import('./infrastructure/context/session-manager.js');
         const sessionId = sessionManager.getSessionId(process.cwd());
@@ -328,266 +620,85 @@ async function handleSmartQuery(query, state, rl) {
             query,
             context: {
                 currentDirectory: process.cwd(),
-                conversationHistory: history.map(turn => ({
-                    query: turn.query,
-                    response: turn.response,
-                    timestamp: typeof turn.timestamp === 'string' ? Date.parse(turn.timestamp) : turn.timestamp,
-                })),
+                conversationHistory: history.map(t => ({ query: t.query, response: t.response, timestamp: typeof t.timestamp === 'string' ? Date.parse(t.timestamp) : t.timestamp })),
                 sessionId,
             },
         });
-        process.stdout.write(' '.repeat(50) + '\r');
-        if (result.success) {
-            newline();
-            if (result.message) {
-                const formatted = cleanResponse(result.message);
-                console.log(formatted);
-            }
+        spinner.stop();
+        if (result.success && result.message) {
+            const { formatMarkdownForTerminal } = await import('./infrastructure/ux/stream-markdown.js');
+            console.log();
+            console.log(formatMarkdownForTerminal(result.message));
+        }
+        else if (result.error) {
+            console.log(error('  ' + result.error));
         }
         else {
-            newline();
-            if (result.error) {
-                console.log(error(result.error));
-            }
-            else if (result.message) {
-                console.log(warning(result.message));
-            }
+            console.log(colors.dim('  No response. Try rephrasing, or run "codehere index" first.'));
         }
-        newline();
-        // Save to history
-        const response = result.message || result.error || 'Processed';
-        state.history.push({
-            command: query,
-            response,
-            timestamp: new Date().toISOString(),
-        });
-        // Update conversation context (reuse variables from above)
+        state.history.push({ command: query, response: result.message || result.error || '', timestamp: new Date().toISOString() });
         const entities = conversationContextManager.extractEntities(query);
-        conversationContextManager.addTurn(sessionId, query, response, entities, result.intent);
+        conversationContextManager.addTurn(sessionId, query, result.message || '', entities, result.intent);
     }
     catch (err) {
-        process.stdout.write(' '.repeat(50) + '\r');
-        throw err;
-    }
-}
-/**
- * Handle ask command (legacy - kept for compatibility)
- */
-async function handleAsk(question, state, rl) {
-    if (!process.env.COHERE_API_KEY) {
-        console.error(error('COHERE_API_KEY not found. Please set it in .env file.'));
-        return;
-    }
-    // Show thinking indicator
-    process.stdout.write(colors.dim('  Thinking...\r'));
-    try {
-        // NEW: Use intelligent search
-        const searchResult = await searchIntelligent(question, {
-            baseDir: process.cwd(),
-        });
-        if (searchResult.chunks.length === 0) {
-            console.log(warning('No relevant code found. Run "codehere index" first.'));
-            return;
+        spinner.stop();
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes('No embeddings') || msg.includes('not found') || msg.includes('Not found')) {
+            console.log(colors.dim(`  Couldn't answer that. Try "codehere index" first, or rephrase your question.`));
         }
-        // Clear thinking indicator
-        process.stdout.write(' '.repeat(50) + '\r');
-        // Show context summary
-        const retrievedFiles = [...new Set(searchResult.chunks.map(r => r.filepath))];
-        console.log(colors.dim(`  Found ${formatNumber(searchResult.chunks.length)} optimized chunks from ${formatNumber(retrievedFiles.length)} file(s)`));
-        console.log(colors.dim(`  Token reduction: ${formatPercent(searchResult.reductionPercent)}`));
-        // Generate response
-        process.stdout.write(colors.dim('  Generating response...\r'));
-        const response = await chatWithContext(question, searchResult.chunks);
-        process.stdout.write(' '.repeat(50) + '\r');
-        // Display response (formatted)
-        newline();
-        const formattedResponse = cleanResponse(response);
-        console.log(formattedResponse);
-        newline();
-        // Save to history
-        state.history.push({
-            command: question,
-            response,
-            timestamp: new Date().toISOString(),
-        });
-    }
-    catch (err) {
-        process.stdout.write(' '.repeat(50) + '\r');
-        throw err;
-    }
-}
-/**
- * Handle explain command
- */
-async function handleExplain(file, rl) {
-    if (!process.env.COHERE_API_KEY) {
-        console.error(error('COHERE_API_KEY not found.'));
-        return;
-    }
-    process.stdout.write(colors.dim('  Reading file...\r'));
-    try {
-        const { readFileSync, existsSync } = await import('fs');
-        const { join } = await import('path');
-        const fullPath = join(process.cwd(), file);
-        if (!existsSync(fullPath)) {
-            process.stdout.write(' '.repeat(50) + '\r');
-            console.error(error(`File not found: ${file}`));
-            return;
+        else {
+            console.log(error('  ' + msg));
         }
-        const content = readFileSync(fullPath, 'utf-8');
-        process.stdout.write(colors.dim('  Generating explanation...\r'));
-        const context = [{
-                filepath: file,
-                content: content,
-                score: 1.0,
-            }];
-        const question = `Explain this file: ${file}`;
-        const response = await chatWithContext(question, context);
-        process.stdout.write(' '.repeat(50) + '\r');
-        newline();
-        console.log(colors.bold(`Explanation for ${file}:`));
-        const formattedResponse = cleanResponse(response);
-        console.log(formattedResponse);
-        newline();
-    }
-    catch (err) {
-        process.stdout.write(' '.repeat(50) + '\r');
-        throw err;
     }
 }
-/**
- * Handle fix command
- */
-async function handleFix(file, instruction, rl) {
-    if (!process.env.COHERE_API_KEY) {
-        console.error(error('COHERE_API_KEY not found.'));
+async function handleExplain(file) {
+    if (!(await requireKey()))
         return;
-    }
-    if (!instruction) {
-        console.error(error('Please provide an instruction. Example: fix file.js "Add error handling"'));
+    const fullPath = join(process.cwd(), file);
+    if (!existsSync(fullPath)) {
+        console.log(error(`  Not found: ${file}`));
         return;
     }
-    process.stdout.write(colors.dim('  Generating edit...\r'));
-    try {
-        const result = await generateAndApplyEdit(file, instruction);
-        process.stdout.write(' '.repeat(50) + '\r');
-        if (result.success) {
-            newline();
-            console.log(success('Edit applied successfully'));
-            if (result.diffStats) {
-                console.log(colors.dim(`  ${result.diffStats.linesAdded} added, ${result.diffStats.linesRemoved} removed`));
-            }
-        }
-        else {
-            newline();
-            console.log(error('Edit failed'));
-            if (result.error) {
-                console.log(colors.red(`  ${result.error}`));
-            }
-        }
-        newline();
-    }
-    catch (err) {
-        process.stdout.write(' '.repeat(50) + '\r');
-        throw err;
-    }
+    const spinner = startSpinner('Reading...');
+    const content = readFileSync(fullPath, 'utf-8');
+    const context = [{ filepath: file, content, score: 1.0 }];
+    spinner.stop();
+    console.log();
+    const md = createMarkdownStream();
+    await chatWithContextStream(`Explain this file: ${file}`, context, (token) => md.write(token));
+    md.flush();
+    console.log();
 }
-/**
- * Handle review command
- */
-async function handleReview(file, rl) {
-    if (!process.env.COHERE_API_KEY) {
-        console.error(error('COHERE_API_KEY not found.'));
+async function handleFix(file, hint) {
+    if (!(await requireKey()))
+        return;
+    if (!hint) {
+        console.log(colors.dim('  Usage: /fix <file> <what to fix>'));
         return;
     }
-    process.stdout.write(colors.dim('  Reviewing code...\r'));
-    try {
-        const review = await reviewFile(file);
-        process.stdout.write(' '.repeat(50) + '\r');
-        newline();
-        console.log(colors.bold(`Review for ${file}:`));
-        console.log(`Score: ${review.score}/100`);
-        console.log(`Issues: ${review.issues.length}`);
-        if (review.issues.length > 0) {
-            newline();
-            review.issues.slice(0, 5).forEach(issue => {
-                const icon = issue.severity === 'error' ? '✗' : issue.severity === 'warning' ? '⚠' : '→';
-                console.log(`  ${icon} ${issue.message}`);
-            });
-        }
-        newline();
-    }
-    catch (err) {
-        process.stdout.write(' '.repeat(50) + '\r');
-        throw err;
-    }
+    const { executeFixCommand } = await import('./presentation/cli/commands/fix-command.js');
+    await executeFixCommand(file, hint);
 }
-/**
- * Handle plan command
- */
-async function handlePlan(instruction, rl) {
-    if (!process.env.COHERE_API_KEY) {
-        console.error(error('COHERE_API_KEY not found.'));
+async function handleReview(file) {
+    if (!(await requireKey()))
         return;
-    }
-    process.stdout.write(colors.dim('  Planning...\r'));
-    try {
-        const plan = await planTask(instruction);
-        process.stdout.write(' '.repeat(50) + '\r');
-        newline();
-        console.log(colors.bold('Execution Plan:'));
-        console.log(formatPlan(plan));
-        newline();
-    }
-    catch (err) {
-        process.stdout.write(' '.repeat(50) + '\r');
-        throw err;
+    const spinner = startSpinner('Reviewing...');
+    const review = await reviewFile(file);
+    spinner.stop();
+    console.log();
+    console.log(colors.bold(`  ${file}`) + colors.dim(` · ${review.score}/100 · ${review.issues.length} issues`));
+    for (const issue of review.issues.slice(0, 5)) {
+        const icon = issue.severity === 'error' ? colors.red('✗') : issue.severity === 'warning' ? colors.yellow('!') : colors.dim('·');
+        console.log(`  ${icon} ${issue.message}`);
     }
 }
-/**
- * Show help
- */
-function showHelp() {
-    newline();
-    console.log(colors.bold('Slash Commands (recommended):'));
-    newline();
-    console.log(colors.cyan('  /fix <file> <instruction>') + '  Apply AI-generated edit');
-    console.log(colors.cyan('  /explain <file>') + '            Get AI explanation');
-    console.log(colors.cyan('  /review <file>') + '             Review code quality');
-    console.log(colors.cyan('  /plan <instruction>') + '        Create implementation plan');
-    console.log(colors.cyan('  /cost') + '                      Show cost tracking');
-    console.log(colors.cyan('  /trust') + '                     Show trust dashboard');
-    console.log(colors.cyan('  /undo') + '                      Undo last edit');
-    console.log(colors.cyan('  /status') + '                    Show project status');
-    console.log(colors.cyan('  /history') + '                   Show command history');
-    console.log(colors.cyan('  /help') + '                      Show all commands');
-    newline();
-    console.log(colors.bold('Quick Commands:'));
-    newline();
-    console.log(colors.cyan('  <question>') + '                 Ask anything about your codebase');
-    console.log(colors.cyan('  clear') + '                      Clear screen');
-    console.log(colors.cyan('  exit') + '                       Exit session (or: quit, q)');
-    newline();
-    console.log(colors.dim('Examples:'));
-    console.log(colors.dim('  How does authentication work?'));
-    console.log(colors.dim('  /explain src/auth.ts'));
-    console.log(colors.dim('  /fix src/utils.js "Add error handling"'));
-    newline();
-}
-/**
- * Show keyboard shortcuts (Task 7.5)
- */
-function showKeyboardShortcuts() {
-    newline();
-    console.log(colors.bold('Keyboard Shortcuts:'));
-    newline();
-    console.log(colors.cyan('  ↑/↓') + '        Navigate command history');
-    console.log(colors.cyan('  Tab') + '        Autocomplete (when available)');
-    console.log(colors.cyan('  Ctrl+C') + '     Cancel current operation');
-    console.log(colors.cyan('  Ctrl+D') + '     Exit session');
-    console.log(colors.cyan('  Ctrl+L') + '     Clear screen');
-    console.log(colors.cyan('  Esc') + '        Cancel current input');
-    console.log(colors.cyan('  Enter') + '      Execute command');
-    newline();
+async function handlePlan(goal) {
+    if (!(await requireKey()))
+        return;
+    const spinner = startSpinner('Planning...');
+    const plan = await planTask(goal);
+    spinner.stop();
+    console.log();
+    console.log(formatPlan(plan));
 }
 //# sourceMappingURL=session.js.map