erosolar-cli 2.1.183 → 2.1.184

package/dist/shell/interactiveShell.js

@@ -2333,87 +2333,6 @@ export class InteractiveShell {
         }
         return false;
     }
-    /**
-     * Decide whether to automatically continue execution when the model stops after a plan/summary
-     * without taking actions. This keeps flows moving toward completion instead of stalling on planning.
-     */
-    shouldAutoEscalateToExecution(request, response, toolsUsed) {
-        // Only auto-escalate when the original request itself was action-oriented
-        if (!this.shouldAutoRunToCompletion(request)) {
-            return false;
-        }
-        if (!response || response.includes('TASK_FULLY_COMPLETE')) {
-            return false;
-        }
-        const lower = response.toLowerCase();
-        // Skip if the model explicitly says it is blocked
-        const blockerPatterns = [
-            /\bneed(s)?\s+(more\s+)?(info|information|details|clarification)\b/,
-            /\bmissing\s+(api\s*key|credentials?|access|permission|token)\b/,
-            /\b(no|not)\s+authorized\b/,
-            /\bcannot\s+(proceed|continue|start|run)\b/,
-            /\bblocked\b/,
-        ];
-        if (blockerPatterns.some((pattern) => pattern.test(lower))) {
-            return false;
-        }
-        const mutatingToolUsed = toolsUsed.some((tool) => WRITE_TOOL_NAMES.has(tool.toLowerCase()));
-        const planOnly = this.flowOrchestrator.isPlanOnlyResponse(response);
-        const lowActionDensity = response.split(/\s+/).length < 80;
-        // If it's clearly a plan-only response, continue regardless of prior tool usage
-        if (planOnly) {
-            return true;
-        }
-        // Thin responses without any mutating work should keep pushing toward completion
-        if (!mutatingToolUsed && lowActionDensity) {
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Build a follow-through request when the model stops after planning instead of executing.
-     */
-    maybeAutoFollowThrough(request, response, toolsUsed) {
-        if (!this.shouldAutoEscalateToExecution(request, response, toolsUsed)) {
-            return null;
-        }
-        const prompt = `${request.trim()}
-
-Execute the plan you outlined. Use the available tools (bash, edits, git) to take the next actions and keep going until the request is fully accomplished. Do not restate the plan—perform the steps and report progress. Reply with TASK_FULLY_COMPLETE only when the work is truly done.`;
-        return {
-            prompt,
-            reason: 'Plan-only or low-action response detected; auto-continuing to complete the task.',
-        };
-    }
-    /**
-     * Ensure informational requests produce a user-facing answer rather than stopping after planning.
-     */
-    maybeAutoAnswerInformational(request, response) {
-        const trimmedRequest = request.trim();
-        const trimmedResponse = response.trim();
-        if (!trimmedResponse) {
-            return null;
-        }
-        if (!this.flowOrchestrator.isInformationalRequest(trimmedRequest)) {
-            return null;
-        }
-        if (trimmedResponse.includes('TASK_FULLY_COMPLETE')) {
-            return null;
-        }
-        const providesAnswer = this.flowOrchestrator.responseAnswersUserRequest(trimmedResponse);
-        const planOnly = this.flowOrchestrator.isPlanOnlyResponse(trimmedResponse);
-        const indicatesIncomplete = this.flowOrchestrator.responseIndicatesIncompleteWork(trimmedResponse);
-        if (providesAnswer && !planOnly && !indicatesIncomplete) {
-            return null;
-        }
-        const prompt = `${trimmedRequest}
-
-You have gathered context but did not provide a clear answer. Respond now with a concise, helpful summary that addresses the request directly. Include the key findings (not the plan), and end with "TASK_FULLY_COMPLETE" if nothing else is needed.`;
-        return {
-            prompt,
-            reason: 'Informational request lacked a user-facing answer; prompting to finish helpfully.',
-        };
-    }
     isExitCommand(input) {
         const lower = input.trim().toLowerCase();
         return (lower === 'exit' ||
@@ -5861,20 +5780,22 @@ You have gathered context but did not provide a clear answer. Respond now with a
         this.clearInlinePanel();
         this.syncRendererInput();
     }
-    async processRequest(request) {
+    async runFlowControlledTask(initialRequest, options) {
+        const { maxIterations, mode } = options;
+        const followUpType = mode === 'continuous' ? 'continuous' : 'request';
         if (this.isProcessing) {
-            this.enqueueFollowUpAction({ type: 'request', text: request });
-            return;
+            this.enqueueFollowUpAction({ type: followUpType, text: initialRequest });
+            return null;
         }
         if (!this.agent && !this.rebuildAgent()) {
             display.showWarning('Configure an API key via /secrets before sending requests.');
-            return;
+            return null;
         }
         this.inlinePanelScopeActive = false;
         this.clearInlinePanel();
         const agent = this.agent;
         if (!agent) {
-            return;
+            return null;
         }
         this.toolsUsedThisRun = [];
         this.currentToolCalls = [];
@@ -5885,200 +5806,41 @@ You have gathered context but did not provide a clear answer. Respond now with a
         else {
             this.resetNetworkRetryState();
         }
-        // Reset per-request render tracking
         this.responseRendered = false;
-        if (this.shouldLogPrompt(request)) {
-            this.logUserPrompt(request);
+        if (this.shouldLogPrompt(initialRequest)) {
+            this.logUserPrompt(initialRequest);
         }
         this.isProcessing = true;
         this.uiUpdates.setMode('processing');
-        this.streamingTokenCount = 0; // Reset token counter for new request
+        this.streamingTokenCount = 0;
         this.terminalInput.setStreaming(true);
-        // Keep the persistent input/control bar active as we transition into streaming.
         this.syncRendererInput();
         this.renderer?.render();
-        const requestStartTime = Date.now(); // Alpha Zero 2 timing
-        // Clear previous parallel agents and start fresh for new request
+        const overallStartTime = Date.now();
         const parallelManager = getParallelAgentManager();
         parallelManager.clear();
         parallelManager.startBatch();
-        // AlphaZero: Track task for learning
-        this.lastUserQuery = request;
-        this.currentTaskType = classifyTaskType(request);
+        this.lastUserQuery = initialRequest;
+        this.currentTaskType = classifyTaskType(initialRequest);
         this.currentToolCalls = [];
         this.clearToolUsageMeta();
         this.renderer?.setActivity('Starting...');
-        this.uiAdapter.startProcessing('Working on your request');
+        this.uiAdapter.startProcessing(mode === 'continuous' ? 'Continuous execution mode' : 'Working on your request');
         this.setProcessingStatus();
         this.beginAiRuntime();
-        let responseText = '';
-        let autoFollowThrough = null;
-        let informationalFollowUp = null;
-        try {
-            // Start streaming - no header needed, the input area already provides context
-            this.startStreamingHeartbeat('Streaming response');
-            responseText = await agent.send(request, true);
-            this.finishStreamingFormatter(undefined, { refreshPrompt: false, mode: 'complete' });
-            await this.awaitPendingCleanup();
-            this.captureHistorySnapshot();
-            this.autosaveIfEnabled();
-            // Track metrics with Alpha Zero 2
-            const elapsedMs = Date.now() - requestStartTime;
-            this.alphaZeroMetrics.recordMessage(elapsedMs);
-            if (!responseText?.trim()) {
-                display.showWarning('The provider returned an empty response. Check your API key/provider selection or retry the prompt.');
-            }
-            // AlphaZero: Extract and track tool calls from response
-            const toolsUsed = this.getExecutedTools(responseText);
-            this.currentToolCalls = toolsUsed.map(name => ({
-                name,
-                arguments: {},
-                success: true, // Assume success if we got here
-                duration: 0,
-            }));
-            autoFollowThrough = this.maybeAutoFollowThrough(request, responseText, toolsUsed);
-            informationalFollowUp = this.maybeAutoAnswerInformational(request, responseText);
-            // AlphaZero: Check for failure in response
-            const failure = detectFailure(responseText, {
-                toolCalls: this.currentToolCalls,
-                userMessage: request,
-            });
-            if (failure) {
-                this.lastFailure = failure;
-                // Check if we have a recovery strategy
-                const strategy = findRecoveryStrategy(failure);
-                if (strategy) {
-                    display.showSystemMessage(`🔄 Found recovery strategy for this type of issue (success rate: ${Math.round(strategy.successRate * 100)}%)`);
-                }
-            }
-            else {
-                // Success - record the tool pattern for this task type
-                if (this.currentToolCalls.length > 0) {
-                    const toolPattern = {
-                        taskType: this.currentTaskType,
-                        toolSequence: this.currentToolCalls.map(t => t.name),
-                        successRate: 1.0,
-                        avgDuration: elapsedMs,
-                        occurrences: 1,
-                    };
-                    addToolPattern(this.currentTaskType, toolPattern);
-                }
-                // Clear action history on success
-                clearActionHistory();
-                this.lastFailure = null;
-            }
-        }
-        catch (error) {
-            const handled = this.handleProviderError(error, () => this.processRequest(request));
-            if (!handled) {
-                // Pass full error object for enhanced formatting with stack trace
-                display.showError(error instanceof Error ? error.message : String(error), error);
-            }
-        }
-        finally {
-            // Fallback: if no assistant message was rendered (e.g., streaming hiccup), show the full response
-            if (!this.responseRendered && responseText.trim()) {
-                const finalText = responseText.trim();
-                display.showAssistantMessage(finalText, { isFinal: true });
-                this.ui.controller.recordAssistantResponse(finalText, {
-                    source: 'final',
-                });
-                this.responseRendered = true;
-            }
-            this.finishStreamingFormatter(undefined, { refreshPrompt: false, mode: 'complete' });
-            display.stopThinking(false);
-            this.uiUpdates.setMode('processing');
-            this.stopStreamingHeartbeat('complete', { quiet: true });
-            this.endAiRuntime();
-            this.isProcessing = false;
-            this.terminalInput.setStreaming(false);
-            this.uiAdapter.endProcessing('Ready for prompts');
-            this.updateToolUsageMeta(this.uiAdapter.getToolUsageSummary({ plain: true }));
-            this.setIdleStatus();
-            this.updateStatusMessage(null);
-            if (autoFollowThrough) {
-                display.showSystemMessage(`🔁 Auto-follow-through: ${autoFollowThrough.reason}`);
-                this.enqueueFollowUpAction({ type: 'continuous', text: autoFollowThrough.prompt });
-            }
-            if (informationalFollowUp) {
-                display.showSystemMessage(`🔁 Auto-follow-up: ${informationalFollowUp.reason}`);
-                this.enqueueFollowUpAction({ type: 'request', text: informationalFollowUp.prompt });
-            }
-            this.toolsUsedThisRun = [];
-            queueMicrotask(() => this.uiUpdates.setMode('idle'));
-            // CRITICAL: Ensure readline prompt is active for user input
-            // Erosolar-CLI style: New prompt naturally appears at bottom
-            this.ensureReadlineReady();
-            this.scheduleQueueProcessing();
-            this.maybeProcessPromptInbox();
-            this.refreshQueueIndicators();
-        }
-    }
-    /**
-     * Process a continuous/infinite loop request.
-     * Runs the agent in a loop until:
-     * 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
-        if (this.isProcessing) {
-            this.enqueueFollowUpAction({ type: 'continuous', text: initialRequest });
-            return;
-        }
-        if (!this.agent && !this.rebuildAgent()) {
-            display.showWarning('Configure an API key via /secrets before sending requests.');
-            return;
-        }
-        this.inlinePanelScopeActive = false;
-        this.clearInlinePanel();
-        const agent = this.agent;
-        if (!agent) {
-            return;
-        }
-        this.toolsUsedThisRun = [];
-        this.currentToolCalls = [];
-        this.lastUserQuery = initialRequest;
-        this.clearToolUsageMeta();
-        this.isProcessing = true;
-        this.uiUpdates.setMode('processing');
-        this.streamingTokenCount = 0; // Reset token counter for new request
-        this.terminalInput.setStreaming(true);
-        if (this.suppressNextNetworkReset) {
-            this.suppressNextNetworkReset = false;
-        }
-        else {
-            this.resetNetworkRetryState();
-        }
-        const overallStartTime = Date.now();
-        // Clear previous parallel agents and start fresh for continuous mode
-        const parallelManager = getParallelAgentManager();
-        parallelManager.clear();
-        parallelManager.startBatch();
-        // Initialize the task completion detector
+        this.startStreamingHeartbeat(mode === 'continuous' ? 'Streaming' : 'Streaming response');
         const completionDetector = getTaskCompletionDetector();
         completionDetector.reset();
-        // Display user prompt in scrollback (Claude Code style)
-        this.logUserPrompt(initialRequest);
-        display.showSystemMessage(`Continuous mode active. Ctrl+C to stop.`);
-        this.uiAdapter.startProcessing('Continuous execution mode');
-        this.setProcessingStatus();
-        this.beginAiRuntime();
-        // No streaming header - just start streaming directly
-        this.startStreamingHeartbeat('Streaming');
         this.flowOrchestrator.start(initialRequest);
-        let iteration = 0;
-        try {
-            // Enhance initial prompt with git context for self-improvement tasks
-            let currentPrompt = initialRequest;
-            if (this.isSelfImprovementRequest(initialRequest)) {
-                currentPrompt = `${initialRequest}
+        if (mode === 'continuous') {
+            display.showSystemMessage('Continuous mode active. Ctrl+C to stop.');
+        }
+        else {
+            display.showSystemMessage('Flow orchestrator engaged; running until the request is satisfied.');
+        }
+        let currentPrompt = initialRequest;
+        if (this.isSelfImprovementRequest(initialRequest)) {
+            currentPrompt = `${initialRequest}
 
 IMPORTANT: You have full git access. After making improvements:
 1. Use bash to run: git status (see changes)
@@ -6088,22 +5850,26 @@ IMPORTANT: You have full git access. After making improvements:
 
 Commit frequently with descriptive messages. Push when ready.
 When truly finished with ALL tasks, explicitly state "TASK_FULLY_COMPLETE".`;
-            }
-            while (iteration < MAX_ITERATIONS) {
+        }
+        let iteration = 0;
+        let lastResponseText = '';
+        let lastToolsUsed = [];
+        let result = null;
+        try {
+            while (iteration < maxIterations) {
                 iteration++;
                 this.toolsUsedThisRun = [];
-                display.showSystemMessage(`\n📍 Iteration ${iteration}/${MAX_ITERATIONS}`);
+                display.showSystemMessage(`\n📍 Iteration ${iteration}/${maxIterations}`);
                 this.updateStatusMessage(`Working on iteration ${iteration}...`);
                 try {
-                    // Send the request and capture the response (streaming disabled)
                     display.showThinking('Responding...');
                     this.refreshStatusLine(true);
                     const response = await agent.send(currentPrompt, true);
+                    lastResponseText = response ?? '';
                     this.finishStreamingFormatter(undefined, { refreshPrompt: false, mode: 'complete' });
                     await this.awaitPendingCleanup();
                     this.captureHistorySnapshot();
                     this.autosaveIfEnabled();
-                    // Track metrics
                     const elapsedMs = Date.now() - overallStartTime;
                     this.alphaZeroMetrics.recordMessage(elapsedMs);
                     if (!response?.trim()) {
@@ -6113,10 +5879,9 @@ When truly finished with ALL tasks, explicitly state "TASK_FULLY_COMPLETE".`;
 The previous reply was empty. Resume the task now: take the next action, call the necessary tools, and report progress.`;
                         continue;
                     }
-                    // Extract tools used from the response (look for tool call patterns)
                     const toolsUsed = this.getExecutedTools(response);
+                    lastToolsUsed = toolsUsed;
                     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)}%`);
                     const decision = this.flowOrchestrator.decide({
@@ -6154,39 +5919,50 @@ The previous reply was empty. Resume the task now: take the next action, call th
                         }
                         currentPrompt = decision.prompt;
                     }
-                    // Small delay between iterations to prevent rate limiting
                     await new Promise(resolve => setTimeout(resolve, 500));
                 }
                 catch (error) {
                     display.stopThinking(false);
-                    // Handle context overflow specially - the agent should auto-recover
-                    // but if it propagates here, we continue the loop
                     if (this.isContextOverflowError(error)) {
                         display.showSystemMessage(`⚡ Context overflow handled. Continuing with reduced context...`);
-                        // The agent.ts should have already handled recovery
-                        // Continue to next iteration
                         continue;
                     }
-                    // For other errors, check if handled by provider error handler
-                    const handled = this.handleProviderError(error, () => this.processContinuousRequest(initialRequest));
+                    const handled = this.handleProviderError(error, () => this.runFlowControlledTask(initialRequest, options));
                     if (!handled) {
                         display.showError(error instanceof Error ? error.message : String(error), error);
                         break;
                     }
                 }
             }
-            if (iteration >= MAX_ITERATIONS) {
-                display.showWarning(`\n⚠️ Reached maximum iterations (${MAX_ITERATIONS}). Stopping to prevent infinite loop.`);
+            if (iteration >= maxIterations) {
+                display.showWarning(`\n⚠️ Reached maximum iterations (${maxIterations}). Stopping to prevent infinite loop.`);
+            }
+            if (!this.responseRendered && lastResponseText.trim()) {
+                const finalText = lastResponseText.trim();
+                display.showAssistantMessage(finalText, { isFinal: true });
+                this.ui.controller.recordAssistantResponse(finalText, {
+                    source: 'final',
+                });
+                this.responseRendered = true;
             }
+            result = {
+                finalResponse: lastResponseText,
+                toolsUsed: lastToolsUsed,
+                iterations: iteration,
+                elapsedMs: Date.now() - overallStartTime,
+            };
         }
         finally {
             this.finishStreamingFormatter(undefined, { refreshPrompt: false, mode: 'complete' });
             const totalElapsed = Date.now() - overallStartTime;
             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
+            const completionLabel = mode === 'continuous'
+                ? `\n🏁 Continuous execution completed: ${iteration} iterations, ${minutes}m ${seconds}s total`
+                : `\n🏁 Task run completed: ${iteration} iterations, ${minutes}m ${seconds}s total`;
+            display.showSystemMessage(completionLabel);
             resetTaskCompletionDetector();
+            display.stopThinking(false);
             this.uiUpdates.setMode('processing');
             this.stopStreamingHeartbeat('complete', { quiet: true });
             this.endAiRuntime();
@@ -6198,13 +5974,76 @@ The previous reply was empty. Resume the task now: take the next action, call th
             this.updateStatusMessage(null);
             this.toolsUsedThisRun = [];
             queueMicrotask(() => this.uiUpdates.setMode('idle'));
-            // CRITICAL: Ensure readline prompt is active for user input
-            // Erosolar-CLI style: New prompt naturally appears at bottom
             this.ensureReadlineReady();
             this.scheduleQueueProcessing();
             this.maybeProcessPromptInbox();
             this.refreshQueueIndicators();
         }
+        return result;
+    }
+    handleFlowRunOutcome(request, result) {
+        this.currentToolCalls = result.toolsUsed.map((name) => ({
+            name,
+            arguments: {},
+            success: true,
+            duration: 0,
+        }));
+        const failure = detectFailure(result.finalResponse, {
+            toolCalls: this.currentToolCalls,
+            userMessage: request,
+        });
+        if (failure) {
+            this.lastFailure = failure;
+            const strategy = findRecoveryStrategy(failure);
+            if (strategy) {
+                display.showSystemMessage(`🔄 Found recovery strategy for this type of issue (success rate: ${Math.round(strategy.successRate * 100)}%)`);
+            }
+            return;
+        }
+        if (this.currentToolCalls.length > 0) {
+            const toolPattern = {
+                taskType: this.currentTaskType,
+                toolSequence: this.currentToolCalls.map((t) => t.name),
+                successRate: 1.0,
+                avgDuration: result.elapsedMs,
+                occurrences: 1,
+            };
+            addToolPattern(this.currentTaskType, toolPattern);
+        }
+        clearActionHistory();
+        this.lastFailure = null;
+    }
+    async processRequest(request) {
+        const result = await this.runFlowControlledTask(request, {
+            maxIterations: 12,
+            mode: 'standard',
+        });
+        if (!result) {
+            return;
+        }
+        this.handleFlowRunOutcome(request, result);
+    }
+    /**
+     * Process a continuous/infinite loop request.
+     * Runs the agent in a loop until:
+     * 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 result = await this.runFlowControlledTask(initialRequest, {
+            maxIterations: 100,
+            mode: 'continuous',
+        });
+        if (!result) {
+            return;
+        }
+        this.handleFlowRunOutcome(initialRequest, result);
     }
     /**
      * Resolve executed tools for the current turn. Prefer the actual tool