erosolar-cli 1.7.383 → 1.7.385

package/dist/shell/interactiveShell.js

@@ -70,6 +70,9 @@ const PROVIDER_LABELS = Object.fromEntries(getProviders().map((provider) => [pro
 // Allow enough time for paste detection to kick in before flushing buffered lines
 const CONTEXT_USAGE_THRESHOLD = 0.9;
 const CONTEXT_AUTOCOMPACT_PERCENT = Math.round(CONTEXT_USAGE_THRESHOLD * 100);
+const CONTEXT_AUTOCOMPACT_FLOOR = 0.6;
+const MIN_COMPACTION_TOKEN_SAVINGS = 200;
+const MIN_COMPACTION_PERCENT_SAVINGS = 0.5;
 const CONTEXT_RECENT_MESSAGE_COUNT = 12;
 const CONTEXT_CLEANUP_CHARS_PER_CHUNK = 6000;
 const CONTEXT_CLEANUP_MAX_OUTPUT_TOKENS = 800;
@@ -116,6 +119,9 @@ export class InteractiveShell {
     isDrainingQueue = false;
     activeContextWindowTokens = null;
     latestTokenUsage = { used: null, limit: null };
+    planApprovalBridgeRegistered = false;
+    contextCompactionInFlight = false;
+    lastContextWarningLevel = null;
     sessionPreferences;
     autosaveEnabled;
     autoContinueEnabled;
@@ -255,6 +261,11 @@ export class InteractiveShell {
         this.refreshContextGauge();
         // Start terminal input (sets up handlers)
         this.terminalInput.start();
+        // Allow planning tools (e.g., ProposePlan) to open the interactive approval UI just like Codex CLI
+        this.registerPlanApprovalBridge();
+        // Capture display output into the scrollback/chat log so system messages
+        // (e.g., /evolve) render above the pinned chat box.
+        this.terminalInput.registerOutputInterceptor(display);
         // Set up command autocomplete with all slash commands
         this.setupCommandAutocomplete();
         // Enter alternate screen buffer when enabled, otherwise clear the main screen for layout
@@ -505,15 +516,9 @@ export class InteractiveShell {
         this.editGuardMode = mode;
         this.pendingPermissionInput = null;
         if (mode === 'plan') {
-            // Register plan approval callback for interactive UI
-            setPlanApprovalCallback((steps, explanation) => {
-                this.showPlanApproval(steps, explanation);
-            });
             display.showSystemMessage('📋 Plan mode enabled. AI will create a plan and ask for approval before implementing.');
         }
         else {
-            // Unregister callback when not in plan mode
-            setPlanApprovalCallback(null);
             if (mode === 'ask-permission') {
                 display.showSystemMessage('🛡️ Ask-to-edit mode enabled. Confirm each request before sending.');
             }
@@ -729,6 +734,8 @@ export class InteractiveShell {
         if (this.alternateScreenEnabled) {
             this.terminalInput.exitAlternateScreen();
         }
+        // Unregister plan approval bridge
+        setPlanApprovalCallback(null);
         // Dispose terminal input handler
         this.terminalInput.dispose();
         // Dispose unified UI adapter
@@ -752,6 +759,18 @@ export class InteractiveShell {
         // Write directly to stdout after exiting alternate screen to preserve the transcript
         process.stdout.write(`\n${separator}\n${header}\n${transcript}\n${separator}\n`);
     }
+    /**
+     * Wire the planning tool suite to the interactive plan approval UI so ProposePlan behaves like Codex CLI.
+     */
+    registerPlanApprovalBridge() {
+        if (this.planApprovalBridgeRegistered) {
+            return;
+        }
+        setPlanApprovalCallback((steps, explanation) => {
+            this.showPlanApproval(steps, explanation);
+        });
+        this.planApprovalBridgeRegistered = true;
+    }
     /**
      * Update status bar message
      */
@@ -1105,9 +1124,9 @@ export class InteractiveShell {
             };
         }
     }
-    updateContextUsage(percentage) {
+    updateContextUsage(percentage, autoCompactThreshold = CONTEXT_AUTOCOMPACT_PERCENT) {
         this.uiAdapter.updateContextUsage(percentage);
-        this.terminalInput.setContextUsage(percentage, CONTEXT_AUTOCOMPACT_PERCENT);
+        this.terminalInput.setContextUsage(percentage, autoCompactThreshold);
     }
     refreshControlBar() {
         this.terminalInput.setModeToggles({
@@ -1190,10 +1209,6 @@ export class InteractiveShell {
         if (state.detail) {
             parts.push(state.detail);
         }
-        const elapsedSeconds = Math.max(0, Math.floor((Date.now() - state.startedAt) / 1000));
-        if (elapsedSeconds > 0) {
-            parts.push(`${elapsedSeconds}s`);
-        }
         return parts.join(' • ');
     }
     handleSlashCommandPreviewChange() {
@@ -1324,20 +1339,11 @@ export class InteractiveShell {
         // Force refresh to update the input area now that streaming has ended
         this.refreshStatusLine(true);
     }
-    buildStreamingStatus(label, elapsedSeconds) {
-        const detail = this.describeModelDetail();
-        const elapsedLabel = typeof elapsedSeconds === 'number' && elapsedSeconds >= 0
-            ? theme.ui.muted(this.formatElapsedShort(elapsedSeconds))
-            : null;
+    buildStreamingStatus(label, _elapsedSeconds) {
+        // Model + elapsed time already live in the pinned meta header; keep the streaming
+        // status focused on the activity to avoid duplicate info.
         const prefix = theme.info('⏺');
-        const parts = [label];
-        if (detail) {
-            parts.push(theme.ui.muted('·'), detail);
-        }
-        if (elapsedLabel) {
-            parts.push(theme.ui.muted('·'), elapsedLabel);
-        }
-        return `${prefix} ${parts.join(' ')}`.trim();
+        return `${prefix} ${label}`.trim();
     }
     formatElapsedShort(seconds) {
         if (seconds < 60) {
@@ -5304,15 +5310,17 @@ What's the next action?`;
         };
         // Always update context usage in the UI
         const percentUsed = Math.round(usageRatio * 100);
-        this.updateContextUsage(percentUsed);
+        this.updateContextUsage(percentUsed, CONTEXT_AUTOCOMPACT_PERCENT);
+        this.maybeShowContextWarning(percentUsed);
         this.refreshStatusLine(true);
-        if (usageRatio < CONTEXT_USAGE_THRESHOLD) {
+        if (!this.agent || this.cleanupInProgress || this.contextCompactionInFlight) {
             return null;
         }
-        if (!this.agent || this.cleanupInProgress) {
+        const trigger = this.shouldAutoCompactContext(usageRatio, windowTokens, total);
+        if (!trigger) {
             return null;
         }
-        return this.runContextCleanup(windowTokens, total);
+        return this.runContextCleanup(windowTokens, total, trigger);
     }
     totalTokens(usage) {
         if (!usage) {
@@ -5326,51 +5334,203 @@ What's the next action?`;
         const sum = input + output;
         return sum > 0 ? sum : null;
     }
-    async runContextCleanup(windowTokens, totalTokens) {
-        if (!this.agent) {
+    async runContextCleanup(windowTokens, totalTokens, trigger) {
+        const agent = this.agent;
+        if (!agent) {
+            return;
+        }
+        const contextManager = agent.getContextManager();
+        if (!contextManager) {
+            return;
+        }
+        const history = agent.getHistory();
+        if (history.length <= 1) {
             return;
         }
         this.cleanupInProgress = true;
+        this.contextCompactionInFlight = true;
         const cleanupStatusId = 'context-cleanup';
         let cleanupOverlayActive = false;
         try {
-            const history = this.agent.getHistory();
-            const { system, conversation } = this.partitionHistory(history);
-            if (!conversation.length) {
-                return;
-            }
-            const preserveCount = Math.min(conversation.length, CONTEXT_RECENT_MESSAGE_COUNT);
-            const preserved = conversation.slice(conversation.length - preserveCount);
-            const toSummarize = conversation.slice(0, conversation.length - preserveCount);
-            if (!toSummarize.length) {
-                return;
+            const percentUsed = Math.round((totalTokens / windowTokens) * 100);
+            const statusDetailParts = [`${percentUsed}% full`];
+            if (trigger?.reason) {
+                statusDetailParts.push(trigger.reason);
             }
-            cleanupOverlayActive = true;
             this.statusTracker.pushOverride(cleanupStatusId, 'Running context cleanup', {
-                detail: `Summarizing ${toSummarize.length} earlier messages`,
+                detail: statusDetailParts.join(' · '),
                 tone: 'warning',
             });
-            const percentUsed = Math.round((totalTokens / windowTokens) * 100);
-            // Update context usage in unified UI
-            this.updateContextUsage(percentUsed);
+            cleanupOverlayActive = true;
+            const triggerReason = trigger?.reason ?? 'Context optimization';
             display.showSystemMessage([
                 `Context usage: ${totalTokens.toLocaleString('en-US')} of ${windowTokens.toLocaleString('en-US')} tokens`,
-                `(${percentUsed}% full). Running automatic cleanup...`,
+                `(${percentUsed}% full). Auto-compacting${triggerReason ? `: ${triggerReason}` : '...'}`,
             ].join(' '));
-            const summary = await this.buildContextSummary(toSummarize);
-            if (!summary) {
-                throw new Error('Summary could not be generated.');
+            const beforeStats = contextManager.getStats(history);
+            const result = await contextManager.intelligentCompact(history);
+            const afterStats = contextManager.getStats(result.compacted);
+            const tokenSavings = Math.max(0, beforeStats.totalTokens - afterStats.totalTokens);
+            const percentSavings = beforeStats.totalTokens > 0 ? (tokenSavings / beforeStats.totalTokens) * 100 : 0;
+            const changed = this.historiesDiffer(history, result.compacted);
+            const meaningfulSavings = changed &&
+                (tokenSavings >= MIN_COMPACTION_TOKEN_SAVINGS || percentSavings >= MIN_COMPACTION_PERCENT_SAVINGS);
+            if (!meaningfulSavings) {
+                if (trigger?.forced || percentUsed >= 85) {
+                    display.showInfo('Auto-compaction completed but did not meaningfully reduce context size. Keeping existing history.');
+                }
+                return;
             }
-            const trimmed = this.buildTrimmedHistory(system, summary, preserved);
-            this.agent.loadHistory(trimmed);
-            display.showSystemMessage(`Context cleanup complete. Summarized ${toSummarize.length} earlier messages and preserved the latest ${preserved.length}.`);
+            agent.loadHistory(result.compacted);
+            this.cachedHistory = result.compacted;
+            const newPercentUsed = windowTokens > 0
+                ? Math.round((afterStats.totalTokens / windowTokens) * 100)
+                : afterStats.percentage;
+            this.latestTokenUsage = {
+                used: afterStats.totalTokens,
+                limit: windowTokens,
+            };
+            this.updateContextUsage(newPercentUsed, CONTEXT_AUTOCOMPACT_PERCENT);
+            this.lastContextWarningLevel = this.getContextWarningLevel(newPercentUsed);
+            this.refreshStatusLine(true);
+            const primarySignal = result.analysis.signals[0]?.reason ?? triggerReason;
+            display.showSystemMessage([
+                `Context compacted: ${beforeStats.percentage}% → ${afterStats.percentage}%`,
+                `(saved ~${tokenSavings.toLocaleString('en-US')} tokens).`,
+                primarySignal ? `Reason: ${primarySignal}.` : '',
+            ].filter(Boolean).join(' '));
+        }
+        catch (error) {
+            display.showError('Context compaction failed.', error);
         }
         finally {
             if (cleanupOverlayActive) {
                 this.statusTracker.clearOverride(cleanupStatusId);
             }
             this.cleanupInProgress = false;
+            this.contextCompactionInFlight = false;
+        }
+    }
+    shouldAutoCompactContext(usageRatio, windowTokens, totalTokens) {
+        const featureFlags = loadFeatureFlags();
+        if (featureFlags.autoCompact === false) {
+            return null;
+        }
+        const agent = this.agent;
+        if (!agent) {
+            return null;
+        }
+        const contextManager = agent.getContextManager();
+        if (!contextManager) {
+            return null;
+        }
+        const history = agent.getHistory();
+        if (history.length <= 1) {
+            return null;
         }
+        const percentUsed = Math.round(usageRatio * 100);
+        const analysis = contextManager.shouldTriggerCompaction(history);
+        const overflowRisk = this.hasContextOverflowRisk(contextManager);
+        if (usageRatio >= CONTEXT_USAGE_THRESHOLD) {
+            return { reason: analysis.reason ?? `Context usage at ${percentUsed}%`, forced: true };
+        }
+        if (usageRatio >= CONTEXT_AUTOCOMPACT_FLOOR && (analysis.shouldCompact || overflowRisk)) {
+            const reason = analysis.reason
+                ?? (overflowRisk ? 'Heavy tool output detected' : 'Compaction signals detected');
+            return { reason, forced: false };
+        }
+        return null;
+    }
+    hasContextOverflowRisk(contextManager) {
+        if (!contextManager?.detectContextOverflowRisk) {
+            return false;
+        }
+        try {
+            const toolHistory = this.runtimeSession.toolRuntime.getToolHistory?.();
+            if (!toolHistory?.length) {
+                return false;
+            }
+            const serialized = toolHistory.map((entry) => {
+                const args = entry.args ?? {};
+                const argsText = Object.keys(args).length ? ` ${JSON.stringify(args)}` : '';
+                return `${entry.toolName}${argsText}`;
+            });
+            return contextManager.detectContextOverflowRisk(serialized);
+        }
+        catch {
+            return false;
+        }
+    }
+    getContextWarningLevel(percentage) {
+        if (percentage >= 90) {
+            return 'danger';
+        }
+        if (percentage >= 70) {
+            return 'warning';
+        }
+        if (percentage >= 50) {
+            return 'info';
+        }
+        return null;
+    }
+    maybeShowContextWarning(percentage) {
+        const level = this.getContextWarningLevel(percentage);
+        if (level === this.lastContextWarningLevel) {
+            if (level === null) {
+                this.lastContextWarningLevel = null;
+            }
+            return;
+        }
+        this.lastContextWarningLevel = level;
+        switch (level) {
+            case 'info':
+                display.showInfo('Context usage is climbing. Auto-compaction will engage if it keeps growing.');
+                break;
+            case 'warning':
+                display.showWarning('Context is getting full. Auto-compaction will try to preserve space.');
+                break;
+            case 'danger':
+                display.showWarning('Context is near capacity. Attempting automatic compaction.');
+                break;
+            default:
+                break;
+        }
+    }
+    historiesDiffer(original, compacted) {
+        if (original.length !== compacted.length) {
+            return true;
+        }
+        for (let i = 0; i < original.length; i++) {
+            const a = original[i];
+            const b = compacted[i];
+            if (a.role !== b.role) {
+                return true;
+            }
+            if ((a.content ?? '') !== (b.content ?? '')) {
+                return true;
+            }
+            const aName = 'name' in a ? a.name : undefined;
+            const bName = 'name' in b ? b.name : undefined;
+            if ((aName ?? '') !== (bName ?? '')) {
+                return true;
+            }
+            const aToolCallId = 'toolCallId' in a ? a.toolCallId : undefined;
+            const bToolCallId = 'toolCallId' in b ? b.toolCallId : undefined;
+            if ((aToolCallId ?? '') !== (bToolCallId ?? '')) {
+                return true;
+            }
+            const aTools = 'toolCalls' in a ? a.toolCalls ?? [] : [];
+            const bTools = 'toolCalls' in b ? b.toolCalls ?? [] : [];
+            if (aTools.length !== bTools.length) {
+                return true;
+            }
+            for (let j = 0; j < aTools.length; j++) {
+                if (JSON.stringify(aTools[j]) !== JSON.stringify(bTools[j])) {
+                    return true;
+                }
+            }
+        }
+        return false;
     }
     partitionHistory(history) {
         const system = [];