@compilr-dev/cli 0.4.0 → 0.5.0

package/dist/repl-v2.js

@@ -0,0 +1,774 @@
+/**
+ * REPL V2 - New Terminal UI based REPL
+ *
+ * Uses TerminalUI with:
+ * - Persistent footer (todo list + input prompt)
+ * - Overlay system for commands
+ * - Real agent integration (or simulation mode for testing)
+ *
+ * Can be run standalone: npx tsx src/repl-v2.ts
+ * Or imported and used with a real agent from index.ts
+ */
+import { TerminalUI } from './ui/terminal-ui.js';
+import * as terminal from './ui/terminal.js';
+import { getStyles } from './themes/index.js';
+import { getSettings, getStartupMode } from './settings/index.js';
+import { renderMascotWithLogo } from './ui/mascot/renderer.js';
+import { registerCommands, executeCommand, allCommands, } from './commands-v2/index.js';
+import { getCustomCommandRegistry } from './commands/custom-registry.js';
+import { PermissionOverlayV2, } from './ui/overlay/impl/permission-overlay-v2.js';
+import { AskUserSimpleOverlayV2, } from './ui/overlay/impl/ask-user-simple-overlay-v2.js';
+import { GuardrailOverlayV2, } from './ui/overlay/impl/guardrail-overlay-v2.js';
+import { AskUserOverlayV2, } from './ui/overlay/impl/ask-user-overlay-v2.js';
+import { IterationLimitOverlayV2, } from './ui/overlay/impl/iteration-limit-overlay-v2.js';
+import { formatToolResult } from './ui/tool-formatters.js';
+import { isMemoryInput } from './input-handlers/index.js';
+import { addAnchor } from './anchors/index.js';
+import { getActiveProject } from './tools/project-db.js';
+// Version for display (when running standalone)
+const STANDALONE_VERSION = '0.4.0-v2';
+// Register all commands on module load
+registerCommands(allCommands);
+// =============================================================================
+// REPL V2 Class
+// =============================================================================
+export class ReplV2 {
+    agent;
+    model;
+    provider;
+    version;
+    projectName;
+    currentSession = null;
+    ui;
+    onUIReady;
+    onTextBufferReady;
+    onAskUserSimpleReady;
+    onGuardrailReady;
+    onAskUserReady;
+    onIterationLimitReady;
+    onAgentFinish;
+    onSuggestionReady;
+    onSubagentReady;
+    clearSubagentTracking;
+    // Session stats
+    startTime = new Date();
+    sessionInputTokens = 0;
+    sessionOutputTokens = 0;
+    sessionRequests = 0;
+    // Text accumulator for agent output (class-level so it can be flushed externally)
+    textAccumulator = '';
+    // Note: Subagent tracking is now simplified - callbacks receive toolUseId directly
+    // from agent.ts, so no more FIFO queue correlation needed!
+    constructor(options = {}) {
+        this.agent = options.agent;
+        this.model = options.model ?? 'simulation';
+        this.provider = options.provider ?? 'simulation';
+        this.version = options.version ?? STANDALONE_VERSION;
+        this.projectName = options.projectName ?? process.cwd().split('/').pop() ?? 'Project';
+        this.onUIReady = options.onUIReady;
+        this.onTextBufferReady = options.onTextBufferReady;
+        this.onAskUserSimpleReady = options.onAskUserSimpleReady;
+        this.onGuardrailReady = options.onGuardrailReady;
+        this.onAskUserReady = options.onAskUserReady;
+        this.onIterationLimitReady = options.onIterationLimitReady;
+        this.onAgentFinish = options.onAgentFinish;
+        this.onSuggestionReady = options.onSuggestionReady;
+        this.onSubagentReady = options.onSubagentReady;
+        this.clearSubagentTracking = options.clearSubagentTracking;
+    }
+    /**
+     * Flush accumulated agent text to the UI.
+     * Called externally (e.g., before showing permission overlay) to ensure
+     * agent's "I'll do X" message appears before the overlay.
+     */
+    flushTextBuffer() {
+        if (this.textAccumulator.trim()) {
+            this.ui.print({ type: 'agent-text', text: this.textAccumulator.trim() });
+            this.textAccumulator = '';
+        }
+    }
+    /**
+     * Start the REPL.
+     */
+    start() {
+        // Create TerminalUI
+        this.ui = new TerminalUI({
+            initialMode: 'normal',
+        });
+        // Print welcome screen
+        this.printWelcome();
+        // Set initial state
+        this.ui.setProjectName(this.projectName);
+        // Notify caller that UI is ready and provide the V2 permission overlay function
+        if (this.onUIReady) {
+            const ui = this.ui;
+            this.onUIReady(async (options) => {
+                const overlay = new PermissionOverlayV2(options);
+                return ui.showOverlay(overlay);
+            });
+        }
+        // Provide the text buffer flush function to the caller
+        if (this.onTextBufferReady) {
+            this.onTextBufferReady(() => {
+                this.flushTextBuffer();
+            });
+        }
+        // Provide the ask_user_simple overlay function to the caller
+        if (this.onAskUserSimpleReady) {
+            const ui = this.ui;
+            this.onAskUserSimpleReady(async (options) => {
+                const overlay = new AskUserSimpleOverlayV2(options);
+                const result = await ui.showOverlay(overlay);
+                return result ?? { answer: '', skipped: true };
+            });
+        }
+        // Provide the guardrail overlay function to the caller
+        if (this.onGuardrailReady) {
+            const ui = this.ui;
+            this.onGuardrailReady(async (options) => {
+                const overlay = new GuardrailOverlayV2(options);
+                const result = await ui.showOverlay(overlay);
+                return result ?? { approved: false };
+            });
+        }
+        // Provide the ask_user overlay function to the caller
+        if (this.onAskUserReady) {
+            const ui = this.ui;
+            this.onAskUserReady(async (options) => {
+                const overlay = new AskUserOverlayV2(options);
+                const result = await ui.showOverlay(overlay);
+                return result ?? { answers: {}, skipped: options.questions.map((q) => q.id) };
+            });
+        }
+        // Provide the iteration_limit overlay function to the caller
+        if (this.onIterationLimitReady) {
+            const ui = this.ui;
+            this.onIterationLimitReady(async (options) => {
+                const overlay = new IterationLimitOverlayV2(options);
+                const result = await ui.showOverlay(overlay);
+                return result ?? { continue: false };
+            });
+        }
+        // Provide the suggestion setter function to the caller
+        if (this.onSuggestionReady) {
+            const ui = this.ui;
+            this.onSuggestionReady((action) => {
+                ui.setSuggestion(action);
+            });
+        }
+        // Provide subagent tracking callbacks to the caller for LiveRegion rendering
+        // Now using toolUseId directly - no more FIFO queue correlation needed!
+        if (this.onSubagentReady) {
+            const ui = this.ui;
+            this.onSubagentReady({
+                onStart: (toolUseId, _agentType, _description) => {
+                    // The subagent entry was already added in tool_start with toolUseId
+                    // Just mark it as "started" (no-op for now, already rendering)
+                    void toolUseId; // Used for correlation, entry already exists
+                },
+                onToolUse: (toolUseId, toolName, summary) => {
+                    // Direct update using toolUseId - no mapping needed!
+                    ui.updateSubagentTool(toolUseId, toolName, summary ?? '');
+                },
+                onEnd: (toolUseId, _success, tokenCount, _error) => {
+                    // DON'T mark as complete here! That changes the line count in LiveRegion,
+                    // and if render loop fires before tool_end, lastRenderHeight becomes wrong.
+                    // Just store the info for tool_end to use when committing.
+                    const item = ui.getLiveRegion().getItem(toolUseId);
+                    if (item && item.type === 'subagent') {
+                        ui.getLiveRegion().updateItem(toolUseId, {
+                            tokenCount,
+                            endTime: Date.now(),
+                        });
+                    }
+                },
+            });
+        }
+        // Event handlers
+        this.ui.on('submit', (input) => {
+            void this.processInput(input);
+        });
+        this.ui.on('command', (cmd, args) => {
+            void (async () => {
+                await this.handleCommand(cmd, args);
+                await this.processQueue();
+            })();
+        });
+        this.ui.on('escape', () => {
+            // Single Esc when no agent - do nothing
+        });
+        this.ui.on('interrupt', () => {
+            if (this.currentSession) {
+                this.cancelSession();
+            }
+            else {
+                this.ui.stop();
+                console.log('\nGoodbye!\n');
+                process.exit(0);
+            }
+        });
+        this.ui.on('cancel', () => {
+            if (this.currentSession) {
+                this.cancelSession();
+            }
+        });
+        this.ui.on('modeChange', () => {
+            const modes = ['normal', 'auto-accept', 'plan'];
+            const currentIndex = modes.indexOf(this.ui.getMode());
+            const nextMode = modes[(currentIndex + 1) % modes.length];
+            this.ui.setMode(nextMode);
+            this.ui.print({ type: 'info', message: `Mode: ${nextMode}` });
+        });
+        // Start UI
+        this.ui.start();
+        // If startup mode is 'menu', immediately execute /menu command
+        const startupMode = getStartupMode();
+        if (startupMode === 'menu') {
+            void this.handleCommand('menu', '');
+        }
+    }
+    /**
+     * Stop the REPL.
+     */
+    stop() {
+        if (this.currentSession) {
+            this.currentSession.abortController.abort();
+            this.currentSession = null;
+        }
+        this.ui.stop();
+    }
+    // ===========================================================================
+    // Welcome Message
+    // ===========================================================================
+    /**
+     * Print just the logo to the scrolling area.
+     * Used for dashboard mode where hints are not needed.
+     */
+    printLogo() {
+        const settings = getSettings();
+        const s = getStyles();
+        terminal.clearScreen();
+        // Render mascot with logo (includes tagline)
+        const logoLines = renderMascotWithLogo(settings.mascot, this.version, null);
+        console.log('');
+        for (const line of logoLines) {
+            console.log(line);
+        }
+        console.log('');
+        // Show agent status
+        if (this.agent) {
+            console.log(s.success('  ✓ Agent connected'));
+        }
+        else {
+            console.log(s.warning('  ⚠ Simulation mode (no agent)'));
+        }
+        console.log('');
+        // Show model info
+        console.log(s.muted('Model: ') + s.secondary(this.model));
+        console.log(s.muted('Provider: ') + s.secondary(this.provider));
+        console.log('');
+    }
+    /**
+     * Print full welcome message for REPL mode.
+     */
+    printWelcome() {
+        const s = getStyles();
+        // Print logo with agent/model info
+        this.printLogo();
+        // Hints
+        console.log(s.muted('Type a message to start'));
+        console.log(s.muted('Type /help for commands, /exit to quit'));
+        console.log('');
+    }
+    // ===========================================================================
+    // Command Handling
+    // ===========================================================================
+    createCommandContext() {
+        return {
+            ui: this.ui,
+            version: this.version,
+            printWelcome: () => { this.printWelcome(); },
+            printLogo: () => { this.printLogo(); },
+            // Agent integration
+            agent: this.agent,
+            model: this.model,
+            provider: this.provider,
+            getContextManager: () => {
+                return this.agent?.getContextManager() ?? null;
+            },
+            getHistory: () => {
+                return this.agent?.getHistory() ?? [];
+            },
+            // Queue agent message (for commands that invoke the agent)
+            queueAgentMessage: (options) => {
+                this.ui.queueAgentMessage(options);
+            },
+            // Session stats
+            startTime: this.startTime,
+            sessionInputTokens: this.sessionInputTokens,
+            sessionOutputTokens: this.sessionOutputTokens,
+            sessionRequests: this.sessionRequests,
+        };
+    }
+    async handleCommand(cmd, args) {
+        const ctx = this.createCommandContext();
+        const result = await executeCommand(cmd, args, ctx);
+        if (result === null) {
+            // Check if it's a custom command
+            const customRegistry = getCustomCommandRegistry();
+            if (customRegistry.has(cmd)) {
+                // Expand custom command and send as message
+                const customArgs = args ? args.split(' ').filter(a => a.trim()) : [];
+                const expanded = customRegistry.expand(cmd, customArgs);
+                if (expanded) {
+                    // Show user what command is being run
+                    this.ui.print({ type: 'user-message', text: `/${cmd}${args ? ' ' + args : ''}` });
+                    // Send expanded prompt to agent
+                    if (this.agent) {
+                        await this.runAgentReal(expanded);
+                    }
+                    else {
+                        await this.runAgentSimulation(expanded);
+                    }
+                    return;
+                }
+            }
+            this.ui.print({ type: 'warning', message: `Unknown command: /${cmd}` });
+            this.ui.print({ type: 'info', message: 'Type /help to see available commands' });
+        }
+        else if (!result) {
+            // result === false means exit
+            process.exit(0);
+        }
+        // Process any queued agent messages (from commands like /arch, /design)
+        await this.processAgentMessageQueue();
+    }
+    /**
+     * Process queued agent messages.
+     * Commands can queue messages to invoke the agent programmatically.
+     */
+    async processAgentMessageQueue() {
+        while (this.ui.hasAgentMessage()) {
+            const agentMsg = this.ui.popAgentMessage();
+            if (agentMsg) {
+                // Show display message to user (or full message if no display message)
+                this.ui.print({
+                    type: 'user-message',
+                    text: agentMsg.displayMessage ?? agentMsg.message,
+                });
+                // Send full message to agent
+                if (this.agent) {
+                    await this.runAgentReal(agentMsg.message);
+                }
+                else {
+                    await this.runAgentSimulation(agentMsg.message);
+                }
+            }
+        }
+    }
+    // ===========================================================================
+    // Input Processing
+    // ===========================================================================
+    async processInput(input) {
+        if (input.startsWith('/')) {
+            const spaceIndex = input.indexOf(' ');
+            const cmd = spaceIndex > 0 ? input.slice(1, spaceIndex) : input.slice(1);
+            const args = spaceIndex > 0 ? input.slice(spaceIndex + 1) : '';
+            await this.handleCommand(cmd, args);
+            await this.processQueue();
+        }
+        else if (isMemoryInput(input)) {
+            // Handle memory note ("# note")
+            this.handleMemoryInputV2(input);
+        }
+        else {
+            // Print user message
+            this.ui.print({ type: 'user-message', text: input });
+            // Run agent (real or simulation)
+            if (this.agent) {
+                await this.runAgentReal(input);
+            }
+            else {
+                await this.runAgentSimulation(input);
+            }
+            await this.processQueue();
+        }
+    }
+    /**
+     * Handle memory note input ("# note") - V2 compatible version
+     */
+    handleMemoryInputV2(input) {
+        const note = input.slice(1).trim();
+        // Get active project to determine scope
+        const activeProject = getActiveProject();
+        const projectId = activeProject?.id;
+        // Determine priority based on keywords
+        let priority = 'info';
+        const lowerNote = note.toLowerCase();
+        if (lowerNote.includes('never') || lowerNote.includes('always') || lowerNote.includes('must')) {
+            priority = 'safety';
+        }
+        if (lowerNote.includes('critical') || lowerNote.includes('important')) {
+            priority = 'critical';
+        }
+        // Create the anchor (persisted to file)
+        const anchor = addAnchor({
+            content: note,
+            priority,
+            scope: 'persistent',
+            projectId: projectId?.toString(),
+            tags: ['user-note'],
+        });
+        // Show confirmation
+        const scope = activeProject ? `project "${activeProject.displayName || activeProject.name}"` : 'global';
+        const priorityLabel = priority === 'info' ? '' : ` (${priority})`;
+        const truncatedNote = note.length > 50 ? note.slice(0, 47) + '...' : note;
+        this.ui.print({ type: 'success', message: `Saved${priorityLabel}: "${truncatedNote}" → ${scope}` });
+        // Also add to agent's anchor manager if enabled (for current session)
+        if (this.agent?.getAnchorManager()) {
+            this.agent.addAnchor({
+                id: anchor.id,
+                content: note,
+                priority,
+                scope: 'persistent',
+                tags: ['user-note'],
+            });
+        }
+    }
+    async processQueue() {
+        while (this.ui.hasQueuedInput()) {
+            const queued = this.ui.popQueuedInput();
+            if (queued) {
+                await this.processInput(queued);
+            }
+        }
+    }
+    // ===========================================================================
+    // Real Agent Execution
+    // ===========================================================================
+    async runAgentReal(userMessage) {
+        if (!this.agent)
+            return;
+        const abortController = new AbortController();
+        const signal = abortController.signal;
+        const setAction = (action) => {
+            if (this.currentSession) {
+                this.currentSession.currentAction = action;
+            }
+        };
+        // Clear subagent tracking state from previous runs
+        // - Agent.ts tracking (activeSubagents map)
+        this.clearSubagentTracking?.();
+        // - LiveRegion entries (visual display of running tools)
+        this.ui.clearLiveRegion();
+        this.currentSession = {
+            abortController,
+            currentAction: null,
+            promise: (async () => {
+                try {
+                    this.ui.setAgentRunning(true);
+                    setAction('Thinking...');
+                    this.ui.setSpinnerText('Thinking...');
+                    // Reset text accumulator for this run (class-level so it can be flushed externally)
+                    this.textAccumulator = '';
+                    let lastToolInput = null;
+                    // Stream agent events (agent is guaranteed to exist in this method)
+                    const agent = this.agent;
+                    if (!agent)
+                        return; // Type guard
+                    for await (const event of agent.stream(userMessage, {
+                        signal,
+                        chatOptions: { model: this.model },
+                    })) {
+                        if (signal.aborted)
+                            break;
+                        if (event.type === 'llm_chunk') {
+                            if (event.chunk.type === 'text' && event.chunk.text) {
+                                this.textAccumulator += event.chunk.text;
+                            }
+                            else if (event.chunk.type === 'done' && event.chunk.usage) {
+                                this.sessionInputTokens += event.chunk.usage.inputTokens;
+                                this.sessionOutputTokens += event.chunk.usage.outputTokens;
+                                this.sessionRequests++;
+                            }
+                        }
+                        else if (event.type === 'tool_start') {
+                            // Flush accumulated text before tool
+                            if (this.textAccumulator.trim()) {
+                                this.ui.print({ type: 'agent-text', text: this.textAccumulator.trim() });
+                                this.textAccumulator = '';
+                            }
+                            lastToolInput = event.input;
+                            // For bash tool, add to live region for streaming output
+                            if (event.name === 'bash' && event.toolUseId) {
+                                const command = typeof lastToolInput.command === 'string'
+                                    ? lastToolInput.command
+                                    : '';
+                                this.ui.addBashCommand(event.toolUseId, command);
+                            }
+                            // Update spinner with tool name
+                            if (event.name !== 'todo_read' && event.name !== 'todo_write' && event.name !== 'suggest') {
+                                if (event.name === 'task' && event.toolUseId) {
+                                    const subagentType = typeof lastToolInput.subagent_type === 'string'
+                                        ? lastToolInput.subagent_type
+                                        : 'general';
+                                    const description = typeof lastToolInput.description === 'string'
+                                        ? lastToolInput.description
+                                        : '';
+                                    setAction(`task(${subagentType}): ${description}`);
+                                    this.ui.setSpinnerText(`task(${subagentType}): ${description}`);
+                                    // Add subagent to LiveRegion with toolUseId
+                                    // No queue needed - callbacks now receive toolUseId directly!
+                                    this.ui.addSubagent(event.toolUseId, subagentType, description);
+                                }
+                                else if (event.name !== 'task') {
+                                    setAction(event.name);
+                                    this.ui.setSpinnerText(`Running ${event.name}...`);
+                                }
+                            }
+                        }
+                        else if (event.type === 'tool_output') {
+                            // Stream bash output to live region
+                            if (event.toolUseId) {
+                                this.ui.updateBashOutput(event.toolUseId, event.output);
+                            }
+                        }
+                        else if (event.type === 'tool_end') {
+                            const toolName = event.name;
+                            const toolInput = lastToolInput;
+                            const result = event.result;
+                            lastToolInput = null;
+                            // Complete bash command in live region
+                            if (toolName === 'bash' && event.toolUseId) {
+                                let exitCode = result.success ? 0 : 1;
+                                if (result.success && typeof result.result === 'object' && result.result !== null) {
+                                    const res = result.result;
+                                    if (typeof res.exitCode === 'number') {
+                                        exitCode = res.exitCode;
+                                    }
+                                }
+                                this.ui.completeBashCommand(event.toolUseId, exitCode);
+                                this.ui.commitBashCommand(event.toolUseId);
+                                this.ui.setCurrentTool(null);
+                                continue;
+                            }
+                            // Handle todo_write - update UI state
+                            if (toolName === 'todo_write' && toolInput && Array.isArray(toolInput.todos)) {
+                                const todos = toolInput.todos.map((t) => {
+                                    const content = typeof t.content === 'string' ? t.content :
+                                        typeof t.title === 'string' ? t.title :
+                                            typeof t.task === 'string' ? t.task :
+                                                typeof t.description === 'string' ? t.description :
+                                                    typeof t.text === 'string' ? t.text : 'Untitled task';
+                                    const status = (typeof t.status === 'string' && ['pending', 'in_progress', 'completed'].includes(t.status)
+                                        ? t.status
+                                        : 'pending');
+                                    const activeForm = typeof t.activeForm === 'string' ? t.activeForm : undefined;
+                                    return { content, status, activeForm };
+                                });
+                                this.ui.setTodos(todos);
+                                this.ui.setCurrentTool(null);
+                                continue;
+                            }
+                            // Skip silent tools (no output needed)
+                            if (toolName === 'todo_read' || toolName === 'suggest' ||
+                                toolName === 'ask_user' || toolName === 'ask_user_simple') {
+                                this.ui.setCurrentTool(null);
+                                continue;
+                            }
+                            // Handle task tool like bash - use atomic commitSubagent
+                            if (toolName === 'task' && event.toolUseId) {
+                                // Extract result content
+                                const { content, success } = this.extractToolResult(toolName, result);
+                                // Use atomic commitSubagent (same pattern as commitBashCommand)
+                                // This removes from LiveRegion and prints in one atomic operation
+                                this.ui.commitSubagent(event.toolUseId, content, success);
+                                this.ui.setCurrentTool(null);
+                                continue; // Skip generic handling
+                            }
+                            // Extract and format tool result
+                            const { content, summary, success } = this.extractToolResult(toolName, result);
+                            this.ui.print({
+                                type: 'tool-result',
+                                name: toolName,
+                                params: this.formatToolParams(toolInput),
+                                summary,
+                                content: content.length > 200 ? content : undefined,
+                                success,
+                            });
+                            this.ui.setCurrentTool(null);
+                        }
+                    }
+                    // Flush remaining text
+                    if (this.textAccumulator.trim()) {
+                        this.ui.print({ type: 'agent-text', text: this.textAccumulator.trim(), expression: 'success' });
+                    }
+                    this.ui.setAgentRunning(false);
+                    // NOTE: Don't clear todos here - they should persist after agent finishes
+                    // to show the final state. Only clear on explicit user action or new conversation.
+                    // Notify that agent has finished (for applying deferred suggestions)
+                    this.onAgentFinish?.();
+                }
+                catch (err) {
+                    if (!signal.aborted) {
+                        this.ui.print({ type: 'error', message: String(err) });
+                    }
+                    this.ui.setAgentRunning(false);
+                    // Still notify on error so suggestions can be applied
+                    this.onAgentFinish?.();
+                }
+            })(),
+        };
+        await this.currentSession.promise;
+        this.currentSession = null;
+    }
+    formatToolParams(input) {
+        if (!input)
+            return '';
+        // Format common params
+        if ('path' in input)
+            return String(input.path);
+        if ('file_path' in input)
+            return String(input.file_path);
+        if ('pattern' in input)
+            return String(input.pattern);
+        if ('command' in input)
+            return String(input.command).slice(0, 50);
+        // Default: show first param
+        const keys = Object.keys(input);
+        if (keys.length > 0) {
+            const val = String(input[keys[0]]);
+            return val.length > 50 ? val.slice(0, 47) + '...' : val;
+        }
+        return '';
+    }
+    /**
+     * Extract content and summary from tool result.
+     * Delegates to tool-formatters module.
+     */
+    extractToolResult(toolName, result) {
+        return formatToolResult(toolName, result);
+    }
+    // ===========================================================================
+    // Agent Simulation (for standalone testing)
+    // ===========================================================================
+    async runAgentSimulation(userMessage) {
+        const abortController = new AbortController();
+        const signal = abortController.signal;
+        const setAction = (action) => {
+            if (this.currentSession) {
+                this.currentSession.currentAction = action;
+            }
+        };
+        this.currentSession = {
+            abortController,
+            currentAction: null,
+            promise: (async () => {
+                try {
+                    this.ui.setAgentRunning(true);
+                    setAction('Thinking...');
+                    this.ui.setSpinnerText('Thinking...');
+                    // 1. Initial response
+                    await this.sleep(1000, signal);
+                    if (signal.aborted)
+                        return;
+                    const response = `I understand you want me to help with "${userMessage}". Let me analyze this.`;
+                    this.ui.print({ type: 'agent-text', text: response });
+                    // 2. Add todos
+                    this.ui.setTodos([
+                        { content: 'Analyze the request', status: 'completed' },
+                        { content: 'Search for relevant files', status: 'in_progress' },
+                        { content: 'Make changes', status: 'pending' },
+                    ]);
+                    // 3. Simulate tool
+                    await this.sleep(800, signal);
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- signal can be aborted externally
+                    if (signal.aborted)
+                        return;
+                    setAction('Glob(**/*.ts)');
+                    this.ui.setSpinnerText('Running Glob...');
+                    await this.sleep(600, signal);
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- signal can be aborted externally
+                    if (signal.aborted)
+                        return;
+                    this.ui.print({
+                        type: 'tool-result',
+                        name: 'Glob',
+                        params: '**/*.ts',
+                        summary: 'Found 42 files',
+                        content: 'src/index.ts\nsrc/config.ts\nsrc/utils/helpers.ts\n... and 39 more',
+                    });
+                    this.ui.setTodos([
+                        { content: 'Analyze the request', status: 'completed' },
+                        { content: 'Search for relevant files', status: 'completed' },
+                        { content: 'Make changes', status: 'in_progress' },
+                    ]);
+                    // 4. Conclusion
+                    await this.sleep(500, signal);
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- signal can be aborted externally
+                    if (signal.aborted)
+                        return;
+                    this.ui.setTodos([
+                        { content: 'Analyze the request', status: 'completed' },
+                        { content: 'Search for relevant files', status: 'completed' },
+                        { content: 'Make changes', status: 'completed' },
+                    ]);
+                    this.ui.print({
+                        type: 'agent-text',
+                        text: 'Done! I have completed the analysis.',
+                        expression: 'success',
+                    });
+                    this.ui.setAgentRunning(false);
+                    // NOTE: Don't clear todos - let them persist to show final state
+                    // Notify that agent has finished (for applying deferred suggestions)
+                    this.onAgentFinish?.();
+                }
+                catch (err) {
+                    if (!signal.aborted) {
+                        this.ui.print({ type: 'error', message: String(err) });
+                    }
+                    this.ui.setAgentRunning(false);
+                    this.onAgentFinish?.();
+                }
+            })(),
+        };
+        await this.currentSession.promise;
+        this.currentSession = null;
+    }
+    async sleep(ms, signal) {
+        return new Promise((resolve) => {
+            const timeout = setTimeout(resolve, ms);
+            signal?.addEventListener('abort', () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    }
+    // ===========================================================================
+    // Session Management
+    // ===========================================================================
+    cancelSession() {
+        const action = this.currentSession?.currentAction ?? undefined;
+        if (this.currentSession) {
+            this.currentSession.abortController.abort();
+            this.currentSession = null;
+        }
+        this.ui.setAgentRunning(false);
+        this.ui.setTodos([]);
+        this.ui.clearQueue();
+        this.ui.print({ type: 'interrupted', action, suggestion: 'what should I do instead?' });
+    }
+}
+// =============================================================================
+// Standalone Entry Point
+// =============================================================================
+// Only run main() when executed directly (not when imported)
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const repl = new ReplV2();
+    repl.start();
+    // Handle SIGINT
+    process.on('SIGINT', () => {
+        console.log('\n\nInterrupted\n');
+        process.exit(0);
+    });
+}