erosolar-cli 1.7.415 → 1.7.416

package/dist/ui/ShellUIAdapter.js

@@ -0,0 +1,1069 @@
+/**
+ * ShellUIAdapter - Bridges the UnifiedUIController with the existing shell infrastructure
+ * Provides compatibility layer and migration path from old to new UI system
+ *
+ * Advanced UI Features:
+ * - Compact same-line tool displays
+ * - In-place progress updates
+ * - Grouped operation summaries
+ * - Dynamic status badges
+ */
+import { UnifiedUIController } from './UnifiedUIController.js';
+import { InterruptPriority } from './interrupts/InterruptManager.js';
+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;
+    config;
+    isProcessing = false;
+    contextUsage = 0;
+    fileChangeCallback;
+    _toolStatusCallback;
+    profileSwitcherTimeout;
+    updateCoordinator;
+    // Track tool operations for compact rendering
+    pendingOperations = new Map();
+    completedOperations = [];
+    maxCompletedOps = 8;
+    compactDisplayMode = true; // Enable compact same-line displays
+    toolWarnings = new Map();
+    constructor(writeStream, display, config = {}, updateCoordinator) {
+        this.display = display;
+        this.config = {
+            enableOverlay: true,
+            enableTelemetry: true,
+            debugMode: false,
+            ...config,
+        };
+        this.updateCoordinator = updateCoordinator ?? new UIUpdateCoordinator();
+        // Initialize unified UI controller
+        this.uiController = new UnifiedUIController(writeStream, {
+            enableOverlay: this.config.enableOverlay,
+            enableAnimations: true,
+            enableTelemetry: this.config.enableTelemetry,
+            adaptivePerformance: true,
+            debugMode: this.config.debugMode,
+        });
+        // Legacy components are optional and should be passed in if needed
+        // They require a readline.Interface which we don't have here
+        this.setupDisplayIntegration();
+    }
+    /**
+     * Setup display integration
+     */
+    setupDisplayIntegration() {
+        // Register output interceptor to coordinate with overlay
+        this.display.registerOutputInterceptor({
+            beforeWrite: () => {
+                this.uiController.beginOutput();
+            },
+            afterWrite: () => {
+                this.uiController.endOutput();
+            },
+        });
+    }
+    /**
+     * Expose the shared update coordinator so other components can align with UI mode.
+     */
+    getUpdateCoordinator() {
+        return this.updateCoordinator;
+    }
+    /**
+     * Expose the underlying unified UI controller for orchestration/telemetry.
+     */
+    getController() {
+        return this.uiController;
+    }
+    /**
+     * Create a tool observer for the agent
+     * Shows tool results in clean panels (status bar shows active tool execution)
+     * Uses compact rendering for same-line displays when appropriate
+     */
+    createToolObserver() {
+        return {
+            onToolStart: (call) => {
+                // Track operation for compact rendering
+                const operation = {
+                    id: call.id,
+                    name: call.name,
+                    status: 'running',
+                    summary: this.getToolSummary(call),
+                    args: call.arguments,
+                    startedAt: Date.now(),
+                };
+                this.pendingOperations.set(call.id, operation);
+                // Show initial display for tools with streaming/progressive output
+                // Skip for quick tools to avoid duplicate displays (⏺ then ✓)
+                const showsProgressiveOutput = this.shouldShowToolStart(call.name);
+                if (showsProgressiveOutput) {
+                    this.displayToolCallStart(call);
+                }
+                // Update status bar to show active tool
+                if (this._toolStatusCallback) {
+                    const actionDesc = this.getToolActionDescription(call);
+                    this._toolStatusCallback(actionDesc);
+                }
+                this.uiController.onToolStart(call);
+            },
+            onToolProgress: (call, progress) => {
+                // Update pending operation
+                const op = this.pendingOperations.get(call.id);
+                if (op) {
+                    op.detail = progress.message;
+                }
+                this.uiController.onToolProgress(call.id, {
+                    current: progress.current,
+                    total: progress.total ?? progress.current,
+                    message: progress.message,
+                });
+                // 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(description);
+                    }
+                }
+                // 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 warningText = this.formatToolWarning(warning);
+                this.recordToolWarning(call.id, warningText);
+                if (this._toolStatusCallback) {
+                    this._toolStatusCallback(`Warning: ${this.getToolActionDescription(call)}`);
+                }
+            },
+            onToolResult: (call, output) => {
+                // Complete the operation tracking
+                const op = this.pendingOperations.get(call.id);
+                if (op) {
+                    op.status = 'success';
+                    op.completedAt = Date.now();
+                    op.summary = this.extractResultSummary(call, output);
+                    this.pendingOperations.delete(call.id);
+                    this.completedOperations.push(op);
+                    // Keep only recent completed operations
+                    while (this.completedOperations.length > this.maxCompletedOps) {
+                        this.completedOperations.shift();
+                    }
+                }
+                // Track file changes for Edit/Write/NotebookEdit tools
+                if (this.fileChangeCallback && (call.name === 'Edit' || call.name === 'Write' || call.name === 'NotebookEdit')) {
+                    const fileChange = this.parseFileChange(call, output);
+                    if (fileChange) {
+                        this.fileChangeCallback(fileChange.path, fileChange.type, fileChange.additions, fileChange.removals);
+                    }
+                }
+                // 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) {
+                    this._toolStatusCallback(null);
+                }
+                this.uiController.onToolComplete(call.id, output);
+            },
+            onToolError: (call, message) => {
+                // Complete the operation tracking with error
+                const op = this.pendingOperations.get(call.id);
+                if (op) {
+                    op.status = 'error';
+                    op.completedAt = Date.now();
+                    op.summary = message;
+                    this.pendingOperations.delete(call.id);
+                    this.completedOperations.push(op);
+                }
+                // 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) {
+                    this._toolStatusCallback(null);
+                }
+                this.uiController.onToolError(call.id, { message });
+            },
+            onCacheHit: (call) => {
+                // Track as cached operation
+                const operation = {
+                    id: call.id,
+                    name: call.name,
+                    status: 'cached',
+                    summary: this.getToolSummary(call) + ' (cached)',
+                    args: call.arguments,
+                    startedAt: Date.now(),
+                    completedAt: Date.now(),
+                };
+                this.completedOperations.push(operation);
+                // Show compact cached result
+                if (this.compactDisplayMode) {
+                    const badge = compactRenderer.formatToolBadge(operation);
+                    this.display.stream(`${badge}\n`);
+                }
+                this.flushToolWarnings(call.id, call.name);
+                this.uiController.onToolStart(call);
+                this.uiController.onToolComplete(call.id, 'cache-hit');
+            },
+        };
+    }
+    /**
+     * 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.
+     */
+    formatToolWarning(warning) {
+        if (typeof warning === 'string') {
+            return warning;
+        }
+        const code = warning.code ? `[${warning.code}] ` : '';
+        const suggestion = warning.suggestion ? ` — ${warning.suggestion}` : '';
+        return `${code}${warning.message}${suggestion}`;
+    }
+    /**
+     * Track warnings for a tool call so we can show them after the result too.
+     */
+    recordToolWarning(callId, warningText) {
+        const existing = this.toolWarnings.get(callId) ?? [];
+        if (!existing.includes(warningText)) {
+            existing.push(warningText);
+            this.toolWarnings.set(callId, existing);
+        }
+    }
+    /**
+     * Render any captured warnings for the given tool call as a structured block.
+     */
+    flushToolWarnings(callId, toolName) {
+        const warnings = this.toolWarnings.get(callId);
+        if (!warnings?.length) {
+            return;
+        }
+        this.toolWarnings.delete(callId);
+        const header = `${theme.warning(icons.warning)} ${theme.ui.muted('preflight')} warnings for ${theme.tool(toolName)}`;
+        const bullet = theme.ui.muted(icons.bullet);
+        const body = warnings.map(text => `  ${bullet} ${text}`).join('\n');
+        this.display.stream(`\n${header}\n${body}\n`);
+    }
+    /**
+     * Get a short summary for tool operation
+     */
+    getToolSummary(call) {
+        const args = call.arguments;
+        switch (call.name) {
+            case 'Read':
+            case 'read_file': {
+                const path = this.extractPath(args, ['file_path', 'path']);
+                return path ? this.truncatePath(path, 30) : '';
+            }
+            case 'Edit':
+            case 'edit_file': {
+                const path = this.extractPath(args, ['file_path', 'path']);
+                return path ? this.truncatePath(path, 30) : '';
+            }
+            case 'Grep':
+            case 'grep': {
+                const pattern = args?.['pattern'];
+                return pattern ? `"${pattern.slice(0, 20)}"` : '';
+            }
+            case 'Glob':
+            case 'glob': {
+                const pattern = args?.['pattern'];
+                return pattern || '';
+            }
+            case 'Task':
+            case 'task': {
+                const desc = args?.['description'];
+                return desc ? desc.slice(0, 25) : '';
+            }
+            default:
+                return '';
+        }
+    }
+    /**
+     * Extract result summary from tool output
+     * Includes file paths for file operations so users can see which files were accessed
+     */
+    extractResultSummary(call, output) {
+        const args = call.arguments;
+        switch (call.name) {
+            case 'Read':
+            case 'read_file': {
+                const path = this.extractPath(args, ['file_path', 'path']);
+                const lines = output.split('\n').length;
+                // Show file path so users see which file was read
+                return path ? `${this.truncatePath(path, 40)} (${lines} lines)` : `${lines} lines`;
+            }
+            case 'Write':
+            case 'write_file': {
+                const path = this.extractPath(args, ['file_path', 'path']);
+                const lines = output.split('\n').length;
+                return path ? `${this.truncatePath(path, 40)} written` : 'file written';
+            }
+            case 'Edit':
+            case 'edit_file': {
+                const path = this.extractPath(args, ['file_path', 'path']);
+                // Parse additions/removals from output if available
+                const editMatch = output.match(/\+(\d+).*-(\d+)/);
+                const changes = editMatch ? `+${editMatch[1]}/-${editMatch[2]}` : 'edited';
+                return path ? `${this.truncatePath(path, 35)} ${changes}` : changes;
+            }
+            case 'Grep':
+            case 'grep': {
+                const pattern = args?.['pattern'];
+                const matches = output.trim().split('\n').filter(l => l).length;
+                const matchText = `${matches} match${matches === 1 ? '' : 'es'}`;
+                // Show pattern for context
+                if (pattern && pattern.length <= 20) {
+                    return `"${pattern}" → ${matchText}`;
+                }
+                return matchText;
+            }
+            case 'Glob':
+            case 'glob': {
+                const pattern = args?.['pattern'];
+                const files = output.trim().split('\n').filter(f => f).length;
+                const fileText = `${files} file${files === 1 ? '' : 's'}`;
+                // Show pattern for context
+                if (pattern && pattern.length <= 25) {
+                    return `${pattern} → ${fileText}`;
+                }
+                return fileText;
+            }
+            case 'Bash':
+            case 'bash': {
+                const cmd = args?.['command'];
+                if (cmd) {
+                    const shortCmd = cmd.split('\n')[0]?.trim() || cmd;
+                    const truncated = shortCmd.length > 30 ? `${shortCmd.slice(0, 27)}...` : shortCmd;
+                    return `\`${truncated}\` done`;
+                }
+                return 'done';
+            }
+            default:
+                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
+     * Returns false for quick single-result tools to avoid duplicate displays
+     */
+    shouldShowToolStart(toolName) {
+        // Tools that show streaming or progressive output - show start indicator
+        const streamingTools = new Set([
+            'Task', // Spawns agents with streaming output
+            'Bash', // Shows live command output
+            'Explore', // Lists files progressively
+            'Plan', // Planning agent with progressive output
+            'Grep', // May return many results
+            'Glob', // May return many files
+            'WebSearch', // Shows search progress
+            'WebFetch', // Shows fetch progress
+        ]);
+        return streamingTools.has(toolName);
+    }
+    /**
+     * Display tool call start with Claude Code style prefix
+     * - ✢ for Task/agent tools (active task indicator)
+     * - ⏺ for other tools
+     * Routes through display module to work with scroll regions
+     */
+    displayToolCallStart(call, isCacheHit = false) {
+        const args = call.arguments || {};
+        const toolName = theme.tool(call.name);
+        // Format args inline (compact)
+        const argsStr = this.formatToolArgsInline(call.name, args);
+        const cacheHint = isCacheHit ? theme.ui.muted(' (cached)') : '';
+        // Use ✢ for Task tools (shows active task), ⏺ for others
+        const isTaskTool = call.name === 'Task' || call.name === 'task';
+        const icon = isTaskTool ? theme.info('✢') : theme.info('⏺');
+        // For Task tools, show the subagent type if available
+        let displayName = toolName;
+        if (isTaskTool) {
+            const subagentType = args['subagent_type'];
+            if (subagentType) {
+                // Capitalize first letter
+                displayName = theme.tool(subagentType.charAt(0).toUpperCase() + subagentType.slice(1));
+            }
+        }
+        // Claude Code style: ⏺/✢ ToolName(args)
+        const line = `${icon} ${displayName}${argsStr}${cacheHint}`;
+        // Use display.stream() to work with scroll regions
+        // Add extra newline before tool calls for visual separation
+        this.display.stream(`\n${line}\n`);
+    }
+    /**
+     * Format tool arguments inline for display (Claude Code style)
+     * Format: ToolName(arg1: "value1", arg2: "value2")
+     */
+    formatToolArgsInline(toolName, args) {
+        const parts = [];
+        // Priority order for different argument types
+        const priorityArgs = [
+            'file_path', 'path', 'pattern', 'command', 'query', 'url',
+            'output_mode', 'glob', 'type', 'head_limit',
+        ];
+        // Skip these arguments in display
+        const skipArgs = new Set([
+            'dangerouslyDisableSandbox', 'run_in_background', 'description',
+            'timeout', 'encoding', '-n', // defaults that don't add info
+        ]);
+        // Build args display based on tool type
+        switch (toolName) {
+            case 'Read':
+            case 'read_file': {
+                const filePath = args['file_path'] || args['path'];
+                if (filePath)
+                    parts.push(this.truncatePath(String(filePath), 50));
+                break;
+            }
+            case 'Write':
+            case 'write_file':
+            case 'Edit':
+            case 'edit_file': {
+                const filePath = args['file_path'] || args['path'];
+                if (filePath)
+                    parts.push(this.truncatePath(String(filePath), 50));
+                break;
+            }
+            case 'Bash':
+            case 'bash': {
+                const cmd = args['command'];
+                if (cmd) {
+                    const shortCmd = String(cmd).split('\n')[0]?.trim() || String(cmd);
+                    parts.push(shortCmd.length > 50 ? `${shortCmd.slice(0, 47)}...` : shortCmd);
+                }
+                break;
+            }
+            case 'Grep':
+            case 'grep': {
+                const pattern = args['pattern'];
+                if (pattern) {
+                    const truncPattern = String(pattern).length > 35
+                        ? `${String(pattern).slice(0, 32)}...`
+                        : String(pattern);
+                    parts.push(`pattern: "${truncPattern}"`);
+                }
+                const path = args['path'];
+                if (path && path !== '.') {
+                    parts.push(`path: "${this.truncatePath(String(path), 30)}"`);
+                }
+                const outputMode = args['output_mode'];
+                if (outputMode && outputMode !== 'files_with_matches') {
+                    parts.push(`output_mode: "${outputMode}"`);
+                }
+                break;
+            }
+            case 'Glob':
+            case 'glob': {
+                const pattern = args['pattern'];
+                if (pattern)
+                    parts.push(`pattern: "${pattern}"`);
+                const path = args['path'];
+                if (path && path !== '.') {
+                    parts.push(`path: "${this.truncatePath(String(path), 30)}"`);
+                }
+                break;
+            }
+            case 'WebFetch':
+            case 'web_fetch': {
+                const url = args['url'];
+                if (url) {
+                    try {
+                        parts.push(new URL(String(url)).hostname);
+                    }
+                    catch {
+                        parts.push(String(url).slice(0, 40));
+                    }
+                }
+                break;
+            }
+            case 'WebSearch':
+            case 'web_search': {
+                const query = args['query'];
+                if (query) {
+                    const truncQuery = String(query).length > 40
+                        ? `${String(query).slice(0, 37)}...`
+                        : String(query);
+                    parts.push(`"${truncQuery}"`);
+                }
+                break;
+            }
+            case 'Task':
+            case 'task': {
+                const desc = args['description'];
+                if (desc) {
+                    const truncDesc = String(desc).length > 40
+                        ? `${String(desc).slice(0, 37)}...`
+                        : String(desc);
+                    parts.push(`"${truncDesc}"`);
+                }
+                break;
+            }
+            case 'TodoWrite':
+            case 'todo_write': {
+                const todos = args['todos'];
+                if (Array.isArray(todos))
+                    parts.push(`${todos.length} items`);
+                break;
+            }
+            default: {
+                // For unknown tools, show key: value pairs for priority args
+                for (const key of priorityArgs) {
+                    if (skipArgs.has(key))
+                        continue;
+                    const value = args[key];
+                    if (value === undefined || value === null || value === '')
+                        continue;
+                    if (typeof value === 'string') {
+                        const truncVal = value.length > 30 ? `${value.slice(0, 27)}...` : value;
+                        parts.push(`${key}: "${truncVal}"`);
+                    }
+                    else if (typeof value === 'number' || typeof value === 'boolean') {
+                        parts.push(`${key}: ${value}`);
+                    }
+                    if (parts.length >= 3)
+                        break; // Max 3 args for display
+                }
+            }
+        }
+        return parts.length > 0 ? `(${parts.join(', ')})` : '';
+    }
+    /**
+     * Start processing a request
+     */
+    startProcessing(message = 'Working on your request') {
+        this.isProcessing = true;
+        this.uiController.startProcessing();
+        this.uiController.setBaseStatus(message, 'info');
+    }
+    /**
+     * End processing
+     */
+    endProcessing(message = 'Ready for prompts') {
+        this.isProcessing = false;
+        this.uiController.endProcessing();
+        this.uiController.setBaseStatus(message, 'success');
+    }
+    /**
+     * 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.
+     */
+    updateContextUsage(percentage) {
+        this.contextUsage = percentage;
+        // Don't push status override - display.showStatusLine() already shows context
+    }
+    /**
+     * Show a user interrupt
+     */
+    showInterrupt(message, type = 'alert', handler) {
+        const priority = type === 'alert'
+            ? InterruptPriority.HIGH
+            : InterruptPriority.NORMAL;
+        return this.uiController.queueInterrupt(type, message, priority, handler ? async () => handler() : undefined);
+    }
+    /**
+     * Complete an interrupt
+     */
+    completeInterrupt(id) {
+        this.uiController.completeInterrupt(id);
+    }
+    /**
+     * Show profile switcher (Shift+Tab)
+     */
+    showProfileSwitcher(profiles, currentProfile) {
+        this.updateCoordinator.enqueue({
+            lane: 'overlay',
+            description: 'profile-switcher',
+            coalesceKey: 'overlay:profile-switcher',
+            priority: 'normal',
+            mode: ['idle', 'processing'],
+            run: () => {
+                const terminalWidth = getTerminalColumns();
+                const separator = '─'.repeat(terminalWidth - 1);
+                const profileLines = profiles.map(profile => {
+                    return `  ${profile.command}\n      ${profile.description}`;
+                }).join('\n');
+                const header = `Switch Profile (Shift+Tab)`;
+                const content = `${separator}\n${header}\n${separator}\n${profileLines}\n\nPress number to switch or Esc to cancel`;
+                this.uiController.updateCommandsOverlay(content);
+                if (this.profileSwitcherTimeout) {
+                    clearTimeout(this.profileSwitcherTimeout);
+                }
+                this.profileSwitcherTimeout = setTimeout(() => {
+                    this.uiController.hideCommandsOverlay();
+                    this.profileSwitcherTimeout = undefined;
+                }, 5000);
+            },
+        });
+    }
+    /**
+     * Enable or disable overlay
+     */
+    setOverlayEnabled(enabled) {
+        this.config.enableOverlay = enabled;
+        this.uiController.updateConfig({ enableOverlay: enabled });
+    }
+    /**
+     * Get telemetry data (only available in unified mode)
+     */
+    getTelemetry() {
+        return {
+            snapshot: this.uiController.getTelemetrySnapshot(),
+            performance: this.uiController.getPerformanceSummary(),
+        };
+    }
+    /**
+     * Get action description for tool execution (Claude Code style)
+     * Returns a human-readable description of what the tool is doing
+     * Includes the actual file path, command, or search target when available
+     */
+    getToolActionDescription(call, progress) {
+        const args = call.arguments;
+        let description;
+        switch (call.name) {
+            case 'Read':
+            case 'read_file': {
+                const filePath = this.extractPath(args, ['file_path', 'path']);
+                description = filePath ? `Reading ${this.truncatePath(filePath)}` : 'Reading file...';
+                break;
+            }
+            case 'Write':
+            case 'write_file': {
+                const filePath = this.extractPath(args, ['file_path', 'path']);
+                description = filePath ? `Writing ${this.truncatePath(filePath)}` : 'Writing file...';
+                break;
+            }
+            case 'Edit':
+            case 'edit_file': {
+                const filePath = this.extractPath(args, ['file_path', 'path']);
+                description = filePath ? `Editing ${this.truncatePath(filePath)}` : 'Editing file...';
+                break;
+            }
+            case 'Bash':
+            case 'bash': {
+                const command = args?.['command'];
+                if (command) {
+                    // Show first meaningful part of command (truncated)
+                    const shortCmd = command.split('\n')[0]?.trim() || command;
+                    const truncated = shortCmd.length > 40 ? `${shortCmd.slice(0, 37)}...` : shortCmd;
+                    description = `Running: ${truncated}`;
+                }
+                else {
+                    description = 'Executing command...';
+                }
+                break;
+            }
+            case 'Grep':
+            case 'grep': {
+                const pattern = args?.['pattern'];
+                const path = this.extractPath(args, ['path', 'directory']);
+                if (pattern) {
+                    const truncPattern = pattern.length > 20 ? `${pattern.slice(0, 17)}...` : pattern;
+                    description = path
+                        ? `Searching "${truncPattern}" in ${this.truncatePath(path)}`
+                        : `Searching for "${truncPattern}"`;
+                }
+                else {
+                    description = 'Searching code...';
+                }
+                break;
+            }
+            case 'Glob':
+            case 'glob': {
+                const pattern = args?.['pattern'];
+                description = pattern ? `Finding files: ${pattern}` : 'Finding files...';
+                break;
+            }
+            case 'WebFetch':
+            case 'web_fetch': {
+                const url = args?.['url'];
+                if (url) {
+                    try {
+                        const hostname = new URL(url).hostname;
+                        description = `Fetching ${hostname}`;
+                    }
+                    catch {
+                        description = 'Fetching web content...';
+                    }
+                }
+                else {
+                    description = 'Fetching web content...';
+                }
+                break;
+            }
+            case 'WebSearch':
+            case 'web_search': {
+                const query = args?.['query'];
+                if (query) {
+                    const truncQuery = query.length > 30 ? `${query.slice(0, 27)}...` : query;
+                    description = `Searching: "${truncQuery}"`;
+                }
+                else {
+                    description = 'Searching web...';
+                }
+                break;
+            }
+            case 'Task':
+            case 'task': {
+                const taskDesc = args?.['description'];
+                description = taskDesc ? `Task: ${taskDesc}` : 'Running task...';
+                break;
+            }
+            default:
+                description = `Executing ${call.name}...`;
+        }
+        if (progress) {
+            const details = [];
+            if (progress.message?.trim()) {
+                details.push(progress.message.trim());
+            }
+            if (typeof progress.total === 'number' && progress.total > 0) {
+                const pct = Math.max(0, Math.min(100, Math.round((progress.current / progress.total) * 100)));
+                details.push(`${pct}%`);
+            }
+            if (details.length) {
+                return `${description} (${details.join(' ')})`;
+            }
+        }
+        return description;
+    }
+    /**
+     * Extract a path from tool arguments, checking multiple possible keys
+     */
+    extractPath(args, keys) {
+        if (!args)
+            return undefined;
+        for (const key of keys) {
+            const value = args[key];
+            if (typeof value === 'string' && value.trim()) {
+                return value.trim();
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Truncate a file path to show just the filename or last path segments
+     * e.g., "/Users/bo/GitHub/project/src/ui/display.ts" -> "src/ui/display.ts"
+     */
+    truncatePath(fullPath, maxLen = 50) {
+        if (fullPath.length <= maxLen)
+            return fullPath;
+        const parts = fullPath.split('/').filter(Boolean);
+        if (parts.length <= 2)
+            return fullPath;
+        // Start from the end and build up until we exceed maxLen
+        let result = parts[parts.length - 1] || '';
+        for (let i = parts.length - 2; i >= 0; i--) {
+            const candidate = `${parts[i]}/${result}`;
+            if (candidate.length > maxLen - 3) {
+                return `.../${result}`;
+            }
+            result = candidate;
+        }
+        return result;
+    }
+    /**
+     * Set file change tracking callback
+     */
+    setFileChangeCallback(callback) {
+        this.fileChangeCallback = callback;
+    }
+    /**
+     * Set tool status callback - called when tools start/complete to update dynamic status
+     */
+    setToolStatusCallback(callback) {
+        this._toolStatusCallback = callback;
+    }
+    /**
+     * Parse file changes from Edit/Write/NotebookEdit tool output
+     */
+    parseFileChange(call, output) {
+        const args = call.arguments;
+        // Handle different path parameter names: file_path (Edit/Write), notebook_path (NotebookEdit)
+        const path = args.file_path || args.notebook_path || args.path;
+        if (!path)
+            return null;
+        // Parse additions and removals from output
+        let additions = 0;
+        let removals = 0;
+        // For Edit tool: parse "Lines changed: +X / -Y" or "+X addition -Y removal"
+        const editMatch = output.match(/\+(\d+).*-(\d+)/);
+        if (editMatch) {
+            additions = parseInt(editMatch[1] || '0', 10);
+            removals = parseInt(editMatch[2] || '0', 10);
+        }
+        // Alternative format: "X addition" and "Y removal"
+        const addMatch = output.match(/(\d+)\s+addition/);
+        const remMatch = output.match(/(\d+)\s+removal/);
+        if (addMatch)
+            additions = parseInt(addMatch[1] || '0', 10);
+        if (remMatch)
+            removals = parseInt(remMatch[1] || '0', 10);
+        // For Write tool: estimate as all additions (new file or full rewrite)
+        if (call.name === 'Write' && additions === 0 && removals === 0) {
+            const lines = (args.content || '').split('\n').length;
+            additions = lines;
+        }
+        // For NotebookEdit: estimate based on new_source content
+        if (call.name === 'NotebookEdit' && additions === 0 && removals === 0) {
+            const lines = (args.new_source || '').split('\n').length;
+            additions = lines;
+            removals = lines; // Assume cell replacement
+        }
+        return {
+            path,
+            type: call.name === 'Edit' || call.name === 'NotebookEdit' ? 'edit' : 'write',
+            additions,
+            removals
+        };
+    }
+    /**
+     * 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 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"
+     */
+    formatClaudeCodeResultSummary(toolName, args, output, success) {
+        if (!success) {
+            // Error case - show error message
+            const errorMsg = output.length > 60 ? `${output.slice(0, 57)}...` : output;
+            return theme.error(errorMsg);
+        }
+        switch (toolName) {
+            case 'Read':
+            case 'read_file': {
+                const lines = output.split('\n').length;
+                return `Read ${theme.info(String(lines))} lines`;
+            }
+            case 'Write':
+            case 'write_file': {
+                const path = args['file_path'] || args['path'];
+                const lines = (args['content'] || '').split('\n').length;
+                if (path) {
+                    return `Wrote ${theme.info(String(lines))} lines to ${this.truncatePath(String(path), 40)}`;
+                }
+                return `Wrote ${theme.info(String(lines))} lines`;
+            }
+            case 'Edit':
+            case 'edit_file': {
+                // Parse additions/removals from output
+                const editMatch = output.match(/\+(\d+).*-(\d+)/);
+                if (editMatch) {
+                    const adds = editMatch[1];
+                    const removes = editMatch[2];
+                    return `${theme.success(`+${adds}`)} ${theme.error(`-${removes}`)} lines`;
+                }
+                return 'Updated file';
+            }
+            case 'Grep':
+            case 'grep':
+            case 'Search': {
+                const outputLines = output.trim().split('\n').filter(l => l.trim());
+                const count = outputLines.length;
+                const outputMode = args['output_mode'];
+                if (count === 0) {
+                    return theme.ui.muted('No matches found');
+                }
+                if (outputMode === 'content') {
+                    return `Found ${theme.info(String(count))} lines`;
+                }
+                return `Found ${theme.info(String(count))} files`;
+            }
+            case 'Glob':
+            case 'glob': {
+                const files = output.trim().split('\n').filter(f => f.trim());
+                const count = files.length;
+                if (count === 0) {
+                    return theme.ui.muted('No files found');
+                }
+                return `Found ${theme.info(String(count))} file${count === 1 ? '' : 's'}`;
+            }
+            case 'Bash':
+            case 'bash': {
+                const lines = output.trim().split('\n').filter(l => l).length;
+                if (lines === 0) {
+                    return theme.ui.muted('Completed (no output)');
+                }
+                return `Output: ${theme.info(String(lines))} lines`;
+            }
+            case 'WebFetch':
+            case 'web_fetch': {
+                const size = output.length;
+                const sizeStr = size > 1024 ? `${(size / 1024).toFixed(1)}KB` : `${size}B`;
+                return `Fetched ${theme.info(sizeStr)}`;
+            }
+            case 'WebSearch':
+            case 'web_search': {
+                const resultMatches = output.match(/^\d+\./gm);
+                const count = resultMatches ? resultMatches.length : 'multiple';
+                return `Found ${theme.info(String(count))} results`;
+            }
+            case 'Task':
+            case 'task': {
+                // Parse agent output to show nested tool summaries
+                return this.formatAgentResultSummary(output);
+            }
+            case 'TodoWrite':
+            case 'todo_write': {
+                const todos = args['todos'];
+                if (todos && Array.isArray(todos)) {
+                    const completed = todos.filter(t => t.status === 'completed').length;
+                    const inProgress = todos.filter(t => t.status === 'in_progress').length;
+                    const pending = todos.length - completed - inProgress;
+                    const parts = [];
+                    if (completed > 0)
+                        parts.push(theme.success(`${completed} done`));
+                    if (inProgress > 0)
+                        parts.push(theme.warning(`${inProgress} active`));
+                    if (pending > 0)
+                        parts.push(theme.ui.muted(`${pending} pending`));
+                    return `Todos: ${parts.join(', ')}`;
+                }
+                return 'Todos updated';
+            }
+            default: {
+                // Generic result
+                const lines = output.trim().split('\n').filter(l => l).length;
+                if (lines === 0) {
+                    return 'Completed';
+                }
+                if (lines <= 3) {
+                    return 'Completed';
+                }
+                return `${theme.info(String(lines))} lines`;
+            }
+        }
+    }
+    /**
+     * Format agent/task result summary showing nested tool uses
+     * Example output:
+     *   Read 100 lines
+     *   Found 4 lines
+     *   +31 more tool uses
+     */
+    formatAgentResultSummary(output) {
+        const lines = [];
+        // Parse output for tool use summaries
+        // Look for patterns like "Read X lines", "Found X files", "Output: X lines", etc.
+        const toolPatterns = [
+            /Read\s+(\d+)\s+lines?/gi,
+            /Found\s+(\d+)\s+(?:files?|lines?|results?|matches?)/gi,
+            /Output:\s+(\d+)\s+lines?/gi,
+            /Wrote\s+(\d+)\s+lines?/gi,
+            /Fetched\s+[\d.]+[KMB]?B?/gi,
+            /Completed/gi,
+            /Updated\s+file/gi,
+            /\+\d+\s+-\d+\s+lines?/gi,
+        ];
+        const toolUses = [];
+        const seenPatterns = new Set();
+        for (const pattern of toolPatterns) {
+            const matches = output.matchAll(pattern);
+            for (const match of matches) {
+                const text = match[0];
+                if (!seenPatterns.has(text.toLowerCase())) {
+                    seenPatterns.add(text.toLowerCase());
+                    toolUses.push(text);
+                }
+            }
+        }
+        // Show first 2 tool uses, then "+N more"
+        const maxShown = 2;
+        const shown = toolUses.slice(0, maxShown);
+        const remaining = toolUses.length - maxShown;
+        for (const use of shown) {
+            lines.push(use);
+        }
+        if (remaining > 0) {
+            lines.push(`+${remaining} more tool uses`);
+        }
+        else if (lines.length === 0) {
+            // Fallback if no tool uses found
+            const outputLines = output.trim().split('\n').filter(l => l.trim()).length;
+            if (outputLines > 0) {
+                return `${theme.info(String(outputLines))} lines`;
+            }
+            return 'Completed';
+        }
+        return lines.join('\n     ');
+    }
+    /**
+     * Get UI state
+     */
+    getState() {
+        return this.uiController.getState();
+    }
+    /**
+     * Dispose of resources
+     */
+    dispose() {
+        // Clear any pending timeouts to prevent process hang
+        if (this.profileSwitcherTimeout) {
+            clearTimeout(this.profileSwitcherTimeout);
+            this.profileSwitcherTimeout = undefined;
+        }
+        this.uiController.dispose();
+    }
+}
+//# sourceMappingURL=ShellUIAdapter.js.map