erosolar-cli 1.5.2 → 1.5.4

package/dist/shell/interactiveShell.js

@@ -10,6 +10,7 @@ import { BracketedPasteManager } from './bracketedPasteManager.js';
 import { detectApiKeyError } from '../core/errors/apiKeyErrors.js';
 import { buildWorkspaceContext } from '../workspace.js';
 import { buildInteractiveSystemPrompt } from './systemPrompt.js';
+import { getTaskCompletionDetector, resetTaskCompletionDetector, } from './taskCompletionDetector.js';
 import { discoverAllModels } from '../core/modelDiscovery.js';
 import { getModels, getSlashCommands, getProviders } from '../core/agentSchemaLoader.js';
 import { clearAutosaveSnapshot, deleteSession, listSessions, loadAutosaveSnapshot, loadSessionById, saveAutosaveSnapshot, saveSessionSnapshot, } from '../core/sessionStore.js';
@@ -80,6 +81,7 @@ export class InteractiveShell {
     cleanupInProgress = false;
     slashPreviewVisible = false;
     keypressHandler = null;
+    rawDataHandler = null;
     skillRepository;
     skillToolHandlers = new Map();
     thinkingMode = 'balanced';
@@ -92,6 +94,8 @@ export class InteractiveShell {
     persistentPrompt;
     alphaZeroMetrics; // Alpha Zero 2 performance tracking
     statusSubscription = null;
+    followUpQueue = [];
+    isDrainingQueue = false;
     activeContextWindowTokens = null;
     sessionPreferences;
     autosaveEnabled;
@@ -367,10 +371,30 @@ export class InteractiveShell {
         display.showInfo(`${this.agentMenuLabel(profileName)} will load the next time you start the CLI. Restart to switch now.`);
     }
     setupHandlers() {
+        // Set up raw data interception for bracketed paste
+        this.setupRawPasteHandler();
         this.rl.on('line', (line) => {
+            // If we're capturing raw paste data, ignore readline line events
+            // (they've already been handled by the raw data handler)
+            if (this.bracketedPaste.isCapturingRaw()) {
+                // Show paste progress
+                this.showMultiLinePastePreview(this.bracketedPaste.getRawBufferLineCount(), this.bracketedPaste.getRawBufferPreview());
+                return;
+            }
             const normalized = this.bracketedPaste.process(line);
             if (normalized.handled) {
+                // If still accumulating multi-line paste, show preview
+                if (normalized.isPending) {
+                    this.showMultiLinePastePreview(normalized.lineCount || 0, normalized.preview);
+                    return;
+                }
+                // Paste complete, submit the full content
                 if (typeof normalized.result === 'string') {
+                    this.clearMultiLinePastePreview();
+                    // Show collapsed summary of what was submitted
+                    if (normalized.lineCount && normalized.lineCount > 1) {
+                        this.displayMultiLineSubmission(normalized.result, normalized.lineCount);
+                    }
                     this.enqueueUserInput(normalized.result, true);
                 }
                 return;
@@ -390,6 +414,11 @@ export class InteractiveShell {
                 inputStream.off('keypress', this.keypressHandler);
                 this.keypressHandler = null;
             }
+            // Remove raw data handler
+            if (inputStream && this.rawDataHandler) {
+                inputStream.off('data', this.rawDataHandler);
+                this.rawDataHandler = null;
+            }
             // Clear any pending cleanup to prevent hanging
             this.pendingCleanup = null;
             // Dispose persistent prompt
@@ -419,6 +448,42 @@ export class InteractiveShell {
         // Show initial persistent prompt
         this.persistentPrompt.show();
     }
+    /**
+     * Set up raw stdin data interception for bracketed paste mode.
+     * This intercepts data before readline processes it, allowing us to
+     * capture complete multi-line pastes without readline splitting them.
+     */
+    setupRawPasteHandler() {
+        if (!this.bracketedPasteEnabled) {
+            return;
+        }
+        const inputStream = input;
+        if (!inputStream || !inputStream.isTTY) {
+            return;
+        }
+        // Set up callback for when a complete paste is captured
+        this.bracketedPaste.setRawPasteCallback((content) => {
+            this.clearMultiLinePastePreview();
+            const lines = content.split('\n');
+            const lineCount = lines.length;
+            // Show collapsed summary for multi-line pastes
+            if (lineCount > 1) {
+                this.displayMultiLineSubmission(content, lineCount);
+            }
+            // Submit the pasted content
+            this.enqueueUserInput(content, true);
+            // Restore the prompt
+            this.persistentPrompt.updateInput('', 0);
+            this.rl.prompt();
+        });
+        // We need to intercept raw data, but we can't easily do this with
+        // readline already consuming stdin. Instead, we handle paste detection
+        // via the bracketed paste markers that appear in line events.
+        // The raw handler approach works better when we control the input stream.
+        //
+        // For now, we rely on the line-event-based approach with enhanced
+        // detection in the BracketedPasteManager.
+    }
     setupSlashCommandPreviewHandler() {
         const inputStream = input;
         if (!inputStream || typeof inputStream.on !== 'function' || !inputStream.isTTY) {
@@ -455,16 +520,24 @@ export class InteractiveShell {
     }
     setIdleStatus(detail) {
         this.statusTracker.setBase('Ready for prompts', {
-            detail: detail ?? this.describeModelDetail(),
+            detail: this.describeStatusDetail(detail),
             tone: 'success',
         });
     }
     setProcessingStatus(detail) {
         this.statusTracker.setBase('Working on your request', {
-            detail: detail ?? this.describeModelDetail(),
+            detail: this.describeStatusDetail(detail),
             tone: 'info',
         });
     }
+    describeStatusDetail(detail) {
+        const parts = [detail?.trim() || this.describeModelDetail()];
+        const queued = this.followUpQueue.length;
+        if (queued > 0) {
+            parts.push(`${queued} follow-up${queued === 1 ? '' : 's'} queued`);
+        }
+        return parts.join(' • ');
+    }
     describeModelDetail() {
         const provider = this.providerLabel(this.sessionState.provider);
         return `${provider} · ${this.sessionState.model}`;
@@ -592,6 +665,42 @@ export class InteractiveShell {
             void this.flushBufferedInput();
         }, MULTILINE_INPUT_FLUSH_DELAY_MS);
     }
+    /**
+     * Show a preview indicator while accumulating multi-line paste
+     */
+    showMultiLinePastePreview(lineCount, preview) {
+        // Clear the current line and show paste accumulation status
+        readline.clearLine(output, 0);
+        readline.cursorTo(output, 0);
+        const statusText = preview
+            ? `${theme.ui.muted('📋 Pasting:')} ${theme.ui.muted(preview.slice(0, 50))}${preview.length > 50 ? '...' : ''}`
+            : `${theme.ui.muted(`📋 Pasting ${lineCount} line${lineCount !== 1 ? 's' : ''}...`)}`;
+        output.write(statusText);
+    }
+    /**
+     * Clear the multi-line paste preview
+     */
+    clearMultiLinePastePreview() {
+        readline.clearLine(output, 0);
+        readline.cursorTo(output, 0);
+    }
+    /**
+     * Display a collapsed summary of multi-line content that was submitted
+     */
+    displayMultiLineSubmission(content, lineCount) {
+        const lines = content.split('\n');
+        const firstLine = (lines[0] || '').trim();
+        const maxPreviewLen = Math.min(60, (output.columns || 80) - 20);
+        const truncatedFirst = firstLine.length > maxPreviewLen
+            ? firstLine.slice(0, maxPreviewLen - 3) + '...'
+            : firstLine;
+        // Show collapsed block indicator
+        const collapsedDisplay = theme.ui.muted(`📋 ${truncatedFirst} [${lineCount} lines]`);
+        // Clear line and show the collapsed preview, then newline for response
+        readline.clearLine(output, 0);
+        readline.cursorTo(output, 0);
+        console.log(`${formatUserPrompt(this.profileLabel || this.profile)}${collapsedDisplay}`);
+    }
     async flushBufferedInput() {
         if (!this.bufferedInputLines.length) {
             this.bufferedInputTimer = null;
@@ -610,6 +719,85 @@ export class InteractiveShell {
             this.rl.prompt();
         }
     }
+    refreshQueueIndicators() {
+        const queued = this.followUpQueue.length;
+        // Build status message based on processing state and queue
+        let message;
+        if (this.isProcessing) {
+            const queueSuffix = queued > 0 ? ` (${queued} queued)` : ' (type to queue follow-up)';
+            message = `⏳ Processing...${queueSuffix}`;
+        }
+        else if (queued > 0) {
+            message = `${queued} follow-up${queued === 1 ? '' : 's'} queued`;
+        }
+        this.persistentPrompt.updateStatusBar({ message });
+        if (this.isProcessing) {
+            this.setProcessingStatus();
+        }
+        else {
+            this.setIdleStatus();
+        }
+    }
+    enqueueFollowUpAction(action) {
+        this.followUpQueue.push(action);
+        const normalized = action.text.replace(/\s+/g, ' ').trim();
+        const previewLimit = 80;
+        const preview = normalized.length > previewLimit ? `${normalized.slice(0, previewLimit - 3)}...` : normalized;
+        const position = this.followUpQueue.length === 1 ? 'to run next' : `#${this.followUpQueue.length} in queue`;
+        const label = action.type === 'continuous' ? 'continuous command' : 'follow-up';
+        const queueCount = this.followUpQueue.length;
+        // Show immediate acknowledgment with checkmark
+        const queueLabel = queueCount === 1 ? '1 queued' : `${queueCount} queued`;
+        if (preview) {
+            display.showInfo(`✓ ${theme.info(label)} ${position}: ${theme.ui.muted(preview)}`);
+        }
+        else {
+            display.showInfo(`✓ ${theme.info(label)} queued ${position}.`);
+        }
+        // Update status bar to show queue count
+        this.persistentPrompt.updateStatusBar({
+            message: `⏳ Processing... (${queueLabel})`
+        });
+        this.refreshQueueIndicators();
+        this.scheduleQueueProcessing();
+        // Re-show the prompt so user can continue typing more follow-ups
+        this.rl.prompt();
+    }
+    scheduleQueueProcessing() {
+        if (!this.followUpQueue.length) {
+            this.refreshQueueIndicators();
+            return;
+        }
+        queueMicrotask(() => {
+            void this.processQueuedActions();
+        });
+    }
+    async processQueuedActions() {
+        if (this.isDrainingQueue || this.isProcessing || !this.followUpQueue.length) {
+            return;
+        }
+        this.isDrainingQueue = true;
+        try {
+            while (!this.isProcessing && this.followUpQueue.length) {
+                const next = this.followUpQueue.shift();
+                const remaining = this.followUpQueue.length;
+                const label = next.type === 'continuous' ? 'continuous command' : 'follow-up';
+                const suffix = remaining ? ` (${remaining} left after this)` : '';
+                display.showSystemMessage(`▶ Running queued ${label}${suffix}.`);
+                this.refreshQueueIndicators();
+                if (next.type === 'continuous') {
+                    await this.processContinuousRequest(next.text);
+                }
+                else {
+                    await this.processRequest(next.text);
+                }
+            }
+        }
+        finally {
+            this.isDrainingQueue = false;
+            this.refreshQueueIndicators();
+        }
+    }
     async processInputBlock(line, _wasRapidMultiLine = false) {
         this.slashPreviewVisible = false;
         this.uiAdapter.hideSlashCommandPreview();
@@ -1727,7 +1915,7 @@ export class InteractiveShell {
     }
     async processRequest(request) {
         if (this.isProcessing) {
-            display.showWarning('Please wait for the current request to complete.');
+            this.enqueueFollowUpAction({ type: 'request', text: request });
             return;
         }
         if (!this.agent && !this.rebuildAgent()) {
@@ -1740,8 +1928,9 @@ export class InteractiveShell {
         }
         this.isProcessing = true;
         const requestStartTime = Date.now(); // Alpha Zero 2 timing
-        // Hide persistent prompt during processing to avoid UI conflicts
-        this.persistentPrompt.hide();
+        // 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)' });
         this.uiAdapter.startProcessing('Working on your request');
         this.setProcessingStatus();
         try {
@@ -1769,30 +1958,32 @@ export class InteractiveShell {
             this.uiAdapter.endProcessing('Ready for prompts');
             this.setIdleStatus();
             display.newLine();
-            // Ensure persistent prompt is visible after processing
+            // Clear the processing status and ensure persistent prompt is visible
+            this.persistentPrompt.updateStatusBar({ message: undefined });
             this.persistentPrompt.show();
             // CRITICAL: Ensure readline prompt is active for user input
             // This is a safety net in case the caller doesn't call rl.prompt()
             this.rl.prompt();
+            this.scheduleQueueProcessing();
+            this.refreshQueueIndicators();
         }
     }
     /**
      * Process a continuous/infinite loop request.
      * Runs the agent in a loop until:
-     * 1. The agent indicates completion (no more actions needed)
+     * 1. The agent indicates completion (verified by AI confirmation)
      * 2. User interrupts (Ctrl+C)
      * 3. Maximum iterations reached (safety limit)
      *
+     * Uses intelligent task completion detection with AI verification
+     * to ensure tasks are truly complete before stopping.
+     *
      * Context is automatically managed - overflow errors trigger auto-recovery.
      */
     async processContinuousRequest(initialRequest) {
         const MAX_ITERATIONS = 100; // Safety limit to prevent truly infinite loops
-        const COMPLETION_PATTERNS = [
-            /\b(completed?|done|finished|all.*done|task.*complete|nothing.*left|no.*more.*tasks?)\b/i,
-            /\b(everything.*done|all.*tasks?.*complete|successfully.*completed?)\b/i,
-        ];
         if (this.isProcessing) {
-            display.showWarning('Please wait for the current request to complete.');
+            this.enqueueFollowUpAction({ type: 'continuous', text: initialRequest });
             return;
         }
         if (!this.agent && !this.rebuildAgent()) {
@@ -1805,15 +1996,22 @@ export class InteractiveShell {
         }
         this.isProcessing = true;
         const overallStartTime = Date.now();
-        // Hide persistent prompt during processing
-        this.persistentPrompt.hide();
+        // 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)' });
         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();
         let iteration = 0;
         let lastResponse = '';
         let consecutiveNoProgress = 0;
-        const MAX_NO_PROGRESS = 3;
+        const MAX_NO_PROGRESS = 5; // Increased to allow more attempts before giving up
+        let pendingVerification = false;
+        let verificationAttempts = 0;
+        const MAX_VERIFICATION_ATTEMPTS = 2;
         try {
             // Enhance initial prompt with git context for self-improvement tasks
             let currentPrompt = initialRequest;
@@ -1826,7 +2024,8 @@ IMPORTANT: You have full git access. After making improvements:
 3. Use bash to run: git commit -m "descriptive message" (commit)
 4. Use bash to run: git push (when milestone reached)
 
-Commit frequently with descriptive messages. Push when ready.`;
+Commit frequently with descriptive messages. Push when ready.
+When truly finished with ALL tasks, explicitly state "TASK_FULLY_COMPLETE".`;
             }
             while (iteration < MAX_ITERATIONS) {
                 iteration++;
@@ -1842,18 +2041,67 @@ Commit frequently with descriptive messages. Push when ready.`;
                     const elapsedMs = Date.now() - overallStartTime;
                     this.alphaZeroMetrics.recordMessage(elapsedMs);
                     display.stopThinking(false);
-                    // Check if the response indicates completion
-                    const isComplete = COMPLETION_PATTERNS.some(pattern => pattern.test(response));
-                    const responseChanged = response !== lastResponse;
-                    if (isComplete && responseChanged) {
-                        display.showSystemMessage(`\n✅ Task completed after ${iteration} iteration(s).`);
+                    // Extract tools used from the response (look for tool call patterns)
+                    const toolsUsed = this.extractToolsFromResponse(response);
+                    completionDetector.recordToolCall.bind(completionDetector);
+                    toolsUsed.forEach(tool => completionDetector.recordToolCall(tool, true, true));
+                    // Use intelligent completion detection
+                    const completionAnalysis = completionDetector.analyzeCompletion(response, toolsUsed);
+                    display.showSystemMessage(`📈 Completion confidence: ${(completionAnalysis.confidence * 100).toFixed(0)}%`);
+                    // Check for explicit TASK_FULLY_COMPLETE marker (highest priority)
+                    if (response.includes('TASK_FULLY_COMPLETE')) {
+                        display.showSystemMessage(`\n✅ Task explicitly marked complete after ${iteration} iteration(s).`);
                         break;
                     }
+                    // High confidence completion without verification needed
+                    if (completionAnalysis.isComplete && completionAnalysis.confidence >= 0.85) {
+                        display.showSystemMessage(`\n✅ Task completed with high confidence after ${iteration} iteration(s).`);
+                        display.showSystemMessage(`   Reason: ${completionAnalysis.reason}`);
+                        break;
+                    }
+                    // Medium confidence - run verification round
+                    if (completionAnalysis.shouldVerify && completionAnalysis.verificationPrompt && !pendingVerification) {
+                        if (verificationAttempts < MAX_VERIFICATION_ATTEMPTS) {
+                            display.showSystemMessage(`\n🔍 Running verification round (confidence: ${(completionAnalysis.confidence * 100).toFixed(0)}%)...`);
+                            pendingVerification = true;
+                            verificationAttempts++;
+                            currentPrompt = completionAnalysis.verificationPrompt;
+                            await new Promise(resolve => setTimeout(resolve, 500));
+                            continue;
+                        }
+                    }
+                    // If we were in verification mode, check the result
+                    if (pendingVerification) {
+                        pendingVerification = false;
+                        if (completionDetector.isVerificationConfirmed(response)) {
+                            display.showSystemMessage(`\n✅ Task completion verified by AI after ${iteration} iteration(s).`);
+                            break;
+                        }
+                        else {
+                            display.showSystemMessage(`🔄 Verification indicates more work needed. Continuing...`);
+                        }
+                    }
                     // Check for no progress (same response multiple times)
+                    const responseChanged = response !== lastResponse;
                     if (!responseChanged) {
                         consecutiveNoProgress++;
                         if (consecutiveNoProgress >= MAX_NO_PROGRESS) {
-                            display.showSystemMessage(`\n⚠️ No progress detected for ${MAX_NO_PROGRESS} iterations. Stopping.`);
+                            // Before giving up, ask one final verification
+                            if (verificationAttempts < MAX_VERIFICATION_ATTEMPTS) {
+                                display.showSystemMessage(`\n⚠️ No progress for ${MAX_NO_PROGRESS} iterations. Running final verification...`);
+                                currentPrompt = `I notice you may be stuck or finished. Please confirm:
+
+1. Is the original task FULLY complete?
+2. If yes, respond with exactly: "TASK_FULLY_COMPLETE"
+3. If no, what specific action should be taken next?
+
+Be explicit about the current state.`;
+                                verificationAttempts++;
+                                consecutiveNoProgress = 0;
+                                await new Promise(resolve => setTimeout(resolve, 500));
+                                continue;
+                            }
+                            display.showSystemMessage(`\n⚠️ No progress detected for ${MAX_NO_PROGRESS} iterations and verification exhausted. Stopping.`);
                             break;
                         }
                     }
@@ -1861,12 +2109,15 @@ Commit frequently with descriptive messages. Push when ready.`;
                         consecutiveNoProgress = 0;
                     }
                     lastResponse = response;
-                    // Prepare next iteration prompt - explicitly encourage git usage
+                    // Prepare next iteration prompt - explicitly encourage progress reporting
                     currentPrompt = `Continue with the next step. Remember:
 - Use bash to run git commands (git status, git add, git commit, git push)
 - Commit your changes with descriptive messages after completing improvements
 - Push changes when a logical milestone is reached
-If all tasks are complete, say "done".`;
+- If all tasks are complete, respond with exactly: "TASK_FULLY_COMPLETE"
+- If there are errors or blockers, explain what's preventing progress
+
+What's the next action?`;
                     // Small delay between iterations to prevent rate limiting
                     await new Promise(resolve => setTimeout(resolve, 500));
                 }
@@ -1897,15 +2148,44 @@ If all tasks are complete, say "done".`;
             const minutes = Math.floor(totalElapsed / 60000);
             const seconds = Math.floor((totalElapsed % 60000) / 1000);
             display.showSystemMessage(`\n🏁 Continuous execution completed: ${iteration} iterations, ${minutes}m ${seconds}s total`);
+            // Reset completion detector for next task
+            resetTaskCompletionDetector();
             this.isProcessing = false;
             this.uiAdapter.endProcessing('Ready for prompts');
             this.setIdleStatus();
             display.newLine();
+            // Clear the processing status and ensure persistent prompt is visible
+            this.persistentPrompt.updateStatusBar({ message: undefined });
             this.persistentPrompt.show();
             // CRITICAL: Ensure readline prompt is active for user input
             // This is a safety net in case the caller doesn't call rl.prompt()
             this.rl.prompt();
+            this.scheduleQueueProcessing();
+            this.refreshQueueIndicators();
+        }
+    }
+    /**
+     * Extract tool names from a response by looking for tool call patterns
+     */
+    extractToolsFromResponse(response) {
+        const tools = [];
+        // Look for common tool call patterns in the response
+        const toolPatterns = [
+            /(?: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,
+        ];
+        for (const pattern of toolPatterns) {
+            let match;
+            while ((match = pattern.exec(response)) !== null) {
+                const toolName = match[1] || match[0];
+                if (toolName && !tools.includes(toolName.toLowerCase())) {
+                    tools.push(toolName.toLowerCase());
+                }
+            }
         }
+        return tools;
     }
     /**
      * Check if an error is a context overflow error