codehere 0.2.2 → 0.3.0-rc.2

package/dist/session.js

@@ -1,704 +0,0 @@
-/**
- * Interactive Session — the main codehere experience
- *
- * Uses raw stdin for live command palette.
- * Pattern copied from test-real.mjs which is verified working.
- */
-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, 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() {
-    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;
-        }
-        // 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);
-            }
-            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 = '';
-                }
-            }
-            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;
-        }
-        // Backspace
-        if (key === '\x7f' || key === '\b') {
-            if (line.length > 0) {
-                line = line.slice(0, -1);
-                selected = 0;
-                render();
-            }
-            return;
-        }
-        // 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);
-        }
-    });
-}
-// ── 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;
-    }
-    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;
-    }
-    // Exact keywords for REPL control
-    if (/^(exit|quit)$/i.test(input)) {
-        console.log(colors.dim('  See you.'));
-        process.exit(0);
-    }
-    if (/^(help|\?)$/i.test(input)) {
-        printCommandList();
-        return;
-    }
-    if (input.toLowerCase() === 'clear') {
-        stdout.write('\x1b[2J\x1b[H');
-        return;
-    }
-    // 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);
-}
-// ── Slash commands ──────────────────────────────────────────────────────────
-async function handleSlash(cmd, args, state) {
-    switch (cmd) {
-        case 'ask':
-        case 'q':
-            if (!args) {
-                console.log(colors.dim('  Usage: /ask <question>'));
-                return;
-            }
-            await handleQuery(args, state);
-            break;
-        case 'explain':
-        case 'e':
-            if (!args) {
-                console.log(colors.dim('  Usage: /explain <file>'));
-                return;
-            }
-            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':
-            if (!args) {
-                console.log(colors.dim('  Usage: /review <file>'));
-                return;
-            }
-            await handleReview(args);
-            break;
-        case 'plan':
-            if (!args) {
-                console.log(colors.dim('  Usage: /plan <goal>'));
-                return;
-            }
-            await handlePlan(args);
-            break;
-        case 'trust': {
-            const { executeTrustCommand } = await import('./presentation/cli/commands/trust-command.js');
-            await executeTrustCommand(args || undefined);
-            break;
-        }
-        case 'report': {
-            const { executeReportCommand } = await import('./presentation/cli/commands/report-command.js');
-            await executeReportCommand(args || undefined);
-            break;
-        }
-        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;
-            }
-            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 '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;
-            }
-            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 '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 {
-                await indexRepositoryParallel(process.cwd(), { useCache: true, maxConcurrency: 5 });
-                spinner.succeed(colors.green('Index built'));
-            }
-            catch (err) {
-                spinner.fail(error('Index failed: ' + (err instanceof Error ? err.message : String(err))));
-            }
-            break;
-        }
-        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 '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 '?':
-            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'));
-            }
-        }
-    }
-}
-// ── Handlers ────────────────────────────────────────────────────────────────
-function startSpinner(text) {
-    return ora({ text: colors.dim(text), spinner: 'dots', color: 'cyan' }).start();
-}
-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;
-}
-async function handleQuery(query, state) {
-    if (!(await requireKey()))
-        return;
-    const spinner = startSpinner('Thinking...');
-    try {
-        const { container } = await import('./application/services/dependency-container.js');
-        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());
-        const history = conversationContextManager.getHistory(sessionId, 5);
-        const result = await router.route({
-            query,
-            context: {
-                currentDirectory: process.cwd(),
-                conversationHistory: history.map(t => ({ query: t.query, response: t.response, timestamp: typeof t.timestamp === 'string' ? Date.parse(t.timestamp) : t.timestamp })),
-                sessionId,
-            },
-        });
-        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 {
-            console.log(colors.dim('  No response. Try rephrasing, or run "codehere index" first.'));
-        }
-        state.history.push({ command: query, response: result.message || result.error || '', timestamp: new Date().toISOString() });
-        const entities = conversationContextManager.extractEntities(query);
-        conversationContextManager.addTurn(sessionId, query, result.message || '', entities, result.intent);
-    }
-    catch (err) {
-        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.`));
-        }
-        else {
-            console.log(error('  ' + msg));
-        }
-    }
-}
-async function handleExplain(file) {
-    if (!(await requireKey()))
-        return;
-    const fullPath = join(process.cwd(), file);
-    if (!existsSync(fullPath)) {
-        console.log(error(`  Not found: ${file}`));
-        return;
-    }
-    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();
-}
-async function handleFix(file, hint) {
-    if (!(await requireKey()))
-        return;
-    if (!hint) {
-        console.log(colors.dim('  Usage: /fix <file> <what to fix>'));
-        return;
-    }
-    const { executeFixCommand } = await import('./presentation/cli/commands/fix-command.js');
-    await executeFixCommand(file, hint);
-}
-async function handleReview(file) {
-    if (!(await requireKey()))
-        return;
-    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}`);
-    }
-}
-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