erosolar-cli 2.1.168 → 2.1.169

package/dist/ui/ShellUIAdapter.js

@@ -13,15 +13,13 @@ import { InterruptPriority } from './interrupts/InterruptManager.js';
 import { getTerminalColumns } from './layout.js';
 import { theme, icons } from './theme.js';
 import { UIUpdateCoordinator } from './orchestration/UIUpdateCoordinator.js';
-import { formatRichContent } from './richText.js';
 export class ShellUIAdapter {
     uiController;
     display;
     config;
-    isProcessing = false;
-    contextUsage = 0;
     fileChangeCallback;
     _toolStatusCallback;
+    _activityCallback;
     profileSwitcherTimeout;
     updateCoordinator;
     // Track tool operations for compact rendering
@@ -38,6 +36,16 @@ export class ShellUIAdapter {
     activeToolStatus = null;
     activeToolHeartbeatId = null;
     statusSpinnerIndex = 0;
+    // Store last tool result for expansion with ctrl+o
+    lastToolResult = null;
+    // Scrolling output buffer - shows only the last N lines of tool output in-place
+    maxScrollingLines = 3;
+    scrollingOutputBuffer = new Map();
+    scrollingPanelOwner = null;
+    // Scrolling tool call display - shows only the last N tool calls, scrolling older ones up
+    maxVisibleToolCalls = 3;
+    recentToolCalls = [];
+    toolCallDisplayedCount = 0;
     constructor(writeStream, display, config = {}, updateCoordinator) {
         this.display = display;
         this.config = {
@@ -138,6 +146,12 @@ export class ShellUIAdapter {
                 else {
                     this.logToolProgress(call, progress);
                 }
+                // Update activity line with streaming output from bash commands
+                if (this._activityCallback && progress.message) {
+                    // Show the streaming line as the activity (e.g., npm install progress)
+                    const activityText = progress.message.slice(0, 60);
+                    this._activityCallback(activityText);
+                }
                 // Update status bar with progress - use in-place update for supported terminals
                 if (this._toolStatusCallback) {
                     const description = this.getToolActionDescription(call, progress);
@@ -167,12 +181,10 @@ export class ShellUIAdapter {
                 const now = Date.now();
                 // Complete the operation tracking
                 const op = this.pendingOperations.get(call.id);
-                let durationMs;
                 if (op) {
                     op.status = 'success';
                     op.completedAt = now;
                     op.summary = this.extractResultSummary(call, output);
-                    durationMs = op.startedAt ? Math.max(0, now - op.startedAt) : undefined;
                     this.pendingOperations.delete(call.id);
                     this.completedOperations.push(op);
                     // Keep only recent completed operations
@@ -191,19 +203,22 @@ export class ShellUIAdapter {
                         this.fileChangeCallback(fileChange.path, fileChange.type, fileChange.additions, fileChange.removals);
                     }
                 }
-                const renderedRich = this.maybeRenderRichToolResult(call, output, true, durationMs);
-                // Use compact display for quick single-result tools and structured edit output
-                if (!renderedRich) {
-                    if (call.name === 'Edit' || call.name === 'edit_file') {
-                        this.displayEditResult(call, output, true);
-                    }
-                    else if (this.compactDisplayMode && this.isCompactTool(call.name)) {
-                        this.displayCompactResult(call, output, true);
-                    }
-                    else {
-                        // Erosolar-CLI style: Display tool result with ⎿ prefix
-                        this.displayToolResultSummary(call, output, true);
-                    }
+                // Store result for expansion with ctrl+o
+                this.lastToolResult = {
+                    toolName: call.name,
+                    output,
+                    timestamp: Date.now(),
+                };
+                // Claude Code style: compact display for all tools
+                if (call.name === 'Edit' || call.name === 'edit_file') {
+                    this.displayEditResult(call, output, true);
+                }
+                else if (this.compactDisplayMode && this.isCompactTool(call.name)) {
+                    this.displayCompactResult(call, output, true);
+                }
+                else {
+                    // Display tool result with ⎿ prefix
+                    this.displayToolResultSummary(call, output, true);
                 }
                 // Surface any captured preflight warnings in a structured block
                 this.flushToolWarnings(call.id, call.name);
@@ -217,12 +232,10 @@ export class ShellUIAdapter {
             onToolError: (call, message) => {
                 // Complete the operation tracking with error
                 const op = this.pendingOperations.get(call.id);
-                let durationMs;
                 if (op) {
                     op.status = 'error';
                     op.completedAt = Date.now();
                     op.summary = message;
-                    durationMs = op.startedAt ? Math.max(0, (op.completedAt ?? Date.now()) - op.startedAt) : undefined;
                     this.pendingOperations.delete(call.id);
                     this.completedOperations.push(op);
                 }
@@ -230,19 +243,16 @@ export class ShellUIAdapter {
                     this.logExploreCompletion(call.id, false);
                 }
                 this.clearToolState(call.id);
-                const renderedRich = this.maybeRenderRichToolResult(call, message, false, durationMs);
-                // Use compact display for errors too
-                if (!renderedRich) {
-                    if (call.name === 'Edit' || call.name === 'edit_file') {
-                        this.displayEditResult(call, message, false);
-                    }
-                    else if (this.compactDisplayMode && this.isCompactTool(call.name)) {
-                        this.displayCompactResult(call, message, false);
-                    }
-                    else {
-                        // Erosolar-CLI style: Display error with ⎿ prefix (error color)
-                        this.displayToolResultSummary(call, message, false);
-                    }
+                // Claude Code style: compact display for errors too
+                if (call.name === 'Edit' || call.name === 'edit_file') {
+                    this.displayEditResult(call, message, false);
+                }
+                else if (this.compactDisplayMode && this.isCompactTool(call.name)) {
+                    this.displayCompactResult(call, message, false);
+                }
+                else {
+                    // Display error with ⎿ prefix (error color)
+                    this.displayToolResultSummary(call, message, false);
                 }
                 this.flushToolWarnings(call.id, call.name);
                 // Clear status bar after showing error
@@ -310,17 +320,27 @@ export class ShellUIAdapter {
      * Shows the top two tools and how many more were used.
      */
     showToolUsageSummary() {
+        // Compute summary for metadata but don't display it
+        // The tool calls are already visible in the conversation flow
         this.lastToolUsageSummary = this.formatToolUsageSummary();
         this.lastToolUsageSummaryPlain = this.formatToolUsageSummary({ plain: true });
-        const summary = this.lastToolUsageSummary;
-        if (!summary) {
-            return;
-        }
-        this.display.stream(`\n${summary}\n`);
+        // Don't stream the summary - it's redundant after the assistant response
     }
     getToolUsageSummary(options = {}) {
         return options.plain ? this.lastToolUsageSummaryPlain : this.lastToolUsageSummary;
     }
+    /**
+     * Get the last tool result for expansion with ctrl+o
+     */
+    getLastToolResult() {
+        return this.lastToolResult;
+    }
+    /**
+     * Clear the stored tool result (e.g., after expansion)
+     */
+    clearLastToolResult() {
+        this.lastToolResult = null;
+    }
     formatToolUsageSummary(options = {}) {
         const plain = options.plain === true;
         if (this.toolUsageCounts.size === 0) {
@@ -439,7 +459,6 @@ export class ShellUIAdapter {
             case 'Write':
             case 'write_file': {
                 const path = this.extractPath(args, ['file_path', 'path']);
-                const lines = this.countLines(output);
                 return path ? `${this.truncatePath(path, 40)} written` : 'file written';
             }
             case 'Edit':
@@ -504,8 +523,8 @@ export class ShellUIAdapter {
             return;
         }
         const prefix = success ? theme.success(icons.subaction) : theme.error(icons.subaction);
-        const toolLabel = theme.tool(call.name);
-        this.display.stream(`  ${prefix}  ${toolLabel} ${summary}\n\n`);
+        // Just show the result summary - tool name was already shown on the call line
+        this.display.stream(`  ${prefix}  ${summary}\n`);
     }
     /**
      * Display edit results with full colored diff output.
@@ -523,12 +542,10 @@ export class ShellUIAdapter {
         if (success) {
             const diffSection = this.extractEditDiffSection(output);
             if (diffSection) {
-                this.display.stream(`${diffSection}\n\n`);
-                return;
+                // Show diff with single trailing newline
+                this.display.stream(`${diffSection}\n`);
             }
         }
-        // Add spacing when no diff section is available
-        this.display.stream('\n');
     }
     logToolProgress(call, progress) {
         const description = this.getToolActionDescription(call, progress);
@@ -551,12 +568,97 @@ export class ShellUIAdapter {
         }
         const separator = theme.ui.muted(' — ');
         const line = parts.filter(Boolean).join(separator);
-        const last = this.toolProgressSnapshots.get(call.id);
-        if (line && line !== last) {
-            // Single trailing newline - no leading newline to avoid gaps
-            this.display.stream(`${line}\n`);
-            this.toolProgressSnapshots.set(call.id, line);
+        if (!line)
+            return;
+        // Use scrolling output for ALL tools on TTY - show only last N lines, updating in place
+        // This prevents flooding the terminal with hundreds of progress lines
+        if (process.stdout.isTTY) {
+            this.appendScrollingOutput(call.id, line);
+        }
+        else {
+            // Non-TTY: original streaming behavior (for log files, pipes, etc.)
+            const last = this.toolProgressSnapshots.get(call.id);
+            if (line !== last) {
+                this.display.stream(`${line}\n`);
+                this.toolProgressSnapshots.set(call.id, line);
+            }
+        }
+    }
+    /**
+     * Append a line to scrolling output buffer and update display in-place
+     * Shows only the last maxScrollingLines, replacing previous output
+     */
+    appendScrollingOutput(callId, line) {
+        let buffer = this.scrollingOutputBuffer.get(callId);
+        if (!buffer) {
+            buffer = { lines: [], displayedLineCount: 0 };
+            this.scrollingOutputBuffer.set(callId, buffer);
         }
+        // Add line to buffer
+        buffer.lines.push(line);
+        // Keep only the last maxScrollingLines
+        while (buffer.lines.length > this.maxScrollingLines) {
+            buffer.lines.shift();
+        }
+        // Prefer inline panel (scroll box) when unified renderer is active
+        if (this.shouldUseInlineScrollBox()) {
+            this.scrollingPanelOwner = callId;
+            const panelLines = this.buildScrollingPanelLines(buffer.lines);
+            this.display.showInlinePanel(panelLines);
+            buffer.displayedLineCount = 0;
+            return;
+        }
+        // Move cursor up to overwrite previous lines (if any were displayed)
+        if (buffer.displayedLineCount > 0) {
+            process.stdout.write(`\x1b[${buffer.displayedLineCount}A`);
+        }
+        // Clear and rewrite the scrolling region
+        const linesToShow = buffer.lines;
+        for (let i = 0; i < linesToShow.length; i++) {
+            process.stdout.write(`\r\x1b[K${linesToShow[i]}\n`);
+        }
+        // Track how many lines we displayed for next update
+        buffer.displayedLineCount = linesToShow.length;
+    }
+    /**
+     * Build the pinned scroll-box contents for live tool output.
+     */
+    buildScrollingPanelLines(lines) {
+        if (!lines.length) {
+            return [];
+        }
+        const header = theme.ui.muted(`${icons.action} live output (latest ${Math.min(lines.length, this.maxScrollingLines)})`);
+        const indented = lines.map(text => `  ${text}`);
+        return [header, ...indented];
+    }
+    /**
+     * Use inline scroll box only when an interactive renderer is active.
+     */
+    shouldUseInlineScrollBox() {
+        return this.display.hasRenderer() && process.stdout.isTTY && !process.env['CI'];
+    }
+    /**
+     * Finalize scrolling output - called when tool completes
+     * Clears the scrolling progress lines so only the final result is shown
+     */
+    finalizeScrollingOutput(callId) {
+        if (this.scrollingPanelOwner === callId && this.shouldUseInlineScrollBox()) {
+            this.display.clearInlinePanel();
+            this.scrollingPanelOwner = null;
+            this.scrollingOutputBuffer.delete(callId);
+            return;
+        }
+        const buffer = this.scrollingOutputBuffer.get(callId);
+        if (buffer && buffer.displayedLineCount > 0 && process.stdout.isTTY) {
+            // Move cursor up and clear all the progress lines
+            process.stdout.write(`\x1b[${buffer.displayedLineCount}A`);
+            for (let i = 0; i < buffer.displayedLineCount; i++) {
+                process.stdout.write(`\r\x1b[K\n`);
+            }
+            // Move cursor back up to where progress started
+            process.stdout.write(`\x1b[${buffer.displayedLineCount}A`);
+        }
+        this.scrollingOutputBuffer.delete(callId);
     }
     logExploreProgress(call, progress) {
         const previous = this.exploreProgressState.get(call.id) ?? { lastCurrent: 0 };
@@ -570,8 +672,14 @@ export class ShellUIAdapter {
         }
         const line = parts.join(theme.ui.muted(' • '));
         if (line && line !== previous.lastLine) {
-            // Single trailing newline - no leading newline to avoid gaps
-            this.display.stream(`${line}\n`);
+            // Use in-place update for TTY - single line that updates without scrolling
+            if (process.stdout.isTTY && previous.lastLine) {
+                // Move cursor up one line and clear it, then write new line
+                process.stdout.write(`\x1b[1A\r\x1b[K${line}\n`);
+            }
+            else {
+                this.display.stream(`${line}\n`);
+            }
         }
         this.exploreProgressState.set(call.id, {
             total,
@@ -585,6 +693,10 @@ export class ShellUIAdapter {
         const summary = success
             ? `${theme.success('✓')} Indexed ${total} file${total === 1 ? '' : 's'}`
             : `${theme.error('✗')} Explore interrupted`;
+        // Clear the progress line before showing summary (if TTY and had progress)
+        if (process.stdout.isTTY && state?.lastLine) {
+            process.stdout.write(`\x1b[1A\r\x1b[K`);
+        }
         this.display.stream(`${summary}\n`);
     }
     /**
@@ -594,12 +706,13 @@ export class ShellUIAdapter {
     clearToolState(callId) {
         this.toolProgressSnapshots.delete(callId);
         this.exploreProgressState.delete(callId);
+        this.finalizeScrollingOutput(callId);
     }
     /**
      * Display tool call start with Erosolar-CLI style prefix
      * - ✢ for Task/agent tools (active task indicator)
      * - ⏺ for other tools
-     * Routes through display module to work with scroll regions
+     * Uses scrolling display to show only the last N tool calls
      */
     displayToolCallStart(call, isCacheHit = false) {
         const args = call.arguments || {};
@@ -622,8 +735,41 @@ export class ShellUIAdapter {
         }
         // Erosolar-CLI style: bullet + optional task marker + ToolName(args)
         const line = `${bullet}${taskMarker ? taskMarker : ''} ${displayName}${argsStr}${cacheHint}`;
-        // Stream with spacing to keep it as a distinct event
-        this.display.stream(`\n${line}\n`);
+        // Use scrolling display for tool calls - shows only recent calls
+        this.appendToolCallDisplay(call.id, line);
+    }
+    /**
+     * Append a tool call to the scrolling display, keeping only the last N visible.
+     * Older tool calls scroll up and disappear, showing only recent activity.
+     */
+    appendToolCallDisplay(callId, line) {
+        // Add to recent tool calls
+        this.recentToolCalls.push({ line, id: callId });
+        // Keep only the last maxVisibleToolCalls
+        while (this.recentToolCalls.length > this.maxVisibleToolCalls) {
+            this.recentToolCalls.shift();
+        }
+        // On TTY, use in-place updating to show only recent tool calls
+        if (process.stdout.isTTY && this.toolCallDisplayedCount > 0) {
+            // Move cursor up to overwrite previous tool call lines
+            const moveUp = `\x1b[${this.toolCallDisplayedCount}A`;
+            // Clear from cursor to end of screen
+            const clearDown = '\x1b[J';
+            process.stdout.write(moveUp + clearDown);
+        }
+        // Display all recent tool calls
+        for (const toolCall of this.recentToolCalls) {
+            this.display.stream(`${toolCall.line}\n`);
+        }
+        // Track how many lines we displayed
+        this.toolCallDisplayedCount = this.recentToolCalls.length;
+    }
+    /**
+     * Clear tool call display state when processing completes
+     */
+    clearToolCallDisplay() {
+        this.recentToolCalls = [];
+        this.toolCallDisplayedCount = 0;
     }
     /**
      * Format tool arguments inline for display (Erosolar-CLI style)
@@ -772,8 +918,8 @@ export class ShellUIAdapter {
      * Start processing a request
      */
     startProcessing(message = 'Working on your request') {
-        this.isProcessing = true;
         this.resetToolUsageSummary();
+        this.clearToolCallDisplay(); // Clear previous tool call display
         this.uiController.startProcessing();
         this.uiController.setBaseStatus(message, 'info');
     }
@@ -781,20 +927,17 @@ export class ShellUIAdapter {
      * End processing
      */
     endProcessing(message = 'Ready for prompts') {
-        this.isProcessing = false;
         this.uiController.endProcessing();
         this.showToolUsageSummary();
         this.uiController.setBaseStatus(message, 'success');
+        // Clear tool call scrolling state for next request
+        this.clearToolCallDisplay();
     }
     /**
-     * Update context usage
-     * NOTE: This only tracks the value internally. The actual context display
-     * is handled by display.showStatusLine() which shows "Session Xm • Context Y% used • Ready"
-     * We don't push a status override here to avoid duplicate context lines.
+     * Update context usage (no-op - status handled by display.showStatusLine)
      */
-    updateContextUsage(percentage) {
-        this.contextUsage = percentage;
-        // Status updates are internal; avoid forcing overlay rerender
+    updateContextUsage(_percentage) {
+        // No-op - context display is handled by display.showStatusLine()
     }
     /**
      * Show a user interrupt
@@ -814,7 +957,7 @@ export class ShellUIAdapter {
     /**
      * Show profile switcher (Shift+Tab)
      */
-    showProfileSwitcher(profiles, currentProfile) {
+    showProfileSwitcher(profiles, _currentProfile) {
         this.updateCoordinator.enqueue({
             lane: 'overlay',
             description: 'profile-switcher',
@@ -1026,6 +1169,12 @@ export class ShellUIAdapter {
             callback(this.buildRunningStatusLine(this.activeToolStatus.description, this.activeToolStatus.startedAt));
         }
     }
+    /**
+     * Set activity callback - called during tool progress to update activity line with streaming output
+     */
+    setActivityCallback(callback) {
+        this._activityCallback = callback;
+    }
     /**
      * Keep a live status line ticking while an SSE tool or long-running tool is active.
      * Uses a heartbeat to animate the spinner and update elapsed time without spamming writes.
@@ -1146,79 +1295,10 @@ export class ShellUIAdapter {
             const prefix = success
                 ? theme.success(icons.subaction)
                 : theme.error(icons.subaction);
-            // Add newline after result for visual separation
-            this.display.stream(`  ${prefix}  ${summary}\n\n`);
+            // Single newline - next tool call adds its own spacing
+            this.display.stream(`  ${prefix}  ${summary}\n`);
         }
     }
-    /**
-     * Render a rich block for non-streamed SSE-style tool results so they feel like a "completed event".
-     * Returns true if a block was rendered and downstream compact formatting should be skipped.
-     */
-    maybeRenderRichToolResult(call, output, success, durationMs) {
-        if (!this.shouldRenderRichToolBlock(call, output)) {
-            return false;
-        }
-        const block = this.renderRichToolBlock(call, output, success, durationMs);
-        if (!block.trim()) {
-            return false;
-        }
-        this.display.stream(`\n${block}\n\n`);
-        return true;
-    }
-    shouldRenderRichToolBlock(call, output) {
-        const trimmed = output?.trim() ?? '';
-        if (!trimmed)
-            return false;
-        // Skip tools that already have bespoke rendering
-        if (call.name === 'Edit' || call.name === 'edit_file' || call.name === 'list_files') {
-            return false;
-        }
-        // Read operations should stay compact (single-line summary), not boxed
-        if (call.name === 'Read' || call.name === 'read_file') {
-            return false;
-        }
-        const isMcpTool = call.name.startsWith('mcp__');
-        const isMultiline = trimmed.includes('\n');
-        const isLong = trimmed.length > 160;
-        return isMcpTool || isMultiline || isLong;
-    }
-    renderRichToolBlock(call, output, success, durationMs) {
-        const columns = Math.max(60, Math.min(getTerminalColumns(), 120));
-        const innerWidth = Math.max(40, columns - 4);
-        const statusIcon = success ? theme.success(icons.success) : theme.error(icons.error);
-        const labels = [
-            `${statusIcon} ${theme.tool(call.name)}`,
-            call.name.startsWith('mcp__') ? theme.ui.muted('SSE result') : theme.ui.muted('Tool result'),
-        ];
-        const elapsed = this.formatElapsedMs(durationMs);
-        if (elapsed) {
-            labels.push(`${theme.metrics.elapsedLabel('elapsed')} ${theme.metrics.elapsedValue(elapsed)}`);
-        }
-        const title = labels.filter(Boolean).join(theme.ui.muted(' • '));
-        const titlePadding = Math.max(0, innerWidth - this.visibleLength(title) - 2);
-        const top = theme.ui.muted(`╭─ ${title} ${'─'.repeat(titlePadding)}╮`);
-        const bottom = theme.ui.muted(`╰${'─'.repeat(innerWidth + 2)}╯`);
-        const bodyLines = formatRichContent(output.trim(), innerWidth);
-        const boxed = bodyLines.length ? bodyLines : [''];
-        const content = boxed.map(line => {
-            const truncated = this.visibleLength(line) > innerWidth
-                ? `${line.slice(0, Math.max(0, innerWidth - 1))}…`
-                : line;
-            const pad = Math.max(0, innerWidth - this.visibleLength(truncated));
-            return `${theme.ui.muted('│')} ${truncated}${' '.repeat(pad)} ${theme.ui.muted('│')}`;
-        });
-        return [top, ...content, bottom].join('\n');
-    }
-    visibleLength(value) {
-        if (!value)
-            return 0;
-        return this.stripAnsi(value).length;
-    }
-    stripAnsi(value) {
-        if (!value)
-            return '';
-        return value.replace(/\u001B\[[0-?]*[ -/]*[@-~]/g, '');
-    }
     /**
      * Format tool result summary in Erosolar-CLI style
      * Returns compact summary like "Found 4 files" or "Read 50 lines"
@@ -1331,14 +1411,32 @@ export class ShellUIAdapter {
                 }
                 return 'Todos updated';
             }
+            case 'grep_search':
+            case 'search_files':
+            case 'Grep': {
+                // Count matches in output - look for file paths or line numbers
+                const lines = output.trim().split('\n').filter(l => l.trim());
+                if (lines.length === 0 || output.includes('No matches found') || output.includes('no matches')) {
+                    return theme.ui.muted('No matches');
+                }
+                // Count unique files or match lines
+                const fileMatches = output.match(/^[^\n:]+:\d+:/gm);
+                if (fileMatches) {
+                    const uniqueFiles = new Set(fileMatches.map(m => m.split(':')[0])).size;
+                    return `${theme.info(String(fileMatches.length))} matches in ${uniqueFiles} file${uniqueFiles === 1 ? '' : 's'}`;
+                }
+                return `${theme.info(String(lines.length))} matches`;
+            }
             default: {
-                // Generic result
+                // Generic result - show more info for better context
                 const lines = output.trim().split('\n').filter(l => l).length;
                 if (lines === 0) {
-                    return 'Completed';
+                    return theme.ui.muted('No output');
                 }
                 if (lines <= 3) {
-                    return 'Completed';
+                    // Show the actual output if short
+                    const shortOutput = output.trim().substring(0, 60);
+                    return shortOutput.length < output.trim().length ? `${shortOutput}…` : shortOutput;
                 }
                 return `${theme.info(String(lines))} lines`;
             }