erosolar-cli 2.1.177 → 2.1.179

package/dist/shell/interactiveShell.js

@@ -4,7 +4,6 @@ import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
 import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
-import { AgentOrchestrator } from '../core/agentOrchestrator.js';
 import { display } from '../ui/display.js';
 import { theme } from '../ui/theme.js';
 import { getTerminalColumns } from '../ui/layout.js';
@@ -13,12 +12,13 @@ import { ensureSecretForProvider, getSecretDefinitionForProvider, getSecretValue
 import { saveActiveProfilePreference, saveModelPreference, loadToolSettings, saveToolSettings, clearToolSettings, clearActiveProfilePreference, loadSessionPreferences, saveSessionPreferences, loadFeatureFlags, saveFeatureFlags, toggleFeatureFlag, FEATURE_FLAG_INFO, } from '../core/preferences.js';
 import { getLearningSummary, getRecentLearning, commitLearning, exportAllLearning, getLearningDir, } from '../core/learningPersistence.js';
 import { buildEnabledToolSet, evaluateToolPermissions, getToolToggleOptions, } from '../capabilities/toolRegistry.js';
+import { FlowOrchestrator } from '../runtime/flowOrchestrator.js';
 import { detectApiKeyError } from '../core/errors/apiKeyErrors.js';
 import { detectPromptBlockError, } from '../core/errors/promptBlockErrors.js';
 import { detectNetworkError } from '../core/errors/networkErrors.js';
 import { buildWorkspaceContext } from '../workspace.js';
 import { buildInteractiveSystemPrompt } from './systemPrompt.js';
-import { WRITE_TOOLS } from './taskCompletionDetector.js';
+import { getTaskCompletionDetector, resetTaskCompletionDetector, WRITE_TOOLS, } from './taskCompletionDetector.js';
 import { discoverAllModels, quickCheckProviders, getCachedDiscoveredModels, sortModelsByPriority } from '../core/modelDiscovery.js';
 import { getModels, getSlashCommands, getProviders } from '../core/agentSchemaLoader.js';
 import { loadMcpServers } from '../mcp/config.js';
@@ -124,6 +124,7 @@ export class InteractiveShell {
     uiUpdates;
     _fileChangeTracker = new FileChangeTracker(); // Reserved for future file tracking features
     alphaZeroMetrics; // Alpha Zero 2 performance tracking
+    flowOrchestrator = new FlowOrchestrator();
     maxNetworkRetries = 2;
     statusSubscription = null;
     followUpQueue = [];
@@ -2275,17 +2276,14 @@ export class InteractiveShell {
         // Check for continuous/infinite loop commands or auto-escalation to completion mode
         const explicitContinuous = this.isContinuousCommand(trimmed);
         const autoContinuous = this.shouldAutoRunToCompletion(trimmed);
-        if (explicitContinuous) {
+        if (explicitContinuous || autoContinuous) {
+            if (autoContinuous && !explicitContinuous) {
+                display.showSystemMessage('⚡ Actionable request detected; running continuously until complete (Ctrl+C to stop).');
+            }
             await this.processContinuousRequest(trimmed);
             this.syncRendererInput();
             return;
         }
-        if (autoContinuous) {
-            display.showSystemMessage('⚡ Actionable request detected; orchestrating until complete (Ctrl+C to stop).');
-            await this.processRequest(trimmed, { orchestrate: true });
-            this.syncRendererInput();
-            return;
-        }
         // Direct execution for all inputs, including multi-line pastes
         await this.processRequest(trimmed);
         this.syncRendererInput();
@@ -2360,7 +2358,7 @@ export class InteractiveShell {
             return false;
         }
         const mutatingToolUsed = toolsUsed.some((tool) => WRITE_TOOL_NAMES.has(tool.toLowerCase()));
-        const planOnly = this.isPlanOnlyResponse(response);
+        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) {
@@ -5834,7 +5832,7 @@ Execute the plan you outlined. Use the available tools (bash, edits, git) to tak
         this.clearInlinePanel();
         this.syncRendererInput();
     }
-    async processRequest(request, options) {
+    async processRequest(request) {
         if (this.isProcessing) {
             this.enqueueFollowUpAction({ type: 'request', text: request });
             return;
@@ -5886,23 +5884,10 @@ Execute the plan you outlined. Use the available tools (bash, edits, git) to tak
         this.beginAiRuntime();
         let responseText = '';
         let autoFollowThrough = null;
-        let orchestratorResult = null;
-        const orchestrate = options?.orchestrate ?? false;
         try {
             // Start streaming - no header needed, the input area already provides context
             this.startStreamingHeartbeat('Streaming response');
-            if (orchestrate) {
-                const orchestrator = new AgentOrchestrator(agent);
-                orchestratorResult = await orchestrator.runToCompletion(request, {
-                    streaming: true,
-                    maxPasses: options?.maxPasses ?? 4,
-                    enforceActions: true,
-                });
-                responseText = orchestratorResult.finalResponse;
-            }
-            else {
-                responseText = await agent.send(request, true);
-            }
+            responseText = await agent.send(request, true);
             this.finishStreamingFormatter(undefined, { refreshPrompt: false, mode: 'complete' });
             await this.awaitPendingCleanup();
             this.captureHistorySnapshot();
@@ -5914,24 +5899,14 @@ Execute the plan you outlined. Use the available tools (bash, edits, git) to tak
                 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 = orchestratorResult
-                ? orchestratorResult.passes.flatMap(pass => pass.toolsUsed)
-                : this.getExecutedTools(responseText);
+            const toolsUsed = this.getExecutedTools(responseText);
             this.currentToolCalls = toolsUsed.map(name => ({
                 name,
                 arguments: {},
                 success: true, // Assume success if we got here
                 duration: 0,
             }));
-            if (!orchestrate) {
-                autoFollowThrough = this.maybeAutoFollowThrough(request, responseText, toolsUsed);
-            }
-            if (orchestratorResult && orchestratorResult.exitReason !== 'complete') {
-                const exitDetail = orchestratorResult.exitReason === 'max-passes'
-                    ? 'Reached orchestrator pass limit; showing last response.'
-                    : 'Received empty replies while orchestrating; showing last response.';
-                display.showSystemMessage(`⚠️ ${exitDetail}`);
-            }
+            autoFollowThrough = this.maybeAutoFollowThrough(request, responseText, toolsUsed);
             // AlphaZero: Check for failure in response
             const failure = detectFailure(responseText, {
                 toolCalls: this.currentToolCalls,
@@ -5963,7 +5938,7 @@ Execute the plan you outlined. Use the available tools (bash, edits, git) to tak
             }
         }
         catch (error) {
-            const handled = this.handleProviderError(error, () => this.processRequest(request, options));
+            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);
@@ -6017,7 +5992,7 @@ Execute the plan you outlined. Use the available tools (bash, edits, git) to tak
      * Context is automatically managed - overflow errors trigger auto-recovery.
      */
     async processContinuousRequest(initialRequest) {
-        const MAX_PASSES = 100; // Safety limit to prevent truly infinite loops
+        const MAX_ITERATIONS = 100; // Safety limit to prevent truly infinite loops
         if (this.isProcessing) {
             this.enqueueFollowUpAction({ type: 'continuous', text: initialRequest });
             return;
@@ -6026,9 +6001,49 @@ Execute the plan you outlined. Use the available tools (bash, edits, git) to tak
             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
+        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.`);
-        const preparedRequest = this.isSelfImprovementRequest(initialRequest)
-            ? `${initialRequest}
+        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}
 
 IMPORTANT: You have full git access. After making improvements:
 1. Use bash to run: git status (see changes)
@@ -6037,9 +6052,124 @@ IMPORTANT: You have full git access. After making improvements:
 4. Use bash to run: git push (when milestone reached)
 
 Commit frequently with descriptive messages. Push when ready.
-When truly finished with ALL tasks, explicitly state "TASK_FULLY_COMPLETE".`
-            : initialRequest;
-        await this.processRequest(preparedRequest, { orchestrate: true, maxPasses: MAX_PASSES });
+When truly finished with ALL tasks, explicitly state "TASK_FULLY_COMPLETE".`;
+            }
+            while (iteration < MAX_ITERATIONS) {
+                iteration++;
+                this.toolsUsedThisRun = [];
+                display.showSystemMessage(`\n📍 Iteration ${iteration}/${MAX_ITERATIONS}`);
+                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);
+                    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()) {
+                        display.showWarning('Model returned an empty response. Retrying this iteration...');
+                        currentPrompt = `${initialRequest}
+
+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);
+                    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({
+                        iteration,
+                        response,
+                        toolsUsed,
+                        completionAnalysis,
+                        verificationConfirmed: this.flowOrchestrator.isVerificationPending()
+                            ? completionDetector.isVerificationConfirmed(response)
+                            : false,
+                    });
+                    if (decision.type === 'stop') {
+                        display.showSystemMessage(decision.message);
+                        break;
+                    }
+                    if (decision.type === 'stagnation-stop') {
+                        display.showWarning(decision.message);
+                        break;
+                    }
+                    if (decision.type === 'execute-plan') {
+                        display.showSystemMessage(decision.message);
+                        currentPrompt = decision.prompt;
+                        await new Promise(resolve => setTimeout(resolve, 500));
+                        continue;
+                    }
+                    if (decision.type === 'verify') {
+                        display.showSystemMessage(decision.message);
+                        currentPrompt = decision.prompt;
+                        await new Promise(resolve => setTimeout(resolve, 500));
+                        continue;
+                    }
+                    if (decision.type === 'continue') {
+                        if (decision.message) {
+                            display.showSystemMessage(decision.message);
+                        }
+                        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));
+                    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.`);
+            }
+        }
+        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
+            resetTaskCompletionDetector();
+            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);
+            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();
+        }
     }
     /**
      * Resolve executed tools for the current turn. Prefer the actual tool
@@ -6061,129 +6191,6 @@ When truly finished with ALL tasks, explicitly state "TASK_FULLY_COMPLETE".`
         }
         return this.extractToolsFromResponse(responseText);
     }
-    /**
-     * Detect plan-only responses that narrate intent without executing actions.
-     */
-    isPlanOnlyResponse(response) {
-        const normalized = response.trim().toLowerCase();
-        if (!normalized) {
-            return false;
-        }
-        // If the assistant is clearly declaring completion, don't treat it as plan-only
-        const completionGuards = [
-            /\bnothing\s+(left|else)\s+(to\s+do|pending)\b/i,
-            /\b(already|now)\s+(clean|complete|done)\b/i,
-            /\b(no\s+(junk|issues?|changes?)\s+found)\b/i,
-        ];
-        if (completionGuards.some((pattern) => pattern.test(response))) {
-            return false;
-        }
-        const planIndicators = [
-            /\bplan\b/i,
-            /\bapproach\b/i,
-            /\bsteps?:\b/i,
-            /\bstep\s+1\b/i,
-            /\bstart by\b/i,
-            /\bfirst[, ]/i,
-            /\bthen\b/i,
-            /\bnext\b/i,
-            /\bi['’]?\s*will\b/i,
-            /\bi['’]?\s*ll\b/i,
-            /\bi['’]?\s*can\b.{0,40}\bthen\b/i,
-            /\bi['’]?\s*(?:will|ll)\s+begin\b/i,
-        ];
-        return planIndicators.some((pattern) => pattern.test(response));
-    }
-    /**
-     * Check if a response contains indicators that work is actually incomplete,
-     * even if it also contains TASK_FULLY_COMPLETE marker.
-     * This catches contradictory responses where the AI says "done" but also "not integrated yet".
-     */
-    responseIndicatesIncompleteWork(response) {
-        // Patterns that indicate work isn't actually complete
-        // Organized by category for maintainability
-        const incompletePatterns = [
-            // === INTEGRATION/DEPLOYMENT STATE ===
-            // "hasn't been integrated/implemented/connected yet"
-            /hasn'?t\s+been\s+(integrated|implemented|connected|deployed|added|completed|tested|verified)\s*(yet|still)?/i,
-            // "not yet integrated/implemented" or "not integrated"
-            /not\s+(yet\s+)?(integrated|implemented|connected|deployed|functional|working|complete|tested|verified)/i,
-            // "ready for integration" = NOT integrated
-            /ready\s+(for|to\s+be)\s+(integration|integrated|connected|deployed|testing|review)/i,
-            // "needs to be integrated"
-            /needs?\s+to\s+be\s+(integrated|connected|deployed|added|hooked|wired|tested|reviewed|merged)/i,
-            // Passive voice: "was not performed/completed"
-            /was\s+not\s+(performed|completed|implemented|deployed|integrated|tested)/i,
-            // "the [X] service hasn't been"
-            /the\s+\w+\s+(service|module|component|feature)\s+hasn'?t\s+been/i,
-            // === PARTIAL/INCOMPLETE STATE ===
-            // "still stores/uses/has" (current bad state persists)
-            /still\s+(stores?|uses?|has|contains?|needs?|requires?|missing|lacks?|broken)/i,
-            // Partial completion: "partially", "mostly", "almost"
-            /\b(partially|mostly|almost|nearly|not\s+fully)\s+(complete|done|finished|implemented|working)/i,
-            // Explicit partial: "part of", "some of", "half of"
-            /\b(only\s+)?(part|some|half|portion)\s+of\s+(the\s+)?(task|work|feature|implementation)/i,
-            // === QUALIFIER WORDS (uncertain completion) ===
-            // "should be complete", "appears complete", "theoretically"
-            /\b(should|might|may|could|appears?\s+to)\s+be\s+(complete|done|working|functional)/i,
-            /\btheoretically\s+(complete|done|working|functional)/i,
-            // "assuming", "if everything works"
-            /\b(assuming|provided|if)\s+(everything|it|this|that)\s+(works?|is\s+correct)/i,
-            // === SELF-CONTRADICTION PHRASES ===
-            // "done but...", "complete except...", "finished however..."
-            /\b(done|complete|finished)\s+(but|except|however|although|though)/i,
-            // "however" followed by incomplete indicator
-            /however[,\s].{0,50}?(hasn'?t|not\s+yet|still\s+needs?|pending|remains?|missing|broken|failing)/i,
-            // "but" followed by negative state
-            /\bbut\s+.{0,30}?(not|hasn'?t|won'?t|can'?t|doesn'?t|isn'?t|wasn'?t)/i,
-            // === FUTURE TENSE / DEFERRED WORK ===
-            // "will need to", "will require"
-            /will\s+(need\s+to|require|have\s+to)\s+(integrate|connect|deploy|complete|implement|test|fix)/i,
-            // Deferred: "left as", "deferred", "postponed", "out of scope"
-            /\b(left\s+as|deferred|postponed|out\s+of\s+scope|for\s+later|in\s+a\s+future)/i,
-            // Time-dependent: "after restart", "takes effect after", "once you"
-            /\b(after\s+(restart|reboot|redeploy)|takes?\s+effect\s+after|once\s+you)/i,
-            // === REMAINING WORK INDICATORS ===
-            // "remaining tasks", "outstanding items"
-            /\b(remaining|outstanding|pending|leftover)\s+(tasks?|items?|work|issues?|steps?)/i,
-            // "X more to do", "still have to"
-            /\b(more\s+to\s+do|still\s+have\s+to|yet\s+to\s+be\s+done)/i,
-            // Explicit blockers
-            /\b(blocker|blocked\s+by|waiting\s+(for|on)|depends?\s+on)/i,
-            // === ERROR/FAILURE STATE ===
-            // "failing tests", "build errors"
-            /\b(failing|broken|erroring)\s+(tests?|builds?|checks?|validations?)/i,
-            // "tests? (are )?(still )?failing"
-            /\btests?\s+(are\s+)?(still\s+)?failing/i,
-            // "errors? to (address|fix)"
-            /\b(errors?|warnings?|issues?)\s+to\s+(address|fix|resolve)/i,
-            // "doesn't work", "isn't working", "not working"
-            /\b(doesn'?t|isn'?t|not)\s+(work|working|functional|functioning)/i,
-            // === MANUAL STEPS REQUIRED ===
-            // "you'll need to", "manually run", "requires user"
-            /\b(you('ll|\s+will)\s+need\s+to|manually\s+(run|configure|set|update)|requires?\s+user)/i,
-            // "run this command", "execute the following"
-            /\b(run\s+this|execute\s+the\s+following|apply\s+the\s+migration)/i,
-            // === TODO/FIXME IN PROSE ===
-            // TODO or FIXME mentioned as remaining work (not in code blocks)
-            /\b(todo|fixme|hack|xxx):\s/i,
-            // "need to add", "should implement"
-            /\b(need\s+to|should|must)\s+(add|implement|create|write|build|fix)\b/i,
-            // === SCOPE LIMITATIONS ===
-            // "didn't have time", "ran out of time"
-            /\b(didn'?t|did\s+not)\s+have\s+(time|chance|opportunity)/i,
-            // "beyond scope", "outside scope"
-            /\b(beyond|outside)\s+(the\s+)?scope/i,
-            // "for now" (temporary state)
-            /\b(for\s+now|at\s+this\s+point|currently)\s*.{0,20}?(not|without|lacks?|missing)/i,
-        ];
-        for (const pattern of incompletePatterns) {
-            if (pattern.test(response)) {
-                return true;
-            }
-        }
-        return false;
-    }
     /**
      * Extract tool names from a response by looking for tool call patterns
      */