codehere 0.3.0-rc.10 → 0.3.0-rc.12

package/dist/presentation/cli/repl.js

@@ -1,370 +1,595 @@
 /**
- * Interactive REPL for codehere.
+ * Interactive REPL · raw-mode live command palette.
  *
- * Bare `codehere` (no args) drops here — the CLI surface, parallel to the
- * web UI at `codehere start`. Type a task in plain English; the Conductor
- * routes to the right specialist; events stream to the terminal; you get
- * the next prompt when the task completes.
+ * Faithful port of v0.2.2's session.ts (commit f4828c2 · "REPL fixes,
+ * Palette Enter completes selected command, stdin multi-char chunk
+ * processing"). Same banner with state badges, same `> ` prompt with
+ * brand color, same filter-as-you-type palette under the prompt, same
+ * escape-buffering keystroke handler, same Tab/Enter complete, same
+ * arrow-key palette navigation when palette is visible / history when not.
  *
- * Why this exists:
- * - The v0.2 REPL was removed in D7 along with the rest of the v0.2 CLI
- *   surface. That trim went too far — it removed a CLI entry point users
- *   relied on. rc.6 brings it back, this time backed by the v0.3
- *   Conductor (rule-based routing) instead of v0.2's smart-route.
- * - codehere is "PM you talk to" — terminal users should be able to talk
- *   to it in the terminal, not be forced to a web UI. Both surfaces, both
- *   first-class.
+ * Backends adapted to v0.3 (chat/edit/review/planner removed in D7):
+ *   - Task slash commands (ask, explain, fix, review, plan, test, refactor,
+ *     orchestrate, run) → spawn via Conductor
+ *   - Subcommand slash (trust, report, hook, status, health, serve, setup,
+ *     config) → invoke `node dist/index.js <cmd>` inline
+ *   - /undo → "queued for v0.5 (F3 memory layer)"
  *
- * What's here:
- * - Read a line → route via Conductor → spawn specialist → stream events
- *   to stdout → await completion → next prompt
- * - `/agents` lists installed specialists and the routing rules
- * - `/status` shows recent audit activity
- * - `/quit` (or Ctrl+C / Ctrl+D) exits cleanly
+ * Citing f4828c2 for lineage. Don't redesign.
  */
