erosolar-cli 1.7.161 → 1.7.164

package/dist/shell/interactiveShell.js

@@ -23,6 +23,8 @@ import { PersistentPrompt, PinnedChatBox } from '../ui/persistentPrompt.js';
 import { formatShortcutsHelp } from '../ui/shortcutsHelp.js';
 import { MetricsTracker } from '../alpha-zero/index.js';
 import { listAvailablePlugins } from '../plugins/index.js';
+import { getClaudeCodeStreamHandler } from './claudeCodeStreamHandler.js';
+import { getUnifiedChatBox } from './unifiedChatBox.js';
 const DROPDOWN_COLORS = [
     theme.primary,
     theme.info,
@@ -114,6 +116,8 @@ export class InteractiveShell {
     pinnedChatBox;
     readlineOutputSuppressed = false;
     originalStdoutWrite = null;
+    streamHandler;
+    unifiedChatBox;
     constructor(config) {
         this.profile = config.profile;
         this.profileLabel = config.profileLabel;
@@ -226,6 +230,17 @@ export class InteractiveShell {
         // This ensures the pinned area is cleared before output and re-rendered after,
         // preventing ghost lines when the terminal scrolls
         this.pinnedChatBox.registerOutputInterceptor(display);
+        // Initialize Claude Code style stream handler for natural output flow
+        // Key insight: No cursor manipulation during streaming - output just appends
+        this.streamHandler = getClaudeCodeStreamHandler();
+        this.streamHandler.attachToReadline(this.rl);
+        // Initialize UnifiedChatBox - Claude Code exact style
+        // The chat box is always at the bottom naturally through readline
+        // During streaming: output flows up, typed input queued invisibly
+        // After streaming: new prompt appears at bottom naturally
+        this.unifiedChatBox = getUnifiedChatBox();
+        this.unifiedChatBox.attachToReadline(this.rl);
+        this.unifiedChatBox.setPrompt(formatUserPrompt(this.profileLabel || this.profile));
         // Initialize Alpha Zero 2 metrics tracking
         this.alphaZeroMetrics = new MetricsTracker(`${this.profile}-${Date.now()}`);
         this.setupStatusTracking();
@@ -278,15 +293,16 @@ export class InteractiveShell {
         this.sessionResumeNotice = null;
     }
     async start(initialPrompt) {
-        // Always render the pinned chat box at startup so it's visible from the beginning
-        this.pinnedChatBox.show();
-        this.pinnedChatBox.forceRender();
+        // Claude Code style: Just use readline's prompt
+        // The prompt naturally appears at the bottom
+        // No complex UI rendering needed - terminal handles it naturally
         if (initialPrompt) {
             display.newLine();
             console.log(`${formatUserPrompt(this.profileLabel || this.profile)}${initialPrompt}`);
             await this.processInputBlock(initialPrompt);
             return;
         }
+        // Show readline prompt - naturally at bottom of terminal
         this.rl.prompt();
     }
     async handleToolSettingsInput(input) {
@@ -482,6 +498,10 @@ export class InteractiveShell {
             this.pendingCleanup = null;
             // Dispose persistent prompt
             this.persistentPrompt.dispose();
+            // Dispose Claude Code stream handler
+            this.streamHandler.dispose();
+            // Dispose unified chat box
+            this.unifiedChatBox.dispose();
             // Dispose unified UI adapter
             this.uiAdapter.dispose();
             display.newLine();
@@ -786,14 +806,25 @@ export class InteractiveShell {
             }
         }
         // Restore readline output if it was suppressed
-        this.restoreReadlineOutput();
+        // Note: Stream handler manages its own state, this is for legacy compatibility
+        if (!this.streamHandler.isStreaming()) {
+            this.restoreReadlineOutput();
+        }
     }
     /**
      * Suppress readline's character echo during streaming.
      * Characters typed will be captured but not echoed to the main output.
      * Instead, they appear only in the persistent input box at the bottom.
+     *
+     * @deprecated Use streamHandler.startStreaming() instead - kept for backwards compatibility
+     * @internal Kept for legacy code paths that may still reference this method
      */
+    // @ts-expect-error - Legacy method kept for backwards compatibility, unused in favor of streamHandler
     suppressReadlineOutput() {
+        // Delegate to stream handler if it's not already streaming
+        if (this.streamHandler.isStreaming()) {
+            return;
+        }
         if (this.readlineOutputSuppressed || !output.isTTY) {
             return;
         }
@@ -850,6 +881,8 @@ export class InteractiveShell {
     }
     /**
      * Restore normal readline output after streaming completes.
+     *
+     * @deprecated Use streamHandler.endStreaming() instead
      */
     restoreReadlineOutput() {
         if (!this.readlineOutputSuppressed || !this.originalStdoutWrite) {
@@ -1080,6 +1113,72 @@ export class InteractiveShell {
             void this.processQueuedActions();
         });
     }
+    /**
+     * Process any inputs that were queued during streaming.
+     * Claude Code style: User can type while streaming, input is stored in queue,
+     * processed after streaming ends.
+     *
+     * @deprecated Use processUnifiedChatBoxQueue() instead
+     */
+    // @ts-expect-error - Legacy method kept for backwards compatibility
+    processQueuedInputs() {
+        if (!this.streamHandler.hasQueuedInput()) {
+            return;
+        }
+        // Transfer queued inputs from stream handler to follow-up queue
+        while (this.streamHandler.hasQueuedInput()) {
+            const input = this.streamHandler.getNextQueuedInput();
+            if (!input) {
+                break;
+            }
+            // Handle interrupts specially
+            if (input.type === 'interrupt') {
+                // Interrupt was already processed during capture
+                continue;
+            }
+            // Add to follow-up queue for processing
+            const actionType = input.type === 'command' ? 'request' : 'request';
+            this.followUpQueue.push({
+                type: actionType,
+                text: input.text,
+            });
+        }
+        // Show queue summary if there are items
+        const summary = this.streamHandler.getQueueSummary();
+        if (summary) {
+            display.showInfo(`📝 ${summary}`);
+        }
+    }
+    /**
+     * Process any inputs that were queued in UnifiedChatBox during streaming.
+     * Claude Code style: User can type while streaming, input is stored invisibly,
+     * processed after streaming ends.
+     */
+    processUnifiedChatBoxQueue() {
+        if (!this.unifiedChatBox.hasQueuedInput()) {
+            return;
+        }
+        // Transfer queued inputs from unified chat box to follow-up queue
+        while (this.unifiedChatBox.hasQueuedInput()) {
+            const input = this.unifiedChatBox.dequeue();
+            if (!input) {
+                break;
+            }
+            // Handle interrupts specially - they cancel current operation
+            if (input.type === 'interrupt') {
+                // Request cancellation if agent is running
+                if (this.agent) {
+                    this.agent.requestCancellation();
+                }
+                continue;
+            }
+            // Add to follow-up queue for processing
+            this.followUpQueue.push({
+                type: 'request',
+                text: input.text,
+            });
+        }
+    }
     async processQueuedActions() {
         if (this.isDrainingQueue || this.isProcessing || !this.followUpQueue.length) {
             return;
@@ -2415,25 +2514,20 @@ export class InteractiveShell {
         }
         this.isProcessing = true;
         const requestStartTime = Date.now(); // Alpha Zero 2 timing
-        // Keep persistent prompt visible during processing so users can type follow-up requests
-        // The prompt will show a "processing" indicator but remain interactive
-        this.persistentPrompt.updateStatusBar({ message: '⏳ Processing... (type to queue follow-up)' });
-        // Update pinned chat box to show processing state
-        // Clear the input display since the request was already submitted
-        // Note: Don't set statusMessage here - the isProcessing flag already shows "⏳ Processing..."
-        this.pinnedChatBox.setProcessing(true);
-        this.pinnedChatBox.setStatusMessage(null); // Clear any previous status to avoid duplication
-        this.pinnedChatBox.clearInput();
+        // Claude Code style: Update status (optional, won't interfere with streaming)
+        this.persistentPrompt.updateStatusBar({ message: '⏳ Processing...' });
         this.uiAdapter.startProcessing('Working on your request');
         this.setProcessingStatus();
         try {
             // Add visual separator between user prompt and AI response
             display.newLine();
             display.newLine();
-            // Enable scroll region so streaming output scrolls while input stays at bottom
-            this.pinnedChatBox.enableScrollRegion();
-            // Suppress readline echo so typed characters only appear in persistent input box
-            this.suppressReadlineOutput();
+            // Claude Code style: Start streaming mode using UnifiedChatBox
+            // - Output flows naturally to stdout (NO cursor manipulation)
+            // - User input is captured invisibly and queued
+            // - Prompt scrolls up naturally with output
+            // - After streaming ends, new prompt appears at bottom
+            this.unifiedChatBox.startStreaming();
             // Enable streaming for real-time text output (Claude Code style)
             await agent.send(request, true);
             await this.awaitPendingCleanup();
@@ -2451,24 +2545,24 @@ export class InteractiveShell {
             }
         }
         finally {
-            // Restore readline echo before other cleanup
-            this.restoreReadlineOutput();
-            // Disable scroll region before any other output to restore normal terminal behavior
-            this.pinnedChatBox.disableScrollRegion();
+            // Claude Code style: End streaming mode using UnifiedChatBox
+            // This restores readline echo and returns queue info
+            const streamResult = this.unifiedChatBox.endStreaming();
+            // Process any queued inputs that came in during streaming
+            this.processUnifiedChatBoxQueue();
+            // Show queue indicator if there were queued inputs
+            if (streamResult.queuedCount > 0) {
+                this.unifiedChatBox.showQueueIndicator();
+            }
             display.stopThinking(false);
             this.isProcessing = false;
             this.uiAdapter.endProcessing('Ready for prompts');
             this.setIdleStatus();
             display.newLine();
-            // Clear the processing status and ensure persistent prompt is visible
+            // Clear the processing status
             this.persistentPrompt.updateStatusBar({ message: undefined });
-            this.persistentPrompt.show();
-            // Update pinned chat box to show ready state and force render
-            this.pinnedChatBox.setProcessing(false);
-            this.pinnedChatBox.setStatusMessage(null);
-            this.pinnedChatBox.forceRender();
             // CRITICAL: Ensure readline prompt is active for user input
-            // Call ensureReadlineReady to resume stdin if paused and re-enable keypress
+            // Claude Code style: New prompt naturally appears at bottom
             this.ensureReadlineReady();
             this.rl.prompt();
             this.scheduleQueueProcessing();
@@ -2506,21 +2600,17 @@ export class InteractiveShell {
         // Initialize the task completion detector
         const completionDetector = getTaskCompletionDetector();
         completionDetector.reset();
-        // Keep persistent prompt visible during processing so users can type follow-up requests
-        this.persistentPrompt.updateStatusBar({ message: '🔄 Continuous mode... (type to queue follow-up)' });
-        // Update pinned chat box for continuous mode
-        // Clear the input display since the request was already submitted
-        this.pinnedChatBox.setProcessing(true);
-        this.pinnedChatBox.setStatusMessage('Continuous execution mode...');
-        this.pinnedChatBox.clearInput();
+        // Claude Code style: Update status
+        this.persistentPrompt.updateStatusBar({ message: '🔄 Continuous mode...' });
         display.showSystemMessage(`🔄 Starting continuous execution mode. Press Ctrl+C to stop.`);
         display.showSystemMessage(`📊 Using intelligent task completion detection with AI verification.`);
         this.uiAdapter.startProcessing('Continuous execution mode');
         this.setProcessingStatus();
-        // Enable scroll region so streaming output scrolls while input stays at bottom
-        this.pinnedChatBox.enableScrollRegion();
-        // Suppress readline echo so typed characters only appear in persistent input box
-        this.suppressReadlineOutput();
+        // Claude Code style: Start streaming mode using UnifiedChatBox
+        // - Output flows naturally to stdout (NO cursor manipulation)
+        // - User input is captured invisibly and queued
+        // - Prompt scrolls up naturally with output
+        this.unifiedChatBox.startStreaming();
         let iteration = 0;
         let lastResponse = '';
         let consecutiveNoProgress = 0;
@@ -2682,23 +2772,22 @@ What's the next action?`;
             display.showSystemMessage(`\n🏁 Continuous execution completed: ${iteration} iterations, ${minutes}m ${seconds}s total`);
             // Reset completion detector for next task
             resetTaskCompletionDetector();
-            // Restore readline echo before other cleanup
-            this.restoreReadlineOutput();
+            // Claude Code style: End streaming mode using UnifiedChatBox
+            const streamResult = this.unifiedChatBox.endStreaming();
+            // Process any queued inputs that came in during streaming
+            this.processUnifiedChatBoxQueue();
+            // Show queue indicator if there were queued inputs
+            if (streamResult.queuedCount > 0) {
+                this.unifiedChatBox.showQueueIndicator();
+            }
             this.isProcessing = false;
             this.uiAdapter.endProcessing('Ready for prompts');
             this.setIdleStatus();
-            // Disable scroll region before output to restore normal terminal behavior
-            this.pinnedChatBox.disableScrollRegion();
             display.newLine();
-            // Clear the processing status and ensure persistent prompt is visible
+            // Clear the processing status
             this.persistentPrompt.updateStatusBar({ message: undefined });
-            this.persistentPrompt.show();
-            // Update pinned chat box to show ready state and force render
-            this.pinnedChatBox.setProcessing(false);
-            this.pinnedChatBox.setStatusMessage(null);
-            this.pinnedChatBox.forceRender();
             // CRITICAL: Ensure readline prompt is active for user input
-            // Call ensureReadlineReady to resume stdin if paused and re-enable keypress
+            // Claude Code style: New prompt naturally appears at bottom
             this.ensureReadlineReady();
             this.rl.prompt();
             this.scheduleQueueProcessing();
@@ -2805,7 +2894,7 @@ What's the next action?`;
             /(?:running|executing|called?|using)\s+(?:the\s+)?(\w+(?:_\w+)*)\s+tool/gi,
             /tool[:\s]+(\w+(?:_\w+)*)/gi,
             /⎿\s*(\w+)/g, // Tool result prefix pattern
-            /(?:read_file|write_file|edit_file|bash|grep|glob|search)/gi,
+            /(?:read_file|edit_file|Edit|bash|grep|glob|search)/gi,
         ];
         for (const pattern of toolPatterns) {
             let match;