ikie-cli 0.1.0

package/dist/repl.js

@@ -0,0 +1,948 @@
+import readline from 'readline';
+import { execSync } from 'child_process';
+import { restoreStdinListeners } from './agent.js';
+import { c, PROMPT, CONTINUE_PROMPT, printPromptHeader, drawBanner, infoLine, successLine, errorLine, THEMES, setTheme, stripAnsi, } from './theme.js';
+import { renderMarkdown } from './renderer.js';
+import { loadAllMemory } from './memory.js';
+import { HOME_DIR, saveConfig, DEFAULT_MODEL, FIREWORKS_BASE_URL, IKIE_HOST } from './config.js';
+import { join as pathJoin } from 'path';
+import { deleteSession, listSessions, loadSession, normalizeSessionName, saveSession } from './session.js';
+import { buildUserContent, formatBytes, loadClipboardImageAttachment, loadImageAttachment, hasClipboardImage } from './attachments.js';
+async function fetchModelsFromServer(config) {
+    const baseUrl = config.baseURL || FIREWORKS_BASE_URL;
+    const apiUrl = baseUrl.includes('/api/v1')
+        ? baseUrl.replace('/api/v1', '/api/models')
+        : `${IKIE_HOST}/api/models`;
+    const response = await fetch(apiUrl);
+    if (!response.ok)
+        throw new Error(`Failed to fetch models (${response.status})`);
+    const data = await response.json();
+    return data.models ?? [];
+}
+async function fetchAndDisplayModels(config) {
+    try {
+        console.log(c.muted('Fetching available models...'));
+        const models = await fetchModelsFromServer(config);
+        if (!models || models.length === 0) {
+            console.log(infoLine('No models available.'));
+            console.log(infoLine(`Current model: ${config.model}`));
+            return;
+        }
+        console.log(`\n${c.primary.bold('Available Models')}\n`);
+        for (const model of models) {
+            const defaultLabel = model.is_default ? c.success(' [DEFAULT]') : '';
+            const contextInfo = c.muted(`(${(model.context_window / 1024).toFixed(0)}K context)`);
+            console.log(`  ${c.secondary(model.name.padEnd(24))} ${c.white(model.display_name)}${defaultLabel} ${contextInfo}`);
+            console.log(`    ${c.dim(model.provider_model_id)}`);
+        }
+        console.log(`\n${c.muted('To switch models:')}`);
+        console.log(`  ${c.accent('/model')} ${c.muted('<name>')}`);
+        console.log(`\n${c.muted('Current model:')} ${c.white(config.model)}\n`);
+    }
+    catch (err) {
+        console.log(errorLine(`Error fetching models: ${err instanceof Error ? err.message : String(err)}`));
+        console.log(infoLine(`Current model: ${config.model}`));
+    }
+}
+const HISTORY_FILE = pathJoin(HOME_DIR, '.repl_history');
+const MAX_HISTORY = 500;
+const SLASH_CMDS = [
+    { name: 'help', desc: 'Show commands' },
+    { name: 'clear', desc: 'Clear conversation' },
+    { name: 'memory', desc: 'View/save memory', subs: [{ name: 'save', desc: 'Save a note' }] },
+    {
+        name: 'image',
+        desc: 'Attach image to next prompt',
+        args: '[path|list|clear]',
+        subs: [
+            { name: 'paste', desc: 'Attach clipboard image' },
+            { name: 'list', desc: 'List queued images' },
+            { name: 'clear', desc: 'Clear queued images' },
+        ],
+    },
+    {
+        name: 'session',
+        desc: 'Save/load chat sessions',
+        subs: [
+            { name: 'list', desc: 'List sessions' },
+            { name: 'save', desc: 'Save current session' },
+            { name: 'load', desc: 'Load a session' },
+            { name: 'new', desc: 'Start fresh session' },
+            { name: 'delete', desc: 'Delete a session' },
+        ],
+    },
+    { name: 'context', desc: 'Show project context' },
+    {
+        name: 'models',
+        desc: 'List available models',
+        subs: [
+            { name: 'list', desc: 'List available models' },
+            { name: 'refresh', desc: 'Refresh models from server' },
+        ],
+    },
+    { name: 'model', desc: 'Switch model', args: '<name>' },
+    {
+        name: 'settings',
+        desc: 'View/change settings',
+        subs: [
+            { name: 'show', desc: 'Show all settings' },
+            { name: 'model', desc: 'Change default model' },
+            { name: 'reset', desc: 'Reset to defaults' },
+        ],
+    },
+    { name: 'theme', desc: 'Change visual theme', args: '[name]' },
+    { name: 'rpm', desc: 'Set request limit', args: '[number]' },
+    { name: 'tokens', desc: 'Token estimate' },
+    { name: 'exit', desc: 'Exit Ikie' },
+];
+function slashCompleter(line) {
+    if (!line.startsWith('/'))
+        return [[], line];
+    const parts = line.slice(1).split(/\s+/);
+    const cmd = parts[0]?.toLowerCase() ?? '';
+    if (parts.length >= 2) {
+        const match = SLASH_CMDS.find(c => c.name === cmd);
+        if (match?.subs) {
+            const sub = parts[1].toLowerCase();
+            const hits = match.subs.filter(s => s.name.startsWith(sub)).map(s => `/${cmd} ${s.name}`);
+            return [hits, line];
+        }
+        return [[], line];
+    }
+    const hits = SLASH_CMDS.filter(c => c.name.startsWith(cmd)).map(c => '/' + c.name);
+    return [hits, line];
+}
+function printHelp() {
+    console.log(`
+${c.primary.bold('Ikie Commands')}
+
+  ${c.warning('/help')}            Show this help
+  ${c.warning('/clear')}           Clear conversation history
+  ${c.warning('/memory')}          Show loaded memory
+  ${c.warning('/memory save')}     Save a note
+  ${c.warning('/image <path>')}     Attach image to next prompt
+  ${c.warning('/image paste')}      Attach clipboard image
+  ${c.warning('/image list')}       List queued images
+  ${c.warning('/image clear')}      Clear queued images
+  ${c.warning('/session list')}    List saved sessions
+  ${c.warning('/session save')}    Save current chat
+  ${c.warning('/session load')}    Load saved chat
+  ${c.warning('/session new')}     Start a fresh chat
+  ${c.warning('/context')}         Show current project context
+  ${c.warning('/models')}          List available models
+  ${c.warning('/model <name>')}    Switch AI model
+  ${c.warning('/settings')}       View all settings
+  ${c.warning('/settings model')} Change default model (persisted)
+  ${c.warning('/settings temperature')} Set temperature (0-2)
+  ${c.warning('/settings max-tokens')}  Set max tokens
+  ${c.warning('/settings top-p')}       Set top P (0-1)
+  ${c.warning('/settings top-k')}       Set top K
+  ${c.warning('/settings auto-approve')} Toggle auto-approve
+  ${c.warning('/settings rpm')}    Set requests per minute
+  ${c.warning('/settings theme')}  Set visual theme
+  ${c.warning('/settings reset')}  Reset settings to defaults
+  ${c.warning('/theme <name>')}    Switch visual theme
+  ${c.warning('/theme')}           Pick a theme interactively
+  ${c.warning('/rpm [number]')}    Show or set request limit
+  ${c.warning('/tokens')}          Show conversation token estimate
+  ${c.warning('/exit')}            Exit Ikie
+
+${c.primary.bold('Shortcuts')}
+
+  ${c.accent('!')}${c.muted('<command>')}       Run shell command directly
+  ${c.accent('Ctrl+V')}           Paste image from clipboard
+  ${c.accent('Tab')}              Complete commands
+  ${c.accent('Esc')}              Cancel current operation
+  ${c.accent('Ctrl+C')}           Cancel or quit on second press
+  ${c.accent('Ctrl+D')}           Exit
+`);
+}
+async function handleSlashCommand(input, agent, config, projectContext, rl, sessionState, imageState) {
+    const [cmd, ...args] = input.slice(1).trim().split(/\s+/);
+    if (!cmd)
+        return true;
+    switch (cmd.toLowerCase()) {
+        case 'help':
+        case '?':
+            printHelp();
+            return true;
+        case 'clear':
+            agent.clearConversation();
+            console.log(infoLine('Conversation cleared.'));
+            return true;
+        case 'memory': {
+            const sub = args[0];
+            if (sub === 'save') {
+                process.stdout.write(c.primary('  Note: '));
+                const note = await promptLine('');
+                if (note.trim()) {
+                    const scope = args[1] === 'global' ? 'global' : 'project';
+                    if (scope === 'global') {
+                        const { appendGlobalMemory } = await import('./memory.js');
+                        appendGlobalMemory(note);
+                    }
+                    else {
+                        const { appendProjectMemory } = await import('./memory.js');
+                        appendProjectMemory(note);
+                    }
+                    console.log(successLine(`Saved to ${scope} memory.`));
+                }
+            }
+            else {
+                const mem = loadAllMemory();
+                if (mem.global || mem.project) {
+                    if (mem.global) {
+                        console.log(`\n${c.primary.bold('Global Memory')} ${c.muted('(~/.ikie/memory.md)')}`);
+                        console.log(renderMarkdown(mem.global));
+                    }
+                    if (mem.project) {
+                        console.log(`\n${c.primary.bold('Project Memory')} ${c.muted('(.ikie/memory.md)')}`);
+                        console.log(renderMarkdown(mem.project));
+                    }
+                }
+                else {
+                    console.log(infoLine('No memory saved yet. Use /memory save to add a note.'));
+                }
+            }
+            return true;
+        }
+        case 'image': {
+            const subOrPath = args.join(' ').trim();
+            if (!subOrPath || subOrPath === 'list') {
+                if (!imageState.pending.length) {
+                    console.log(infoLine('No images queued. Use /image <path>.'));
+                    return true;
+                }
+                console.log(`\n${c.primary.bold('Queued Images')}`);
+                for (const image of imageState.pending) {
+                    console.log(`  ${c.secondary(`[Image #${image.id}]`)} ${c.white(image.name)} ${c.muted(formatBytes(image.bytes))}`);
+                    console.log(`    ${c.dim(image.path)}`);
+                }
+                return true;
+            }
+            if (subOrPath === 'clear') {
+                const count = imageState.pending.length;
+                imageState.pending = [];
+                console.log(successLine(`Cleared ${count} queued image${count === 1 ? '' : 's'}.`));
+                return true;
+            }
+            if (subOrPath === 'paste' || subOrPath === 'clipboard') {
+                try {
+                    const image = loadClipboardImageAttachment(imageState.nextId++);
+                    imageState.pending.push(image);
+                    console.log(successLine(`Queued [Image #${image.id}] clipboard image (${formatBytes(image.bytes)}). Add text, then press Enter to send.`));
+                }
+                catch (err) {
+                    console.log(errorLine(err instanceof Error ? err.message : String(err)));
+                }
+                return true;
+            }
+            try {
+                const image = loadImageAttachment(subOrPath, imageState.nextId++);
+                imageState.pending.push(image);
+                console.log(successLine(`Queued [Image #${image.id}] ${image.name} (${formatBytes(image.bytes)}). Add text, then press Enter to send.`));
+            }
+            catch (err) {
+                console.log(errorLine(err instanceof Error ? err.message : String(err)));
+            }
+            return true;
+        }
+        case 'session': {
+            const sub = (args[0] ?? 'list').toLowerCase();
+            const nameArg = args.slice(1).join(' ').trim();
+            if (sub === 'list' || sub === 'ls') {
+                const sessions = listSessions();
+                if (!sessions.length) {
+                    console.log(infoLine('No saved sessions yet. Use /session save <name>.'));
+                    return true;
+                }
+                console.log(`\n${c.primary.bold('Sessions')}`);
+                for (const s of sessions.slice(0, 30)) {
+                    const active = s.name === sessionState.activeName ? c.success('*') : ' ';
+                    const when = new Date(s.updatedAt).toLocaleString();
+                    const model = s.model ? ` ${c.muted(s.model.split('/').pop() ?? s.model)}` : '';
+                    console.log(`  ${active} ${c.secondary(s.name.padEnd(24))} ${c.muted(String(s.messageCount).padStart(3) + ' msgs')} ${c.dim(when)}${model}`);
+                }
+                return true;
+            }
+            if (sub === 'save') {
+                const name = normalizeSessionName(nameArg || sessionState.activeName);
+                const saved = saveSession(name, config.model, agent.getConversation());
+                sessionState.activeName = saved.name;
+                console.log(successLine(`Session saved as "${saved.name}".`));
+                return true;
+            }
+            if (sub === 'load') {
+                if (!nameArg) {
+                    console.log(errorLine('Usage: /session load <name>'));
+                    return true;
+                }
+                try {
+                    const session = loadSession(nameArg);
+                    agent.setConversation(session.messages);
+                    sessionState.activeName = session.name;
+                    if (session.model)
+                        config.model = session.model;
+                    console.log(successLine(`Loaded session "${session.name}" (${session.messages.length} messages).`));
+                }
+                catch (err) {
+                    console.log(errorLine(err instanceof Error ? err.message : String(err)));
+                }
+                return true;
+            }
+            if (sub === 'new') {
+                agent.clearConversation();
+                sessionState.activeName = nameArg ? normalizeSessionName(nameArg) : undefined;
+                console.log(successLine(sessionState.activeName ? `Started new session "${sessionState.activeName}".` : 'Started a fresh session.'));
+                return true;
+            }
+            if (sub === 'delete' || sub === 'rm') {
+                if (!nameArg) {
+                    console.log(errorLine('Usage: /session delete <name>'));
+                    return true;
+                }
+                try {
+                    const name = normalizeSessionName(nameArg);
+                    deleteSession(name);
+                    if (sessionState.activeName === name)
+                        sessionState.activeName = undefined;
+                    console.log(successLine(`Deleted session "${name}".`));
+                }
+                catch (err) {
+                    console.log(errorLine(err instanceof Error ? err.message : String(err)));
+                }
+                return true;
+            }
+            console.log(errorLine('Usage: /session list|save [name]|load <name>|new [name]|delete <name>'));
+            return true;
+        }
+        case 'context':
+            console.log(`\n${c.primary.bold('Project Context')}\n`);
+            console.log(renderMarkdown(projectContext));
+            return true;
+        case 'models': {
+            const sub = args[0]?.toLowerCase();
+            if (sub === 'refresh' || !sub || sub === 'list') {
+                await fetchAndDisplayModels(config);
+            }
+            return true;
+        }
+        case 'model': {
+            const model = args[0];
+            if (!model) {
+                await selectModelInteractively(rl, config);
+            }
+            else {
+                config.model = model;
+                saveConfig({ model });
+                console.log(successLine(`Default model set to: ${model}`));
+                console.log(infoLine('Persisted to settings — will be used for all new sessions.'));
+            }
+            return true;
+        }
+        case 'settings': {
+            const sub = (args[0] ?? 'show').toLowerCase();
+            const value = args.slice(1).join(' ').trim();
+            if (sub === 'show' || sub === 'list') {
+                console.log(`\n${c.primary.bold('Current Settings')}\n`);
+                console.log(`  ${c.secondary('Model:')}             ${c.white(config.model)}`);
+                console.log(`  ${c.secondary('Max Tokens:')}       ${c.white(config.maxTokens.toLocaleString())}`);
+                console.log(`  ${c.secondary('Temperature:')}      ${c.white(config.temperature)}`);
+                console.log(`  ${c.secondary('Top P:')}            ${c.white(config.topP)}`);
+                console.log(`  ${c.secondary('Top K:')}            ${c.white(config.topK)}`);
+                console.log(`  ${c.secondary('Auto Approve:')}     ${c.white(config.autoApprove ? 'Yes' : 'No')}`);
+                console.log(`  ${c.secondary('Requests/min:')}     ${c.white(config.requestsPerMinute)}`);
+                console.log(`  ${c.secondary('Theme:')}            ${c.white(config.theme)}`);
+                console.log(`  ${c.secondary('Base URL:')}         ${c.white(config.baseURL ?? FIREWORKS_BASE_URL)}`);
+                console.log(`\n  ${c.muted('Use')} ${c.warning('/settings <option> <value>')} ${c.muted('to change settings')}`);
+                console.log(`  ${c.muted('Options:')} model, temperature, max-tokens, top-p, top-k, auto-approve, rpm, theme`);
+                return true;
+            }
+            if (sub === 'model') {
+                if (!value) {
+                    console.log(errorLine('Usage: /settings model <model-name>'));
+                    console.log(`\n${c.muted('  Examples:')}`);
+                    console.log(`    ${c.accent('accounts/fireworks/models/kimi-k2p7-code')}`);
+                    console.log(`    ${c.accent('accounts/fireworks/models/llama-v3p3-70b-instruct')}`);
+                    console.log(`\n  ${c.muted('Current:')} ${c.white(config.model)}`);
+                    console.log(`  ${c.muted('Default:')} ${c.dim(DEFAULT_MODEL)}`);
+                    return true;
+                }
+                config.model = value;
+                saveConfig({ model: value });
+                console.log(successLine(`Default model changed to: ${value}`));
+                return true;
+            }
+            if (sub === 'temperature') {
+                const temp = parseFloat(value);
+                if (isNaN(temp) || temp < 0 || temp > 2) {
+                    console.log(errorLine('Temperature must be a number between 0 and 2'));
+                    return true;
+                }
+                config.temperature = temp;
+                saveConfig({ temperature: temp });
+                console.log(successLine(`Temperature set to ${temp}`));
+                return true;
+            }
+            if (sub === 'max-tokens') {
+                const tokens = parseInt(value, 10);
+                if (isNaN(tokens) || tokens < 1) {
+                    console.log(errorLine('Max tokens must be a positive number'));
+                    return true;
+                }
+                config.maxTokens = tokens;
+                saveConfig({ maxTokens: tokens });
+                console.log(successLine(`Max tokens set to ${tokens.toLocaleString()}`));
+                return true;
+            }
+            if (sub === 'top-p') {
+                const topP = parseFloat(value);
+                if (isNaN(topP) || topP < 0 || topP > 1) {
+                    console.log(errorLine('Top P must be a number between 0 and 1'));
+                    return true;
+                }
+                config.topP = topP;
+                saveConfig({ topP });
+                console.log(successLine(`Top P set to ${topP}`));
+                return true;
+            }
+            if (sub === 'top-k') {
+                const topK = parseInt(value, 10);
+                if (isNaN(topK) || topK < 1) {
+                    console.log(errorLine('Top K must be a positive number'));
+                    return true;
+                }
+                config.topK = topK;
+                saveConfig({ topK });
+                console.log(successLine(`Top K set to ${topK}`));
+                return true;
+            }
+            if (sub === 'auto-approve') {
+                const on = value === 'true' || value === 'on' || value === 'yes' || value === '1';
+                config.autoApprove = on;
+                saveConfig({ autoApprove: on });
+                console.log(successLine(`Auto approve ${on ? 'enabled' : 'disabled'}`));
+                return true;
+            }
+            if (sub === 'rpm') {
+                const rpm = parseInt(value, 10);
+                if (isNaN(rpm) || rpm < 1) {
+                    console.log(errorLine('RPM must be a positive number'));
+                    return true;
+                }
+                config.requestsPerMinute = rpm;
+                saveConfig({ requestsPerMinute: rpm });
+                console.log(successLine(`Request limit set to ${rpm} rpm`));
+                return true;
+            }
+            if (sub === 'theme') {
+                if (!value) {
+                    await selectThemeInteractively(rl, config);
+                }
+                else if (setTheme(value)) {
+                    config.theme = value;
+                    saveConfig({ theme: value });
+                    drawBanner(config.model);
+                    console.log(successLine(`Theme switched to "${value}".`));
+                }
+                else {
+                    console.log(errorLine(`Unknown theme "${value}". Available: ${Object.keys(THEMES).join(', ')}`));
+                }
+                return true;
+            }
+            if (sub === 'reset') {
+                config.model = DEFAULT_MODEL;
+                config.maxTokens = 32768;
+                config.temperature = 0.6;
+                config.topP = 0.95;
+                config.topK = 40;
+                config.autoApprove = false;
+                config.requestsPerMinute = 10;
+                config.theme = 'nebula';
+                saveConfig({
+                    model: DEFAULT_MODEL,
+                    maxTokens: 32768,
+                    temperature: 0.6,
+                    topP: 0.95,
+                    topK: 40,
+                    autoApprove: false,
+                    requestsPerMinute: 10,
+                    theme: 'nebula',
+                });
+                drawBanner(config.model);
+                console.log(successLine('Settings reset to defaults'));
+                return true;
+            }
+            console.log(errorLine('Usage: /settings [show|model|temperature|max-tokens|top-p|top-k|auto-approve|rpm|theme|reset]'));
+            return true;
+        }
+        case 'theme': {
+            const themeName = args[0]?.toLowerCase();
+            if (!themeName) {
+                await selectThemeInteractively(rl, config);
+            }
+            else if (setTheme(themeName)) {
+                config.theme = themeName;
+                drawBanner(config.model);
+                console.log(successLine(`Theme switched to "${themeName}".`));
+            }
+            else {
+                console.log(errorLine(`Unknown theme "${themeName}". Available themes: ${Object.keys(THEMES).join(', ')}`));
+            }
+            return true;
+        }
+        case 'rpm': {
+            const value = args[0];
+            if (!value) {
+                console.log(infoLine(`Request limit: ${config.requestsPerMinute} rpm`));
+                return true;
+            }
+            const rpm = Number(value);
+            if (!Number.isFinite(rpm) || rpm < 1) {
+                console.log(errorLine('Usage: /rpm <number greater than 0>'));
+                return true;
+            }
+            config.requestsPerMinute = Math.floor(rpm);
+            console.log(successLine(`Request limit set to ${config.requestsPerMinute} rpm.`));
+            return true;
+        }
+        case 'tokens': {
+            const msgs = agent.getConversation();
+            const approxTokens = JSON.stringify(msgs).length / 4;
+            console.log(infoLine(`~${Math.round(approxTokens).toLocaleString()} tokens in conversation`));
+            return true;
+        }
+        case 'exit':
+        case 'quit':
+        case 'q':
+            printGoodbye(sessionState, agent, config);
+            process.exit(0);
+        default:
+            console.log(errorLine(`Unknown command: /${cmd}. Type /help for help.`));
+            return true;
+    }
+}
+function promptLine(prompt) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(prompt, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+function printGoodbye(sessionState, agent, config) {
+    const msgs = agent.getConversation();
+    const hasConversation = msgs.length > 0;
+    // Auto-save if there's an active session and we have config
+    if (sessionState.activeName && hasConversation && config) {
+        try {
+            saveSession(sessionState.activeName, config.model, msgs);
+        }
+        catch (err) {
+            // Silently fail if save doesn't work
+        }
+    }
+    console.log(`\n${c.primary.bold('Goodbye!')}\n`);
+    if (sessionState.activeName) {
+        console.log(`  ${c.muted('Your session')} ${c.secondary.bold(sessionState.activeName)} ${c.muted('has been saved.')}`);
+        console.log(`\n  ${c.muted('To continue:')}`);
+        console.log(`    ${c.accent('ikie')} ${c.warning(`/session load ${sessionState.activeName}`)}\n`);
+    }
+    else if (hasConversation) {
+        console.log(`  ${c.warning('\u26A0')}  ${c.muted('Your current conversation was not saved.')}`);
+        console.log(`\n  ${c.muted('To save next time:')}`);
+        console.log(`    ${c.warning('/session save')} ${c.muted('<name>')}\n`);
+    }
+    console.log(`  ${c.muted('Happy coding!')}\n`);
+}
+function formatElapsed(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const seconds = ms / 1000;
+    if (seconds < 60)
+        return `${seconds.toFixed(1)}s`;
+    const minutes = Math.floor(seconds / 60);
+    const rest = Math.floor(seconds % 60).toString().padStart(2, '0');
+    return `${minutes}:${rest}`;
+}
+function printRightStatus(message) {
+    const cols = process.stdout.columns ?? 80;
+    const width = stripAnsi(message).length;
+    process.stdout.write(`${' '.repeat(Math.max(0, cols - width - 1))}${message}\n`);
+}
+function formatTaskTimeline(agent, elapsed, state) {
+    const stats = agent.getLastTurnStats();
+    const modelLabel = `${stats.modelCalls} model`;
+    const toolLabel = `${stats.toolCalls} tools`;
+    const filesLabel = stats.filesChanged > 0 ? ` · ${stats.filesChanged} files` : '';
+    const tail = state === 'cancelled' ? `cancelled after ${elapsed}` : `${state} in ${elapsed}`;
+    return `${modelLabel} · ${toolLabel}${filesLabel} · ${tail}`;
+}
+function selectModelInteractively(rl, config) {
+    return new Promise((resolve) => {
+        const models = [];
+        const prompt = () => {
+            rl.question(c.muted('Enter number (or 0 to cancel): '), (answer) => {
+                const num = parseInt(answer, 10);
+                if (isNaN(num) || num < 0 || num > models.length) {
+                    prompt();
+                    return;
+                }
+                if (num === 0) {
+                    console.log(infoLine('Model selection cancelled.'));
+                    resolve();
+                    return;
+                }
+                const chosen = models[num - 1];
+                config.model = chosen.provider_model_id;
+                console.log(successLine(`Switched to ${chosen.name} — ${chosen.display_name}`));
+                resolve();
+            });
+        };
+        console.log(`\n  ${c.accent.bold('Select a Model')}`);
+        fetchModelsFromServer(config).then((fetched) => {
+            models.push(...fetched);
+            if (models.length === 0) {
+                console.log(`  ${c.error('No models available.')}`);
+                resolve();
+                return;
+            }
+            models.forEach((m, i) => {
+                const num = c.primary((i + 1).toString().padStart(2));
+                const def = m.is_default ? ` ${c.success('[DEFAULT]')}` : '';
+                console.log(`  ${num}) ${c.bold(m.name.padEnd(24))} ${c.dim(m.display_name)} ${c.muted(`(${(m.context_window / 1024).toFixed(0)}K)`)}${def}`);
+            });
+            console.log(`  ${c.muted(' 0)')} Cancel`);
+            prompt();
+        }).catch(() => {
+            console.log(`  ${c.error('Failed to load models.')}`);
+            resolve();
+        });
+    });
+}
+function selectThemeInteractively(rl, config) {
+    return new Promise((resolve) => {
+        const themesList = Object.keys(THEMES);
+        const currentIndex = themesList.indexOf(config.theme);
+        let lastIndex = currentIndex === -1 ? 0 : currentIndex;
+        const prompt = () => {
+            rl.question(c.muted('Enter number (or 0 to cancel): '), (answer) => {
+                const num = parseInt(answer, 10);
+                if (isNaN(num) || num < 0 || num > themesList.length) {
+                    prompt();
+                    return;
+                }
+                if (num === 0) {
+                    console.log(infoLine('Theme selection cancelled.'));
+                    resolve();
+                    return;
+                }
+                const chosen = themesList[num - 1];
+                setTheme(chosen);
+                config.theme = chosen;
+                drawBanner(config.model);
+                console.log(successLine(`Theme switched to "${chosen}".`));
+                resolve();
+            });
+        };
+        console.log(`\n  ${c.accent.bold('Select a Theme')}`);
+        themesList.forEach((name, i) => {
+            const theme = THEMES[name];
+            const num = c.primary((i + 1).toString().padStart(2));
+            const active = i === currentIndex ? ` ${c.success('[ACTIVE]')}` : '';
+            console.log(`  ${num}) ${c.bold(name.padEnd(12))} ${c.muted('-')} ${c.dim(theme.description)}${active}`);
+        });
+        console.log(`  ${c.muted(' 0)')} Cancel`);
+        prompt();
+    });
+}
+export async function startREPL(agent, config, projectContext, oneShot) {
+    void HISTORY_FILE;
+    if (oneShot) {
+        try {
+            await agent.send(oneShot, { autoApprove: config.autoApprove });
+        }
+        catch (err) {
+            console.error(errorLine(`Agent error: ${err}`));
+            process.exit(1);
+        }
+        return;
+    }
+    drawBanner(config.model);
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: true,
+        historySize: MAX_HISTORY,
+        prompt: PROMPT,
+        completer: slashCompleter,
+    });
+    let multilineBuffer = '';
+    let busy = false;
+    let ctrlCCount = 0;
+    const sessionState = {};
+    const imageState = { nextId: 1, pending: [] };
+    let pasteSeq = 0;
+    let pasteMode = false;
+    let pasteBuffer = '';
+    const pastedBlocks = new Map();
+    const readlineDataListeners = process.stdin.rawListeners('data').slice();
+    for (const fn of readlineDataListeners) {
+        process.stdin.removeListener('data', fn);
+    }
+    const forwardToReadline = (data) => {
+        for (const fn of readlineDataListeners) {
+            fn.call(process.stdin, data);
+        }
+    };
+    const pasteSummary = (content) => {
+        const normalized = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        const lines = normalized ? normalized.split('\n').length : 0;
+        if (lines > 1)
+            return `~${lines} lines`;
+        return `${normalized.length} chars`;
+    };
+    const insertPasteBlock = (content) => {
+        const normalized = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        if (!normalized)
+            return;
+        const token = `[Pasted #${++pasteSeq}: ${pasteSummary(normalized)}]`;
+        pastedBlocks.set(token, normalized);
+        rl.write(token);
+    };
+    const routeInputData = (data) => {
+        const text = data.toString('utf8');
+        // Check for Ctrl+V (0x16) - try to paste image from clipboard
+        if (data.length === 1 && data[0] === 0x16) {
+            // Check if clipboard has an image
+            if (hasClipboardImage()) {
+                try {
+                    const image = loadClipboardImageAttachment(imageState.nextId++);
+                    imageState.pending.push(image);
+                    // Show feedback
+                    process.stdout.write(`\r\x1b[2K${rl.getPrompt()}`);
+                    const line = rl.line || '';
+                    process.stdout.write(line);
+                    process.stdout.write(`\n  ${c.success('✓')} ${c.muted('Image pasted from clipboard')} ${c.secondary(`[Image #${image.id}]`)} ${c.dim(image.name)} ${c.muted(formatBytes(image.bytes))}\n`);
+                    process.stdout.write(rl.getPrompt() + line);
+                    return;
+                }
+                catch (err) {
+                    // Silently fall through to normal paste if clipboard image load fails
+                    // This allows Ctrl+V to still work for text paste
+                }
+            }
+            // If no image in clipboard, forward Ctrl+V to readline for text paste
+            forwardToReadline(data);
+            return;
+        }
+        if (!pasteMode && !text.includes('\x1b[200~') && /[\r\n]/.test(text.trim()) && text.length > 3) {
+            insertPasteBlock(text);
+            return;
+        }
+        let rest = text;
+        while (rest) {
+            if (pasteMode) {
+                const end = rest.indexOf('\x1b[201~');
+                if (end === -1) {
+                    pasteBuffer += rest;
+                    return;
+                }
+                pasteBuffer += rest.slice(0, end);
+                insertPasteBlock(pasteBuffer);
+                pasteBuffer = '';
+                pasteMode = false;
+                rest = rest.slice(end + '\x1b[201~'.length);
+                continue;
+            }
+            const start = rest.indexOf('\x1b[200~');
+            if (start === -1) {
+                forwardToReadline(Buffer.from(rest, 'utf8'));
+                return;
+            }
+            if (start > 0) {
+                forwardToReadline(Buffer.from(rest.slice(0, start), 'utf8'));
+            }
+            pasteMode = true;
+            rest = rest.slice(start + '\x1b[200~'.length);
+        }
+    };
+    process.stdin.on('data', routeInputData);
+    const expandPastedBlocks = (input) => {
+        let expanded = input;
+        const used = [];
+        for (const [token, content] of pastedBlocks) {
+            if (!expanded.includes(token))
+                continue;
+            used.push(token);
+            expanded = expanded.split(token).join(`[pasted content ${token}]`);
+        }
+        if (!used.length)
+            return input;
+        const attachments = used.map((token, i) => {
+            const content = pastedBlocks.get(token) ?? '';
+            return `Pasted content ${i + 1} (${token}):\n${content}`;
+        });
+        for (const token of used)
+            pastedBlocks.delete(token);
+        return `${expanded}\n\n${attachments.join('\n\n')}`;
+    };
+    const showPrompt = () => {
+        if (multilineBuffer) {
+            rl.setPrompt(CONTINUE_PROMPT);
+        }
+        else {
+            printPromptHeader();
+            if (imageState.pending.length) {
+                const labels = imageState.pending.map(image => `[Image #${image.id}]`).join(' ');
+                process.stdout.write(`${c.muted('   attached')} ${c.secondary(labels)}\n`);
+            }
+            rl.setPrompt(PROMPT);
+        }
+        rl.prompt();
+    };
+    rl.on('close', () => {
+        printGoodbye(sessionState, agent, config);
+        process.exit(0);
+    });
+    rl.on('SIGINT', () => {
+        if (busy)
+            return;
+        ctrlCCount++;
+        if (ctrlCCount >= 2) {
+            rl.close();
+            return;
+        }
+        multilineBuffer = '';
+        process.stdout.write(`\n${c.muted('  (press Ctrl+C again or type /exit to quit)')}\n`);
+        setTimeout(() => { ctrlCCount = 0; }, 2000);
+        showPrompt();
+    });
+    const handleLine = async (raw) => {
+        const line = raw.trim();
+        if (!line) {
+            showPrompt();
+            return;
+        }
+        if (line.endsWith('\\')) {
+            multilineBuffer += (multilineBuffer ? '\n' : '') + line.slice(0, -1);
+            showPrompt();
+            return;
+        }
+        const fullInput = multilineBuffer ? multilineBuffer + '\n' + line : line;
+        multilineBuffer = '';
+        if (fullInput.startsWith('!')) {
+            const cmd = fullInput.slice(1).trim();
+            if (cmd) {
+                try {
+                    process.stdout.write(execSync(cmd, { encoding: 'utf-8' }));
+                }
+                catch (err) {
+                    const e = err;
+                    if (e.stdout)
+                        process.stdout.write(e.stdout);
+                    if (e.stderr)
+                        process.stdout.write(e.stderr);
+                    else
+                        console.error(errorLine(e.message ?? 'Command failed'));
+                }
+                process.stdout.write('\n');
+            }
+            showPrompt();
+            return;
+        }
+        if (fullInput.startsWith('/')) {
+            await handleSlashCommand(fullInput, agent, config, projectContext, rl, sessionState, imageState);
+            process.stdout.write('\n');
+            showPrompt();
+            return;
+        }
+        const agentInput = expandPastedBlocks(fullInput);
+        const imagesForTurn = [...imageState.pending];
+        const userContent = buildUserContent(agentInput, imagesForTurn);
+        imageState.pending = [];
+        let restoredImages = false;
+        process.stdout.write('\r\x1b[2K');
+        process.stdout.write(`${c.muted('  Working. Press Esc to interrupt.')}\n`);
+        busy = true;
+        rl.pause();
+        const taskStartedAt = Date.now();
+        let taskFailed = false;
+        const abortController = new AbortController();
+        const savedDataListeners = process.stdin.rawListeners('data').slice();
+        const savedKeypressListeners = process.stdin.rawListeners('keypress').slice();
+        process.stdin.removeAllListeners('data');
+        process.stdin.removeAllListeners('keypress');
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(true);
+        process.stdin.resume();
+        const cancelHandler = (data) => {
+            const b = data[0];
+            if (b === 0x1b && data.length === 1) {
+                if (!abortController.signal.aborted) {
+                    abortController.abort();
+                    process.stdout.write(`\n${c.warning('  Cancelled')}\n`);
+                }
+            }
+            else if (b === 0x03) {
+                ctrlCCount++;
+                if (ctrlCCount >= 2)
+                    process.exit(0);
+                if (!abortController.signal.aborted) {
+                    abortController.abort();
+                    process.stdout.write(`\n${c.warning('  Cancelled')}\n`);
+                }
+                setTimeout(() => { ctrlCCount = 0; }, 2000);
+            }
+        };
+        process.stdin.on('data', cancelHandler);
+        try {
+            await agent.send(userContent, {
+                autoApprove: config.autoApprove,
+                signal: abortController.signal,
+                startedAt: taskStartedAt,
+            });
+            if (sessionState.activeName && !abortController.signal.aborted) {
+                saveSession(sessionState.activeName, config.model, agent.getConversation());
+            }
+        }
+        catch (err) {
+            if (!abortController.signal.aborted) {
+                taskFailed = true;
+                if (imagesForTurn.length) {
+                    imageState.pending = [...imagesForTurn, ...imageState.pending];
+                    restoredImages = true;
+                }
+                const e = err;
+                console.error(`\n${errorLine(`Error: ${e.message ?? String(err)}`)}`);
+            }
+        }
+        finally {
+            if (abortController.signal.aborted && imagesForTurn.length && !restoredImages) {
+                imageState.pending = [...imagesForTurn, ...imageState.pending];
+            }
+            const elapsed = formatElapsed(Date.now() - taskStartedAt);
+            process.stdin.removeListener('data', cancelHandler);
+            if (process.stdin.isTTY)
+                process.stdin.setRawMode(false);
+            process.stdin.pause();
+            restoreStdinListeners(savedDataListeners, savedKeypressListeners);
+            busy = false;
+            ctrlCCount = 0;
+            rl.resume();
+            const status = abortController.signal.aborted
+                ? c.warning(formatTaskTimeline(agent, elapsed, 'cancelled'))
+                : taskFailed
+                    ? c.error(formatTaskTimeline(agent, elapsed, 'failed'))
+                    : c.muted(formatTaskTimeline(agent, elapsed, 'done'));
+            printRightStatus(status);
+            showPrompt();
+        }
+    };
+    let chain = Promise.resolve();
+    rl.on('line', (raw) => {
+        chain = chain.then(() => handleLine(raw));
+    });
+    showPrompt();
+}