-import readline from 'readline';
-import { colors, newline } from '../../ui.js';
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join, basename } from 'path';
+import { spawn as childSpawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { colors, success, error, warning, newline, createCodehereLogo, } from '../../ui.js';
 import { getVersion } from '../../utils/version.js';
 import { SessionManager, availableAgents } from '../../infrastructure/orchestration/session-manager.js';
+import chalk from 'chalk';
+const brandBlue = chalk.rgb(74, 144, 226);
+const stdin = process.stdin;
+const stdout = process.stdout;
 const SLASH_COMMANDS = [
-    // Task commands · describe the work, the Conductor routes
+    // Tasks · delegate via Conductor
     {
-        name: 'fix',
-        aliases: ['edit'],
-        args: '<file> <instruction>',
-        description: 'fix or edit a file (Conductor routes to Aider by default)',
-        action: 'task',
-        promptTemplate: (args) => {
-            const parts = args.split(/\s+/);
-            const file = parts[0];
-            const instr = parts.slice(1).join(' ');
-            return `fix ${file}: ${instr}`;
-        },
+        name: 'ask',
+        args: '<question>',
+        description: 'Ask anything about your codebase',
+        kind: 'task',
+        promptTemplate: (a) => a,
     },
     {
         name: 'explain',
-        aliases: ['e'],
         args: '<file>',
-        description: 'explain a file (Conductor routes to Claude Code by default)',
-        action: 'task',
-        promptTemplate: (args) => `explain this file in plain English: ${args}`,
+        description: 'Explain a file',
+        kind: 'task',
+        promptTemplate: (a) => `Explain this file in plain English: ${a}`,
+    },
+    {
+        name: 'fix',
+        args: '<file> <hint>',
+        description: 'Apply a targeted fix',
+        kind: 'task',
+        promptTemplate: (a) => {
+            const parts = a.split(/\s+/);
+            const file = parts[0];
+            const hint = parts.slice(1).join(' ');
+            return `fix ${file}: ${hint}`;
+        },
     },
     {
         name: 'review',
-        aliases: ['r'],
         args: '<file>',
-        description: 'review a file for bugs and risks (routes to Claude Code)',
-        action: 'task',
-        promptTemplate: (args) => `review ${args} for bugs, security issues, and risks. List concrete findings.`,
+        description: 'Code review with findings',
+        kind: 'task',
+        promptTemplate: (a) => `Review ${a} for bugs, security issues, and risks. Concrete findings only.`,
     },
     {
         name: 'plan',
-        aliases: ['p'],
-        args: '<instruction>',
-        description: 'plan a complex task into steps (routes to Codex/Claude Code)',
-        action: 'task',
-        promptTemplate: (args) => `plan: ${args}. Break down into concrete steps before any execution.`,
+        args: '<goal>',
+        description: 'Break a goal into steps',
+        kind: 'task',
+        promptTemplate: (a) => `Plan: ${a}. Break into concrete steps before any execution.`,
     },
     {
         name: 'test',
-        args: '<file or area>',
-        description: 'add or write tests (routes to Codex)',
-        action: 'task',
-        promptTemplate: (args) => `add tests for ${args}. Cover edge cases and likely failure modes.`,
+        args: '<file>',
+        description: 'Generate tests for a file',
+        kind: 'task',
+        promptTemplate: (a) => `add tests for ${a}. Cover edge cases and likely failure modes.`,
+    },
+    {
+        name: 'refactor',
+        args: '<pattern> <instr>',
+        description: 'Refactor across files',
+        kind: 'task',
+        promptTemplate: (a) => `refactor: ${a}`,
     },
-    // Meta · don't spawn agents · run locally
-    { name: 'agents', aliases: ['a'], description: 'list installed specialists + routing rules', action: 'meta' },
-    { name: 'status', aliases: ['s'], description: 'last 24h activity from the audit log', action: 'meta' },
-    { name: 'trust', args: '[path]', description: 'scan a path for security issues (default: current dir)', action: 'meta' },
-    { name: 'history', aliases: ['hist'], description: 'recent prompts in this session', action: 'meta' },
-    { name: 'web', description: 'launch the web UI at :3773 (in another terminal)', action: 'meta' },
-    { name: 'undo', description: 'undo the last edit (queued for v0.5 · F3 memory layer)', action: 'meta' },
-    { name: 'cost', description: 'usage / cost (alias for /status in v0.3)', action: 'meta' },
-    { name: 'clear', description: 'clear the screen', action: 'meta' },
-    { name: 'help', aliases: ['?'], description: 'show this help', action: 'meta' },
-    { name: 'quit', aliases: ['exit', 'q'], description: 'exit (Ctrl+C / Ctrl+D also work)', action: 'meta' },
+    // Subcommands · run an existing CLI subcommand inline
+    { name: 'trust', args: '[path]', description: 'Scan for vulnerabilities', kind: 'sub', noKey: true, subcommand: 'trust' },
+    { name: 'report', args: '[path]', description: 'Security audit report', kind: 'sub', noKey: true, subcommand: 'report' },
+    { name: 'hook', args: '[install|status]', description: 'Safety hook management', kind: 'sub', noKey: true, subcommand: 'hook' },
+    { name: 'status', args: '', description: 'Dashboard — hook activity', kind: 'sub', noKey: true, subcommand: 'status' },
+    { name: 'health', args: '', description: 'System health check', kind: 'sub', noKey: true, subcommand: 'health' },
+    { name: 'setup', args: '', description: 'Configure first-run preferences', kind: 'sub', noKey: true, subcommand: 'setup' },
+    { name: 'config', args: '[key] [value]', description: 'Manage preferences', kind: 'sub', noKey: true, subcommand: 'config' },
+    { name: 'agents', args: '', description: 'List installed specialists', kind: 'session', noKey: true },
+    { name: 'undo', args: '<file>', description: 'Undo file changes (queued for v0.5)', kind: 'session', noKey: true },
+    { name: 'history', args: '', description: 'Show command history', kind: 'session', noKey: true },
+    // Helpers
+    { name: 'help', args: '', description: 'Command reference', kind: 'session', noKey: true },
+    { name: 'clear', args: '', description: 'Clear the screen', kind: 'session', noKey: true },
+    { name: 'exit', args: '', description: 'Leave the session', kind: 'session', noKey: true },
 ];
-function findSlashCommand(input) {
-    const parts = input.trim().split(/\s+/);
-    const head = parts[0].toLowerCase();
-    for (const cmd of SLASH_COMMANDS) {
-        if (cmd.name === head || (cmd.aliases ?? []).includes(head)) {
-            return { command: cmd, args: parts.slice(1).join(' ').trim() };
-        }
+const PALETTE_CMDS = SLASH_COMMANDS.map((c) => ({
+    sig: `/${c.name}${c.args ? ' ' + c.args : ''}`,
+    name: c.name,
+    desc: c.description,
+    noKey: c.noKey,
+}));
+function maxPalette() {
+    const rows = process.stdout.rows || 24;
+    return Math.min(rows - 8, 20);
+}
+// ── State detection (badges in welcome) ──────────────────────────────────
+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 {
+        /* ignore */
     }
-    return null;
+    const hasAnyAgent = availableAgents().some((a) => a.installed && a.id !== 'conductor');
+    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 {
+        /* ignore */
+    }
+    return { name, hasHooks, hasAgents: hasAnyAgent, isGitRepo, fileCount };
 }
-export async function runInteractiveRepl(options = {}) {
-    const cwd = options.cwd ?? process.cwd();
-    const history = [];
-    newline();
-    console.log(colors.bold('codehere ') + colors.dim('v' + getVersion()));
-    console.log(colors.dim('Talk to your AI coding agents. Type a task to delegate; or use a /command.'));
-    newline();
-    console.log(colors.dim('  /fix /explain /review /plan      delegate a task; Conductor picks the specialist'));
-    console.log(colors.dim('  /agents /status /trust /history  show state, no agent spawn'));
-    console.log(colors.dim('  /help                            full command list'));
-    console.log(colors.dim('  ↑/↓ history  ·  Ctrl+L clear  ·  Ctrl+C / Ctrl+D exit'));
-    newline();
-    const installed = availableAgents().filter((a) => a.installed);
-    if (installed.length === 0) {
-        console.log(colors.yellow('  No specialist agents installed. Install at least one to delegate tasks:'));
-        console.log(colors.dim('    npm install -g @anthropic-ai/claude-code'));
-        console.log(colors.dim('    npm install -g @openai/codex'));
-        console.log(colors.dim('    brew install aider'));
-        console.log(colors.dim('    curl -fsSL https://opencode.ai/install | bash'));
-        newline();
-        console.log(colors.dim('You can still use ') +
-            colors.cyan('/status') +
-            colors.dim(', ') +
-            colors.cyan('codehere trust .') +
-            colors.dim(', and the safety hook here.'));
-        newline();
+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.hasAgents ? colors.green('● agents') : colors.dim('○ agents'),
+    ];
+    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.hasAgents)
+        console.log('  ' + colors.yellow('→') + ' Install ' + colors.cyan('claude-code') + colors.dim(' / ') + colors.cyan('codex') + colors.dim(' / aider / opencode to delegate tasks'));
+    console.log(colors.dim('  Type / for commands, or ask anything'));
+    console.log();
+}
+// ── Main session ─────────────────────────────────────────────────────────
+export async function runInteractiveRepl() {
+    printWelcome();
+    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;
+    const cols = () => stdout.columns || 80;
+    function truncate(s, maxWidth) {
+        const visible = s.replace(/\x1b\[[0-9;]*m/g, '');
+        if (visible.length <= maxWidth)
+            return s;
+        let vis = 0;
+        let cut = 0;
+        for (let i = 0; i < s.length; i++) {
+            if (s[i] === '\x1b') {
+                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;
     }
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-        prompt: colors.cyan('› '),
-        terminal: true,
-        historySize: 200,
-    });
-    const manager = SessionManager.getInstance();
-    const promptNext = () => {
-        rl.setPrompt(colors.cyan('› '));
-        rl.prompt();
-    };
-    rl.on('close', () => {
-        newline();
-        console.log(colors.dim('Goodbye.'));
-        process.exit(0);
-    });
-    rl.on('SIGINT', () => {
-        rl.close();
-    });
-    promptNext();
-    for await (const line of rl) {
-        const trimmed = line.trim();
-        if (!trimmed) {
-            promptNext();
-            continue;
+    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;
+            }
         }
-        history.push(trimmed);
-        // Slash commands first
-        if (trimmed.startsWith('/')) {
-            const found = findSlashCommand(trimmed.slice(1));
-            if (!found) {
-                console.log(colors.yellow(`  Unknown command: ${trimmed.split(/\s+/)[0]}`));
-                console.log(colors.dim('  Run /help to see all commands.'));
-                promptNext();
-                continue;
+        else {
+            pLines = 0;
+        }
+    }
+    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;
+        }
+        // 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;
+        }
+        // Arrow up
+        if (key === '\x1b[A') {
+            if (pLines > 0) {
+                selected = Math.max(0, selected - 1);
             }
-            const { command, args } = found;
-            switch (command.name) {
-                case 'quit':
-                    rl.close();
-                    return;
-                case 'help':
-                    printSlashCommandHelp();
-                    break;
-                case 'clear':
-                    console.clear();
-                    newline();
-                    console.log(colors.bold('codehere ') + colors.dim('v' + getVersion()));
-                    newline();
-                    break;
-                case 'agents':
-                    printAgentsAndRoutingRules();
-                    break;
-                case 'status':
-                    await printStatusSummary();
-                    break;
-                case 'history':
-                    printHistory(history);
-                    break;
-                case 'web':
-                    console.log(colors.dim('  Tip: run ') +
-                        colors.cyan('codehere start') +
-                        colors.dim(' in another terminal to launch the web UI at http://127.0.0.1:3773'));
-                    break;
-                case 'trust':
-                    await runTrustScan(args || '.');
-                    break;
-                case 'cost':
-                    // v0.3 doesn't separate cost tracking — show the same dashboard as /status
-                    await printStatusSummary();
-                    break;
-                case 'undo':
-                    console.log(colors.dim('  /undo is queued for v0.5 (F3 memory layer).'));
-                    console.log(colors.dim('  For now, use git: ') + colors.cyan('git diff') + colors.dim(' / ') + colors.cyan('git checkout -- <file>'));
-                    break;
-                default: {
-                    // Task slash command (/fix, /explain, /review, /plan, /test) → Conductor
-                    if (command.action !== 'task' || !command.promptTemplate)
-                        break;
-                    if (!args) {
-                        console.log(colors.yellow(`  Usage: /${command.name}${command.args ? ' ' + command.args : ''}`));
-                        break;
-                    }
-                    if (installed.length === 0) {
-                        console.log(colors.yellow('  No specialist installed — install one and try again.'));
-                        break;
-                    }
-                    const promptText = command.promptTemplate(args);
-                    try {
-                        await runTask(promptText, cwd, manager);
-                    }
-                    catch (err) {
-                        console.log(colors.red('  ✗ ') + (err instanceof Error ? err.message : String(err)));
-                    }
-                    newline();
+            else if (historyBuf.length > 0 && historyIdx < historyBuf.length - 1) {
+                historyIdx++;
+                line = historyBuf[historyIdx];
+            }
+            render();
+            return;
+        }
+        // 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 = '';
                 }
             }
-            promptNext();
-            continue;
+            render();
+            return;
         }
-        // Legacy non-slash syntax for backwards-compat with v0.2 muscle memory
-        // (commit 796d4b7's REPL accepted these forms without /).
-        const lower = trimmed.toLowerCase();
-        const legacyMatch = lower.startsWith('explain ') || lower.startsWith('e ')
-            ? { name: 'explain', argsAt: lower.startsWith('explain ') ? 8 : 2 }
-            : lower.startsWith('fix ') || lower.startsWith('edit ')
-                ? { name: 'fix', argsAt: lower.startsWith('fix ') ? 4 : 5 }
-                : lower.startsWith('review ')
-                    ? { name: 'review', argsAt: 7 }
-                    : lower.startsWith('plan ')
-                        ? { name: 'plan', argsAt: 5 }
-                        : null;
-        if (legacyMatch) {
-            const cmd = SLASH_COMMANDS.find((c) => c.name === legacyMatch.name);
-            if (cmd?.promptTemplate) {
-                const args = trimmed.substring(legacyMatch.argsAt).trim();
-                if (!args) {
-                    console.log(colors.yellow(`  Usage: /${cmd.name}${cmd.args ? ' ' + cmd.args : ''}`));
+        // 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 (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}`;
                 }
-                else if (installed.length === 0) {
-                    console.log(colors.yellow('  No specialist installed — install one and try again.'));
+            }
+            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;
+            }
+            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;
+        }
+        // Backspace
+        if (key === '\x7f' || key === '\b') {
+            if (line.length > 0) {
+                line = line.slice(0, -1);
+                selected = 0;
+                render();
+            }
+            return;
+        }
+        // Ignore stray escape sequences
+        if (key.startsWith('\x1b'))
+            return;
+        // Regular character
+        line += key;
+        selected = 0;
+        render();
+    }
+    render();
+    stdin.on('data', (raw) => {
+        if (processing)
+            return;
+        if (raw.startsWith('\x1b') && raw.length >= 2) {
+            handle(raw);
+            return;
+        }
+        for (let i = 0; i < raw.length; i++) {
+            if (processing)
+                return;
+            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 {
-                    try {
-                        await runTask(cmd.promptTemplate(args), cwd, manager);
-                    }
-                    catch (err) {
-                        console.log(colors.red('  ✗ ') + (err instanceof Error ? err.message : String(err)));
-                    }
+                    escTimer = setTimeout(() => {
+                        const seq = escBuf;
+                        escBuf = '';
+                        handle(seq);
+                    }, 50);
                 }
-                newline();
-                promptNext();
                 continue;
             }
+            if (ch === '\x1b') {
+                escBuf = ch;
+                escTimer = setTimeout(() => {
+                    const seq = escBuf;
+                    escBuf = '';
+                    handle(seq);
+                }, 50);
+                continue;
+            }
+            handle(ch);
+        }
+    });
+}
+/** One-shot · `codehere "review src/auth.ts"` runs that task and exits. */
+export async function runOneShot(prompt) {
+    const installed = availableAgents().filter((a) => a.installed);
+    if (installed.length === 0) {
+        console.log(warning('No specialist installed. Run `codehere setup` and try again.'));
+        process.exit(1);
+    }
+    try {
+        await spawnViaConductor(prompt);
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+// ── Dispatch ─────────────────────────────────────────────────────────────
+async function executeInput(input, state) {
+    const lower = input.toLowerCase();
+    if (lower.startsWith('/')) {
+        const parts = input.substring(1).trim().split(/\s+/);
+        const cmd = parts[0].toLowerCase();
+        const args = parts.slice(1).join(' ');
+        await handleSlash(cmd, args, state);
+        return;
+    }
+    // Legacy non-slash syntax (v0.2 backwards compat)
+    if (lower.startsWith('explain '))
+        return runTask(`Explain this file in plain English: ${input.substring(8).trim()}`, state);
+    if (lower.startsWith('e '))
+        return runTask(`Explain this file in plain English: ${input.substring(2).trim()}`, state);
+    if (lower.startsWith('fix ')) {
+        const rest = input.substring(4).trim();
+        const parts = rest.split(/\s+/);
+        return runTask(`fix ${parts[0]}: ${parts.slice(1).join(' ')}`, state);
+    }
+    if (lower.startsWith('review '))
+        return runTask(`Review ${input.substring(7).trim()} for bugs, security, and risks.`, state);
+    if (lower.startsWith('plan '))
+        return runTask(`Plan: ${input.substring(5).trim()}. Break into steps.`, state);
+    // Default: ask via Conductor
+    await runTask(input, state);
+}
+async function handleSlash(cmd, args, state) {
+    if (cmd === 'help' || cmd === '?') {
+        showSlashCommandMenu();
+        return;
+    }
+    if (cmd === 'clear') {
+        stdout.write('\x1b[2J\x1b[H');
+        printWelcome();
+        return;
+    }
+    if (cmd === 'exit' || cmd === 'quit' || cmd === 'q') {
+        console.log(colors.dim('Goodbye! 👋'));
+        process.exit(0);
+    }
+    if (cmd === 'agents') {
+        const all = availableAgents();
+        newline();
+        console.log(colors.bold('  Installed specialists:'));
+        for (const a of all) {
+            const tag = a.installed ? colors.green('  ✓ ') : colors.dim('  · ');
+            const status = a.installed ? '' : colors.dim('  (not installed)');
+            console.log(tag + colors.cyan(a.id.padEnd(14)) + colors.dim(a.label) + status);
         }
-        // Plain text → delegate via Conductor
-        if (installed.length === 0) {
-            console.log(colors.yellow('  No specialist installed — install one and try again.'));
-            promptNext();
-            continue;
+        newline();
+        return;
+    }
+    if (cmd === 'history' || cmd === 'h') {
+        if (state.history.length === 0) {
+            console.log(colors.dim('No command history yet.'));
         }
-        try {
-            await runTask(trimmed, cwd, manager);
+        else {
+            console.log(colors.bold('Recent Commands:'));
+            state.history.slice(-10).forEach((h, i) => {
+                const preview = h.command.length > 60 ? h.command.slice(0, 57) + '…' : h.command;
+                console.log(colors.dim(`  ${i + 1}. ${preview}`));
+            });
         }
-        catch (err) {
-            console.log(colors.red('  ✗ ') + (err instanceof Error ? err.message : String(err)));
+        return;
+    }
+    if (cmd === 'undo') {
+        console.log(colors.dim('  /undo is queued for v0.5 (F3 memory layer).'));
+        console.log(colors.dim('  For now: ') + colors.cyan('git diff') + colors.dim(' / ') + colors.cyan('git checkout -- <file>'));
+        return;
+    }
+    const def = SLASH_COMMANDS.find((c) => c.name === cmd);
+    if (!def) {
+        console.log(warning(`Unknown command: /${cmd}`));
+        console.log(colors.dim('Type /help to see available commands'));
+        return;
+    }
+    if (def.kind === 'task' && def.promptTemplate) {
+        if (!args && def.args) {
+            console.log(warning(`Usage: /${def.name} ${def.args}`));
+            return;
         }
-        newline();
-        promptNext();
+        await runTask(def.promptTemplate(args), state);
+        return;
+    }
+    if (def.kind === 'sub' && def.subcommand) {
+        await runSubcommand(def.subcommand, args ? args.split(/\s+/) : []);
+        return;
     }
 }
-/**
- * Run `codehere trust <path>` inline. Spawns the trust command as a child
- * process so the existing rendering / scoring logic is reused as-is.
- */
-async function runTrustScan(target) {
-    const { spawn } = await import('child_process');
-    const { fileURLToPath } = await import('url');
-    const { join, dirname } = await import('path');
-    // dist/presentation/cli/repl.js → walk up to dist/index.js
+function showSlashCommandMenu() {
+    newline();
+    console.log(colors.bold('  Slash commands'));
+    newline();
+    const maxNameLen = Math.max(...SLASH_COMMANDS.map((c) => c.name.length + c.args.length)) + 1;
+    for (const cmd of SLASH_COMMANDS) {
+        const signature = `/${cmd.name}${cmd.args ? ' ' + cmd.args : ''}`;
+        const pad = ' '.repeat(Math.max(0, maxNameLen + 2 - signature.length + 8));
+        const badge = cmd.noKey ? colors.dim(' (free)') : '';
+        console.log(`  ${colors.cyan(signature)}${pad}${colors.dim(cmd.description)}${badge}`);
+    }
+    newline();
+    console.log(colors.dim('  Type any command with / prefix, or just ask a question directly.'));
+    newline();
+}
+// ── Run-task / Run-subcommand helpers ────────────────────────────────────
+async function runTask(prompt, state) {
+    await spawnViaConductor(prompt, state);
+}
+async function runSubcommand(name, extraArgs) {
     const here = fileURLToPath(import.meta.url);
     const cliPath = join(dirname(here), '..', '..', 'index.js');
     await new Promise((resolve) => {
-        const child = spawn('node', [cliPath, 'trust', target], { stdio: 'inherit' });
+        const child = childSpawn('node', [cliPath, name, ...extraArgs], { stdio: 'inherit' });
         child.on('close', () => resolve());
         child.on('error', (err) => {
-            console.log(colors.red('  ✗ ') + err.message);
+            console.log(error('  ' + err.message));
             resolve();
         });
     });
 }
-function printSlashCommandHelp() {
-    const formatRow = (cmd) => {
-        const aliases = cmd.aliases?.length ? colors.dim(' (/' + cmd.aliases.join(', /') + ')') : '';
-        const cmdLabel = '/' + cmd.name + (cmd.args ? ' ' + cmd.args : '');
-        console.log('    ' + colors.cyan(cmdLabel.padEnd(34)) + colors.dim(cmd.description) + aliases);
-    };
-    newline();
-    console.log(colors.bold('Slash commands'));
-    console.log(colors.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-    newline();
-    console.log(colors.bold('  Tasks') + colors.dim(' — describe the work; Conductor routes to the right specialist'));
-    for (const cmd of SLASH_COMMANDS.filter((c) => c.action === 'task'))
-        formatRow(cmd);
-    newline();
-    console.log(colors.bold('  Meta') + colors.dim(' — run locally, no agent spawn'));
-    for (const cmd of SLASH_COMMANDS.filter((c) => c.action === 'meta'))
-        formatRow(cmd);
-    newline();
-    console.log(colors.bold('  Or just type'));
-    console.log(colors.dim('    Plain text without / → Conductor routes (e.g. "review src/auth.ts" → claude-code)'));
-    console.log(colors.dim('    Legacy v0.2 syntax: ') + colors.cyan('explain src/auth.ts') + colors.dim(' / ') + colors.cyan('fix file "instr"') + colors.dim(' also work without /'));
-    newline();
-}
-function printHistory(history) {
-    newline();
-    if (history.length === 0) {
-        console.log(colors.dim('  No prompts yet in this session.'));
-        newline();
-        return;
-    }
-    console.log(colors.bold('  Recent prompts:'));
-    history.slice(-10).forEach((h, i) => {
-        const preview = h.length > 70 ? h.slice(0, 67) + '…' : h;
-        console.log(colors.dim(`    ${(i + 1).toString().padStart(2, ' ')}. `) + preview);
-    });
-    newline();
-}
-/**
- * Run a single task and exit — bypass the REPL prompt loop.
- * Use case: `codehere "review src/auth.ts"` or scripts piping a task in.
- */
-export async function runOneShot(prompt, cwd = process.cwd()) {
+async function spawnViaConductor(prompt, state) {
     const installed = availableAgents().filter((a) => a.installed);
     if (installed.length === 0) {
-        console.log(colors.yellow('  No specialist installed. Install one (see `codehere setup`) and try again.'));
-        process.exit(1);
+        console.log(warning('No specialist installed — install one and try again.'));
+        return;
     }
     const manager = SessionManager.getInstance();
-    try {
-        await runTask(prompt, cwd, manager);
-    }
-    catch (err) {
-        console.log(colors.red('  ✗ ') + (err instanceof Error ? err.message : String(err)));
-        process.exit(1);
-    }
-}
-async function runTask(prompt, cwd, manager) {
-    const session = manager.spawn(prompt, 'conductor', { cwd });
-    const startedLabel = colors.dim('  ┌─ ') + colors.bold(session.sessionId.slice(0, 8)) + colors.dim(' · ' + new Date(session.startedAt).toLocaleTimeString());
-    console.log(startedLabel);
+    const session = manager.spawn(prompt, 'conductor', { cwd: process.cwd() });
+    console.log(colors.dim('  ┌─ ') +
+        colors.bold(session.sessionId.slice(0, 8)) +
+        colors.dim(' · ' + new Date(session.startedAt).toLocaleTimeString()));
+    let captured = '';
     await new Promise((resolve) => {
         const unsubscribe = session.subscribe((event) => {
-            renderEvent(event);
+            const text = renderEvent(event);
+            if (text)
+                captured += text + '\n';
             if (event.type === 'codehere:complete' || event.type === 'codehere:error' || event.type === 'exit') {
                 unsubscribe();
                 resolve();
             }
         });
     });
-    const finalStatus = session.status;
-    const verdict = finalStatus === 'completed' ? colors.green('  └─ done') : finalStatus === 'killed' ? colors.yellow('  └─ killed') : colors.red('  └─ ' + finalStatus);
+    const status = session.status;
+    const verdict = status === 'completed'
+        ? success('  └─ done')
+        : status === 'killed'
+            ? warning('  └─ killed')
+            : error('  └─ ' + status);
     console.log(verdict);
+    if (state) {
+        state.history.push({ command: prompt, response: captured, timestamp: new Date().toISOString() });
+    }
 }
 function renderEvent(event) {
     switch (event.type) {
@@ -374,11 +599,7 @@ function renderEvent(event) {
                 colors.bold('routing → ') +
                 colors.cyan(data.delegatedTo ?? '?') +
                 colors.dim(' · ' + (data.reason ?? '')));
-            break;
-        }
-        case 'codehere:steps': {
-            // Step snapshots replay frequently — skip the noisy ones; the UI handles them
-            break;
+            return null;
         }
         case 'stdout':
         case 'stderr': {
@@ -386,89 +607,21 @@ function renderEvent(event) {
             const line = data?.line;
             if (line) {
                 const text = String(line).trimEnd();
-                if (text)
+                if (text) {
                     console.log(colors.dim('  │ ') + text);
+                    return text;
+                }
             }
-            break;
+            return null;
         }
         case 'error': {
             const data = event.data;
             if (data?.message)
                 console.log(colors.red('  │ ✗ ') + data.message);
-            break;
-        }
-        case 'codehere:complete':
-        case 'exit': {
-            // handled by runTask's verdict line
-            break;
+            return null;
         }
         default:
-            // Other event types — quiet by default to keep the REPL readable
-            break;
-    }
-}
-function printAgentsAndRoutingRules() {
-    newline();
-    console.log(colors.bold('  Installed specialists:'));
-    const all = availableAgents();
-    for (const a of all) {
-        const tag = a.installed ? colors.green('  ✓ ') : colors.dim('  · ');
-        const status = a.installed ? '' : colors.dim('  (not installed)');
-        console.log(tag + colors.cyan(a.id.padEnd(14)) + colors.dim(a.label) + status);
+            return null;
     }
-    newline();
-    console.log(colors.bold('  Routing (rule-based; LLM classifier in v0.4):'));
-    console.log(colors.dim('    review · audit · explain → claude-code'));
-    console.log(colors.dim('    refactor · restructure → codex'));
-    console.log(colors.dim('    fix · patch · bugfix → aider'));
-    console.log(colors.dim('    scaffold · generate · bootstrap → opencode'));
-    console.log(colors.dim('    add tests · write tests → codex'));
-    console.log(colors.dim('    (anything else) → claude-code'));
-    newline();
-}
-async function printStatusSummary() {
-    newline();
-    try {
-        const { existsSync, readFileSync } = await import('fs');
-        const { join } = await import('path');
-        const { homedir } = await import('os');
-        const auditPath = process.env.CODEHERE_AUDIT_FILE || join(homedir(), '.codehere', 'audit', 'hook-events.jsonl');
-        if (!existsSync(auditPath)) {
-            console.log(colors.dim('  No audit log yet. Run a task or `codehere hook install`.'));
-            newline();
-            return;
-        }
-        const lines = readFileSync(auditPath, 'utf-8').split('\n').filter(Boolean).slice(-10);
-        const cutoff = Date.now() - 24 * 60 * 60 * 1000;
-        let actions = 0;
-        let blocked = 0;
-        let trustSum = 0;
-        let trustN = 0;
-        for (const line of lines) {
-            try {
-                const entry = JSON.parse(line);
-                const ts = entry.timestamp ? Date.parse(entry.timestamp) : 0;
-                if (ts < cutoff)
-                    continue;
-                actions++;
-                if (entry.blocked)
-                    blocked++;
-                if (typeof entry.riskScore === 'number') {
-                    trustSum += 100 - entry.riskScore;
-                    trustN++;
-                }
-            }
-            catch {
-                /* skip malformed line */
-            }
-        }
-        const avgTrust = trustN > 0 ? Math.round(trustSum / trustN) : null;
-        console.log(colors.bold('  Last 24h:'));
-        console.log(`    ${actions} actions · ${blocked} blocked${avgTrust !== null ? ` · avg trust ${avgTrust}` : ''}`);
-    }
-    catch (err) {
-        console.log(colors.dim('  Could not read audit log: ' + (err instanceof Error ? err.message : String(err))));
-    }
-    newline();
 }
 //# sourceMappingURL=repl.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehere",
-  "version": "0.3.0-rc.10",
+  "version": "0.3.0-rc.12",
   "description": "A PM for your AI coding agents. Delegate, orchestrate, and audit Claude Code, Codex, Aider, and OpenCode from one local web UI — every AI action traced, every file scored.",
   "main": "dist/index.js",
   "type": "module",