erosolar-cli 1.7.410 → 1.7.412

package/dist/ui/ShellUIAdapter.js

@@ -4,7 +4,7 @@
  *
  * Advanced UI Features:
  * - Compact same-line tool displays
- * - Streaming progress updates (no redraw)
+ * - In-place progress updates
  * - Grouped operation summaries
  * - Dynamic status badges
  */
@@ -14,6 +14,7 @@ import { getTerminalColumns } from './layout.js';
 import { theme, icons } from './theme.js';
 import { UIUpdateCoordinator } from './orchestration/UIUpdateCoordinator.js';
 import { compactRenderer } from './compactRenderer.js';
+import { inPlaceUpdater } from './inPlaceUpdater.js';
 export class ShellUIAdapter {
     uiController;
     display;
@@ -30,8 +31,6 @@ export class ShellUIAdapter {
     maxCompletedOps = 8;
     compactDisplayMode = true; // Enable compact same-line displays
     toolWarnings = new Map();
-    recentWarnings = [];
-    toolProgressState = new Map();
     constructor(writeStream, display, config = {}, updateCoordinator) {
         this.display = display;
         this.config = {
@@ -106,7 +105,7 @@ export class ShellUIAdapter {
                 // Update status bar to show active tool
                 if (this._toolStatusCallback) {
                     const actionDesc = this.getToolActionDescription(call);
-                    this._toolStatusCallback({ text: actionDesc, stage: 'start' });
+                    this._toolStatusCallback(actionDesc);
                 }
                 this.uiController.onToolStart(call);
             },
@@ -121,34 +120,23 @@ export class ShellUIAdapter {
                     total: progress.total ?? progress.current,
                     message: progress.message,
                 });
-                // Update status bar with progress
+                // Update status bar with progress - use in-place update for supported terminals
                 if (this._toolStatusCallback) {
                     const description = this.getToolActionDescription(call, progress);
                     if (description) {
-                        this._toolStatusCallback({ text: description, stage: 'progress' });
+                        this._toolStatusCallback(description);
                     }
                 }
-                // Stream progress updates instead of in-place redraws
-                if (progress.total && progress.total > 1) {
-                    const progressLine = this.formatStreamingProgress(call, progress);
-                    this.streamProgressUpdate(call.id, progressLine);
-                }
-                else if (progress.message) {
-                    this.streamProgressUpdate(call.id, `${theme.info(icons.action)} ${theme.tool(call.name)} ${progress.message}`);
+                // Show progress bar for file operations and long-running tools
+                if (inPlaceUpdater.hasTTY && progress.total && progress.total > 1) {
+                    inPlaceUpdater.showToolProgress(call.name, progress.message || '', { current: progress.current, total: progress.total });
                 }
             },
             onToolWarning: (call, warning) => {
-                const toolName = theme.tool(call.name);
                 const warningText = this.formatToolWarning(warning);
-                const line = `${theme.warning(icons.warning)} ${toolName} ${theme.ui.muted('preflight')} ${warningText}`;
-                this.recordToolWarning(call.id, call.name, warningText);
-                // Use display.stream() to work with scroll regions
-                this.display.stream(`\n${line}\n`);
+                this.recordToolWarning(call.id, warningText);
                 if (this._toolStatusCallback) {
-                    this._toolStatusCallback({
-                        text: `Warning: ${this.getToolActionDescription(call)}`,
-                        stage: 'progress',
-                    });
+                    this._toolStatusCallback(`Warning: ${this.getToolActionDescription(call)}`);
                 }
             },
             onToolResult: (call, output) => {
@@ -172,21 +160,21 @@ export class ShellUIAdapter {
                         this.fileChangeCallback(fileChange.path, fileChange.type, fileChange.additions, fileChange.removals);
                     }
                 }
-                // Render concise tool result + preview instead of verbose blocks
-                this.displayToolResultSummary(call, output, true);
+                // Use compact display for quick single-result tools
+                if (this.compactDisplayMode && this.isCompactTool(call.name)) {
+                    this.displayCompactResult(call, output, true);
+                }
+                else {
+                    // Claude Code style: 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);
                 // Clear status bar after showing result
                 if (this._toolStatusCallback) {
-                    const completed = this.getToolActionDescription(call);
-                    this._toolStatusCallback({
-                        text: completed ? `Completed ${completed}` : 'Tool complete',
-                        stage: 'result',
-                    });
-                    this._toolStatusCallback({ text: null, stage: 'complete' });
+                    this._toolStatusCallback(null);
                 }
                 this.uiController.onToolComplete(call.id, output);
-                this.toolProgressState.delete(call.id);
             },
             onToolError: (call, message) => {
                 // Complete the operation tracking with error
@@ -198,20 +186,20 @@ export class ShellUIAdapter {
                     this.pendingOperations.delete(call.id);
                     this.completedOperations.push(op);
                 }
-                // Render concise error summary + preview instead of verbose blocks
-                this.displayToolResultSummary(call, message, false);
+                // Use compact display for errors too
+                if (this.compactDisplayMode && this.isCompactTool(call.name)) {
+                    this.displayCompactResult(call, message, false);
+                }
+                else {
+                    // Claude Code style: Display error with ⎿ prefix (error color)
+                    this.displayToolResultSummary(call, message, false);
+                }
                 this.flushToolWarnings(call.id, call.name);
                 // Clear status bar after showing error
                 if (this._toolStatusCallback) {
-                    const failed = this.getToolActionDescription(call);
-                    this._toolStatusCallback({
-                        text: failed ? `Failed ${failed}` : 'Tool failed',
-                        stage: 'error',
-                    });
-                    this._toolStatusCallback({ text: null, stage: 'complete' });
+                    this._toolStatusCallback(null);
                 }
                 this.uiController.onToolError(call.id, { message });
-                this.toolProgressState.delete(call.id);
             },
             onCacheHit: (call) => {
                 // Track as cached operation
@@ -230,21 +218,24 @@ export class ShellUIAdapter {
                     const badge = compactRenderer.formatToolBadge(operation);
                     this.display.stream(`${badge}\n`);
                 }
-                if (this._toolStatusCallback) {
-                    const cached = this.getToolActionDescription(call);
-                    this._toolStatusCallback({
-                        text: cached ? `Cached ${cached}` : 'Tool cache hit',
-                        stage: 'result',
-                    });
-                    this._toolStatusCallback({ text: null, stage: 'complete' });
-                }
                 this.flushToolWarnings(call.id, call.name);
                 this.uiController.onToolStart(call);
                 this.uiController.onToolComplete(call.id, 'cache-hit');
-                this.toolProgressState.delete(call.id);
             },
         };
     }
+    /**
+     * Check if a tool should use compact (single-line) display
+     */
+    isCompactTool(toolName) {
+        const compactTools = new Set([
+            'Read', 'read_file',
+            'Glob', 'glob',
+            'TodoWrite', 'todo_write',
+            'WebFetch', 'web_fetch',
+        ]);
+        return compactTools.has(toolName);
+    }
     /**
      * Normalize preflight warnings for consistent display.
      */
@@ -259,14 +250,11 @@ export class ShellUIAdapter {
     /**
      * Track warnings for a tool call so we can show them after the result too.
      */
-    recordToolWarning(callId, toolName, warningText) {
+    recordToolWarning(callId, warningText) {
         const existing = this.toolWarnings.get(callId) ?? [];
-        existing.push(warningText);
-        this.toolWarnings.set(callId, existing);
-        this.recentWarnings.push({ tool: toolName, text: warningText, time: Date.now() });
-        // Keep recent warnings list compact
-        if (this.recentWarnings.length > 20) {
-            this.recentWarnings.shift();
+        if (!existing.includes(warningText)) {
+            existing.push(warningText);
+            this.toolWarnings.set(callId, existing);
         }
     }
     /**
@@ -283,42 +271,6 @@ export class ShellUIAdapter {
         const body = warnings.map(text => `  ${bullet} ${text}`).join('\n');
         this.display.stream(`\n${header}\n${body}\n`);
     }
-    /**
-     * Render progress updates as streaming lines rather than in-place redraws.
-     */
-    formatStreamingProgress(call, progress) {
-        const pct = progress.total ? Math.round((progress.current / progress.total) * 100) : null;
-        const parts = [];
-        parts.push(theme.info(icons.action));
-        parts.push(theme.tool(call.name));
-        if (pct !== null && Number.isFinite(pct)) {
-            parts.push(theme.progress.percentage(`${pct}%`));
-            parts.push(theme.ui.muted(`(${progress.current}/${progress.total})`));
-        }
-        if (progress.message) {
-            parts.push(progress.message);
-        }
-        return parts.join(' ');
-    }
-    /**
-     * Only stream distinct progress updates to avoid noisy duplicates.
-     */
-    streamProgressUpdate(callId, line) {
-        const previous = this.toolProgressState.get(callId);
-        if (previous === line) {
-            return;
-        }
-        this.toolProgressState.set(callId, line);
-        this.display.stream(`${line}\n`);
-    }
-    /**
-     * Return preflight warnings captured since a timestamp.
-     */
-    getRecentWarnings(since) {
-        return this.recentWarnings
-            .filter((entry) => entry.time >= since)
-            .map((entry) => ({ tool: entry.tool, text: entry.text }));
-    }
     /**
      * Get a short summary for tool operation
      */
@@ -418,6 +370,21 @@ export class ShellUIAdapter {
                 return 'done';
         }
     }
+    /**
+     * Display compact single-line result
+     */
+    displayCompactResult(call, output, success) {
+        const op = {
+            id: call.id,
+            name: call.name,
+            status: success ? 'success' : 'error',
+            summary: this.extractResultSummary(call, output),
+            startedAt: Date.now(),
+        };
+        const badge = compactRenderer.formatToolBadge(op);
+        // Add newline after result for visual separation
+        this.display.stream(`${badge}\n\n`);
+    }
     /**
      * Determine if a tool should show initial ⏺ display
      * Returns true for tools with streaming/progressive output
@@ -852,19 +819,6 @@ export class ShellUIAdapter {
     setToolStatusCallback(callback) {
         this._toolStatusCallback = callback;
     }
-    /**
-     * Expose a snapshot of tool operations for external summary displays.
-     * Returns both completed and in-flight operations, optionally filtered by start time.
-     */
-    getToolOperationsSince(sinceMs) {
-        const cutoff = sinceMs ?? 0;
-        const completed = this.completedOperations.map(op => ({ ...op }));
-        const pending = Array.from(this.pendingOperations.values()).map(op => ({ ...op }));
-        const all = [...completed, ...pending];
-        return all
-            .filter(op => op.startedAt >= cutoff)
-            .sort((a, b) => (a.startedAt || 0) - (b.startedAt || 0));
-    }
     /**
      * Parse file changes from Edit/Write/NotebookEdit tool output
      */
@@ -909,282 +863,27 @@ export class ShellUIAdapter {
         };
     }
     /**
-     * Display tool result summary in a compact, badge-driven line with an optional preview block.
-     * Routes through display module to work with scroll regions while keeping output minimal.
+     * Display tool result summary using Claude Code style.
+     * Format: ⎿  Summary text
+     * Routes through display module to work with scroll regions
      */
     displayToolResultSummary(call, output, success) {
-        const summaryLine = this.formatCompactToolLine(call, output, success);
-        const preview = this.formatToolPreview(call, output, success);
-        if (!summaryLine && !preview) {
-            return;
-        }
-        const blocks = [];
-        if (summaryLine)
-            blocks.push(summaryLine);
-        if (preview)
-            blocks.push(preview);
-        // Add newline for separation while keeping output compact
-        this.display.stream(`\n${blocks.join('\n')}\n\n`);
-    }
-    /**
-     * Display full tool output directly under the summary block.
-     * Now uses the same compact preview system to keep verbose tools readable.
-     */
-    displayFullToolOutput(call, output, success) {
-        const normalized = typeof output === 'string' ? output.trimEnd() : '';
-        if (!normalized) {
-            return;
-        }
-        // Use the same preview builder to keep verbose output compact
-        const preview = this.formatToolPreview(call, normalized, success, true);
-        const summary = this.formatCompactToolLine(call, normalized, success);
-        const parts = [];
-        if (summary)
-            parts.push(summary);
-        if (preview)
-            parts.push(preview);
-        if (parts.length) {
-            this.display.stream(`\n${parts.join('\n')}\n\n`);
+        const args = call.arguments || {};
+        // Get compact summary for the result
+        const summary = this.formatClaudeCodeResultSummary(call.name, args, output, success);
+        if (summary) {
+            // Claude Code style: ⎿  Summary (indented under tool call)
+            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`);
         }
     }
     /**
      * Format tool result summary in Claude Code style
      * Returns compact summary like "Found 4 files" or "Read 50 lines"
      */
-    formatCompactToolLine(call, output, success) {
-        const { main, detail } = this.buildToolSummaryParts(call, output, success);
-        const summary = main || this.getToolSummary(call) || call.name;
-        return compactRenderer.formatInlineResult(call.name, success ? 'success' : 'error', summary, detail);
-    }
-    /**
-     * Build compact summary + detail parts for a tool result line.
-     * Keeps the main text meaningful (path/query) and pushes counts into detail.
-     */
-    buildToolSummaryParts(call, output, success) {
-        const args = call.arguments || {};
-        const lineCount = this.countOutputLines(output);
-        switch (call.name) {
-            case 'Read':
-            case 'read_file': {
-                const path = this.extractPath(args, ['file_path', 'path']);
-                return {
-                    main: path ? theme.info(this.truncatePath(path, 60)) : 'Read',
-                    detail: `${lineCount} line${lineCount === 1 ? '' : 's'}`,
-                };
-            }
-            case 'Write':
-            case 'write_file': {
-                const path = this.extractPath(args, ['file_path', 'path']);
-                const content = args['content'] || output;
-                const lines = this.countOutputLines(content);
-                return {
-                    main: path ? theme.info(this.truncatePath(path, 60)) : 'Write',
-                    detail: `${lines} line${lines === 1 ? '' : 's'}`,
-                };
-            }
-            case 'Edit':
-            case 'edit_file':
-            case 'NotebookEdit': {
-                const change = this.parseFileChange(call, output);
-                const path = change?.path || this.extractPath(args, ['file_path', 'path', 'notebook_path']);
-                const detailParts = [];
-                if (change) {
-                    detailParts.push(`+${change.additions}/-${change.removals}`);
-                }
-                else if (lineCount > 0) {
-                    detailParts.push(`${lineCount} line${lineCount === 1 ? '' : 's'}`);
-                }
-                const action = call.name === 'NotebookEdit' ? 'Notebook' : 'Edit';
-                return {
-                    main: path ? `${action} ${theme.info(this.truncatePath(path, 60))}` : action,
-                    detail: detailParts.join(' · ') || undefined,
-                };
-            }
-            case 'Grep':
-            case 'grep': {
-                const pattern = args['pattern'] || '';
-                const path = this.extractPath(args, ['path', 'directory']);
-                const matches = output.trim() ? output.trim().split('\n').filter(l => l.trim()).length : 0;
-                const detailParts = [`${matches} match${matches === 1 ? '' : 'es'}`];
-                if (path && path !== '.') {
-                    detailParts.push(`in ${this.truncatePath(path, 40)}`);
-                }
-                return {
-                    main: pattern ? `"${pattern.length > 40 ? `${pattern.slice(0, 37)}...` : pattern}"` : 'Grep',
-                    detail: detailParts.join(' · '),
-                };
-            }
-            case 'Glob':
-            case 'glob': {
-                const pattern = args['pattern'] || '*';
-                const files = output.trim() ? output.trim().split('\n').filter(f => f.trim()).length : 0;
-                const path = this.extractPath(args, ['path', 'directory']);
-                const detailParts = [`${files} file${files === 1 ? '' : 's'}`];
-                if (path && path !== '.') {
-                    detailParts.push(`in ${this.truncatePath(path, 40)}`);
-                }
-                return {
-                    main: pattern ? theme.info(pattern) : 'Glob',
-                    detail: detailParts.join(' · '),
-                };
-            }
-            case 'Bash':
-            case 'bash': {
-                const command = args['command'] || '';
-                const shortCmd = command.split('\n')[0]?.trim() || command;
-                const main = shortCmd
-                    ? `${theme.ui.muted('$')} ${shortCmd.length > 70 ? `${shortCmd.slice(0, 67)}...` : shortCmd}`
-                    : 'Shell';
-                const detail = lineCount === 0 ? 'no output' : `${lineCount} line${lineCount === 1 ? '' : 's'}`;
-                return { main, detail };
-            }
-            case 'WebFetch':
-            case 'web_fetch': {
-                const url = args['url'] || '';
-                let host = url;
-                try {
-                    host = new URL(url).hostname;
-                }
-                catch {
-                    // Keep original
-                }
-                const sizeStr = output.length > 1024 ? `${(output.length / 1024).toFixed(1)}KB` : `${output.length}B`;
-                return { main: host ? `Fetch ${theme.info(host)}` : 'Fetch', detail: sizeStr };
-            }
-            case 'WebSearch':
-            case 'web_search': {
-                const query = args['query'] || '';
-                const queryDisplay = query.length > 50 ? `${query.slice(0, 47)}...` : query;
-                const resultMatches = output.match(/^\d+\./gm);
-                const count = resultMatches ? resultMatches.length : this.countOutputLines(output);
-                return { main: queryDisplay ? `Search "${queryDisplay}"` : 'Search', detail: `${count} result${count === 1 ? '' : 's'}` };
-            }
-            case 'Task':
-            case 'task': {
-                const desc = args['description'] || '';
-                const trimmed = desc.length > 60 ? `${desc.slice(0, 57)}...` : desc;
-                return { main: trimmed || 'Task', detail: success ? 'done' : 'incomplete' };
-            }
-            case 'TodoWrite':
-            case 'todo_write': {
-                const todos = args['todos'];
-                const total = todos?.length || 0;
-                return { main: 'Todos', detail: total ? `${total} item${total === 1 ? '' : 's'}` : undefined };
-            }
-            case 'run_tests': {
-                const pattern = (args['pattern'] || args['filter']);
-                const counts = this.parseTestCounts(output);
-                const detailParts = [];
-                if (counts.passed > 0)
-                    detailParts.push(`${counts.passed} pass`);
-                if (counts.failed > 0)
-                    detailParts.push(`${counts.failed} fail`);
-                if (counts.skipped > 0)
-                    detailParts.push(`${counts.skipped} skip`);
-                if (detailParts.length === 0 && lineCount > 0) {
-                    detailParts.push(`${lineCount} line${lineCount === 1 ? '' : 's'}`);
-                }
-                return {
-                    main: pattern ? `Tests "${pattern}"` : 'Tests',
-                    detail: detailParts.join(' · ') || (success ? 'all passed' : 'failed'),
-                };
-            }
-            case 'run_build': {
-                const target = (args['target'] || args['script']);
-                const errors = (output.match(/error/gi) || []).length;
-                const detail = errors > 0
-                    ? `${errors} error${errors === 1 ? '' : 's'}`
-                    : `${lineCount} line${lineCount === 1 ? '' : 's'}`;
-                return { main: target ? `Build ${target}` : 'Build', detail };
-            }
-            default: {
-                const summary = this.extractResultSummary(call, output);
-                if (summary) {
-                    return { main: summary };
-                }
-                const claudeSummary = this.formatClaudeCodeResultSummary(call.name, args, output, success);
-                if (claudeSummary) {
-                    return { main: claudeSummary };
-                }
-                return { main: call.name, detail: lineCount ? `${lineCount} line${lineCount === 1 ? '' : 's'}` : undefined };
-            }
-        }
-    }
-    /**
-     * Render a compact preview of tool output (first N lines) with truncation hints.
-     */
-    formatToolPreview(call, output, success, force = false) {
-        const previewLines = this.buildPreviewLines(call, output, success, force);
-        if (!previewLines.length) {
-            return null;
-        }
-        const gutter = theme.ui.muted('│');
-        return previewLines.map(line => `  ${gutter} ${line}`).join('\n');
-    }
-    buildPreviewLines(call, output, success, force) {
-        const normalized = (output || '').trim();
-        const allLines = normalized ? normalized.split('\n').filter(l => l.trim()) : [];
-        const limit = this.getPreviewLineLimit(call.name, success);
-        if (limit <= 0 && !force) {
-            return [];
-        }
-        const maxLines = limit > 0 ? limit : force ? Math.min(1, allLines.length) : 0;
-        if (maxLines === 0 || allLines.length === 0) {
-            return [];
-        }
-        const preview = allLines.slice(0, maxLines).map(line => this.truncatePreviewLine(line));
-        const remaining = allLines.length - maxLines;
-        if (remaining > 0) {
-            preview.push(theme.ui.muted(`… +${remaining} more`));
-        }
-        return preview;
-    }
-    getPreviewLineLimit(toolName, success) {
-        switch (toolName) {
-            case 'Read':
-            case 'read_file':
-                return success ? 0 : 1;
-            case 'Glob':
-            case 'glob':
-                return 3;
-            case 'Grep':
-            case 'grep':
-                return 4;
-            case 'Bash':
-            case 'bash':
-                return success ? 3 : 4;
-            case 'run_tests':
-                return success ? 2 : 4;
-            case 'Edit':
-            case 'edit_file':
-            case 'NotebookEdit':
-                return success ? 30 : 4; // Show more diff context for successful edits
-            default:
-                return success ? 2 : 3;
-        }
-    }
-    truncatePreviewLine(line, maxLen = 100) {
-        const trimmed = line.trim();
-        if (trimmed.length <= maxLen) {
-            return theme.dim(trimmed);
-        }
-        return theme.dim(`${trimmed.slice(0, maxLen - 3)}...`);
-    }
-    countOutputLines(output) {
-        if (!output || !output.trim())
-            return 0;
-        return output.trimEnd().split('\n').length;
-    }
-    parseTestCounts(output) {
-        const passMatch = output.match(/(\d+)\s*(?:passing|passed|✓)/i);
-        const failMatch = output.match(/(\d+)\s*(?:failing|failed|✗)/i);
-        const skipMatch = output.match(/(\d+)\s*(?:skipped|pending)/i);
-        return {
-            passed: passMatch ? parseInt(passMatch[1] || '0', 10) : 0,
-            failed: failMatch ? parseInt(failMatch[1] || '0', 10) : 0,
-            skipped: skipMatch ? parseInt(skipMatch[1] || '0', 10) : 0,
-        };
-    }
     formatClaudeCodeResultSummary(toolName, args, output, success) {
         if (!success) {
             // Error case - show error message