erosolar-cli 1.7.166 → 1.7.168

package/dist/shell/interactiveShell.js

@@ -471,7 +471,7 @@ export class InteractiveShell {
                     this.clearMultiLinePastePreview();
                     const lineCount = normalized.lineCount ?? normalized.result.split('\n').length;
                     // All pastes (single or multi-line) are captured for confirmation before submit
-                    this.capturePaste(normalized.result, lineCount);
+                    void this.capturePaste(normalized.result, lineCount);
                     return;
                 }
                 return;
@@ -546,7 +546,7 @@ export class InteractiveShell {
             const lines = content.split('\n');
             const lineCount = lines.length;
             // All pastes (single or multi-line) are captured for confirmation before submit
-            this.capturePaste(content, lineCount);
+            void this.capturePaste(content, lineCount);
         });
         // Set up raw data interception to catch bracketed paste before readline processes it.
         // We need to actually PREVENT readline from seeing the paste content to avoid echo.
@@ -589,9 +589,24 @@ export class InteractiveShell {
         this.keypressHandler = (_str, key) => {
             // Handle special keys
             if (key) {
-                // Shift+Tab for profile switching
-                if (key.name === 'tab' && key.shift && this.agentMenu) {
-                    this.showProfileSwitcher();
+                // Shift+Tab: Cycle paste preview options if paste blocks exist, otherwise profile switching
+                if (key.name === 'tab' && key.shift) {
+                    // Check if there are paste blocks to cycle through
+                    const pasteBlockCount = this.composableMessage.getPasteBlockCount();
+                    if (pasteBlockCount > 0) {
+                        this.cyclePastePreview();
+                        return;
+                    }
+                    // Fall through to profile switching if no paste blocks
+                    if (this.agentMenu) {
+                        this.showProfileSwitcher();
+                        return;
+                    }
+                }
+                // Tab: Autocomplete slash commands
+                if (key.name === 'tab' && !key.shift && !key.ctrl) {
+                    this.handleTabCompletion();
+                    return;
                 }
                 // Escape: Cancel current operation if agent is running
                 if (key.name === 'escape') {
@@ -638,6 +653,11 @@ export class InteractiveShell {
                     }
                     // If no text in buffer, let default Ctrl+C behavior exit
                 }
+                // Ctrl+G: Edit pasted content blocks
+                if (key.ctrl && key.name === 'g') {
+                    this.showPasteBlockEditor();
+                    return;
+                }
             }
             // Readline handles all keyboard input natively (history, shortcuts, etc.)
             // We just sync the current state to our display components
@@ -970,7 +990,7 @@ export class InteractiveShell {
      * - Longer pastes (3+ lines) show as collapsed block chips
      * Supports multiple pastes - user can paste multiple times before submitting.
      */
-    capturePaste(content, lineCount) {
+    async capturePaste(content, lineCount) {
         this.resetBufferedInputLines();
         // Short pastes (1-2 lines) display inline like normal text
         const isShortPaste = lineCount <= 2;
@@ -1005,7 +1025,26 @@ export class InteractiveShell {
             return;
         }
         // For longer pastes (3+ lines), store as a composable block
-        this.composableMessage.addPaste(content);
+        // Check size limits first
+        const { ComposableMessageBuilder } = await import('./composableMessage.js');
+        const sizeCheck = ComposableMessageBuilder.checkPasteSize(content);
+        if (!sizeCheck.ok) {
+            // Paste rejected - show error and abort
+            display.showError(sizeCheck.error || 'Paste rejected due to size limits');
+            this.rl.prompt();
+            return;
+        }
+        // Show warning for large (but acceptable) pastes
+        if (sizeCheck.warning) {
+            display.showWarning(`⚠️ ${sizeCheck.warning}`);
+        }
+        const pasteId = this.composableMessage.addPaste(content);
+        if (!pasteId) {
+            // Should not happen since we checked above, but handle defensively
+            display.showError('Failed to store paste block');
+            this.rl.prompt();
+            return;
+        }
         // Clear remaining echoed lines from terminal
         output.write('\r\x1b[K');
         // Build the paste chips to show inline with prompt
@@ -1043,6 +1082,277 @@ export class InteractiveShell {
             this.persistentPrompt.updateStatusBar({ message: undefined });
         }
     }
+    /**
+     * Show paste block editor (Ctrl+G)
+     * Allows viewing and editing captured paste blocks before sending
+     *
+     * Features:
+     * - View block content with line numbers
+     * - Edit blocks inline (replace content)
+     * - Remove individual blocks
+     * - Undo/redo paste operations
+     * - Clear all blocks
+     */
+    showPasteBlockEditor() {
+        const state = this.composableMessage.getState();
+        const pasteBlocks = state.parts.filter((p) => p.type === 'paste');
+        if (pasteBlocks.length === 0) {
+            display.showInfo('No pasted content blocks to edit. Paste some content first.');
+            this.rl.prompt();
+            return;
+        }
+        output.write('\n');
+        display.showSystemMessage('📋 Paste Block Editor');
+        output.write('\n');
+        // Display each paste block with preview
+        pasteBlocks.forEach((block, index) => {
+            const lines = block.content.split('\n');
+            const preview = lines.slice(0, 3).map((l) => `  ${l.slice(0, 60)}${l.length > 60 ? '...' : ''}`).join('\n');
+            const moreLines = lines.length > 3 ? `\n  ... +${lines.length - 3} more lines` : '';
+            const editedFlag = block.edited ? theme.warning(' [edited]') : '';
+            output.write(theme.ui.muted(`[${index + 1}] `) + theme.info(`${block.lineCount} lines, ${block.content.length} chars`) + editedFlag + '\n');
+            output.write(theme.secondary(preview + moreLines) + '\n\n');
+        });
+        // Show undo/redo status
+        const canUndo = this.composableMessage.canUndo();
+        const canRedo = this.composableMessage.canRedo();
+        if (canUndo || canRedo) {
+            const undoStatus = canUndo ? theme.success('undo available') : theme.ui.muted('undo unavailable');
+            const redoStatus = canRedo ? theme.success('redo available') : theme.ui.muted('redo unavailable');
+            output.write(theme.ui.muted('History: ') + undoStatus + theme.ui.muted(' │ ') + redoStatus + '\n\n');
+        }
+        output.write(theme.ui.muted('Commands: ') + '\n');
+        output.write(theme.ui.muted('  • Enter number to view full block') + '\n');
+        output.write(theme.ui.muted('  • "edit N" to replace block N content') + '\n');
+        output.write(theme.ui.muted('  • "remove N" to remove block N') + '\n');
+        output.write(theme.ui.muted('  • "undo" / "redo" to undo/redo changes') + '\n');
+        output.write(theme.ui.muted('  • "clear" to remove all blocks') + '\n');
+        output.write(theme.ui.muted('  • Enter to return to prompt') + '\n');
+        output.write('\n');
+        // Set up interaction mode for paste editing
+        this.pendingInteraction = { type: 'paste-edit' };
+        this.rl.prompt();
+    }
+    /**
+     * Handle paste block editor input
+     */
+    async handlePasteEditInput(trimmedInput) {
+        const trimmed = trimmedInput.toLowerCase();
+        const state = this.composableMessage.getState();
+        const pasteBlocks = state.parts.filter((p) => p.type === 'paste');
+        if (!trimmed) {
+            // Exit paste edit mode
+            this.pendingInteraction = null;
+            display.showInfo('Returned to prompt.');
+            this.rl.prompt();
+            return;
+        }
+        // Handle undo command
+        if (trimmed === 'undo') {
+            if (this.composableMessage.undo()) {
+                this.updateComposeStatusSummary();
+                this.refreshPasteChipsDisplay();
+                display.showInfo('Undone.');
+                // Refresh the paste block view
+                this.showPasteBlockEditor();
+            }
+            else {
+                display.showWarning('Nothing to undo.');
+                this.rl.prompt();
+            }
+            return;
+        }
+        // Handle redo command
+        if (trimmed === 'redo') {
+            if (this.composableMessage.redo()) {
+                this.updateComposeStatusSummary();
+                this.refreshPasteChipsDisplay();
+                display.showInfo('Redone.');
+                // Refresh the paste block view
+                this.showPasteBlockEditor();
+            }
+            else {
+                display.showWarning('Nothing to redo.');
+                this.rl.prompt();
+            }
+            return;
+        }
+        if (trimmed === 'clear') {
+            this.composableMessage.clear();
+            this.updateComposeStatusSummary();
+            this.persistentPrompt.updateInput('', 0);
+            this.rl.line = '';
+            this.rl.cursor = 0;
+            this.pendingInteraction = null;
+            display.showInfo('Cleared all paste blocks.');
+            this.rl.prompt();
+            return;
+        }
+        // Handle "edit N" command - start inline editing mode
+        const editMatch = trimmed.match(/^edit\s+(\d+)$/);
+        if (editMatch) {
+            const blockNum = parseInt(editMatch[1], 10);
+            if (blockNum >= 1 && blockNum <= pasteBlocks.length) {
+                const block = pasteBlocks[blockNum - 1];
+                if (block) {
+                    // Enter edit mode for this block
+                    this.pendingInteraction = { type: 'paste-edit-block', blockId: block.id, blockNum };
+                    output.write('\n');
+                    display.showSystemMessage(`Editing Block ${blockNum}:`);
+                    output.write(theme.ui.muted('Paste or type new content. Press Enter twice to finish, or "cancel" to abort.\n'));
+                    output.write('\n');
+                    // Show current content as reference
+                    const preview = block.content.split('\n').slice(0, 5).map((l) => theme.ui.muted(`  ${l.slice(0, 60)}`)).join('\n');
+                    output.write(theme.ui.muted('Current content (first 5 lines):\n') + preview + '\n\n');
+                }
+            }
+            else {
+                display.showWarning(`Invalid block number. Use 1-${pasteBlocks.length}.`);
+            }
+            this.rl.prompt();
+            return;
+        }
+        // Handle "remove N" command
+        const removeMatch = trimmed.match(/^remove\s+(\d+)$/);
+        if (removeMatch) {
+            const blockNum = parseInt(removeMatch[1], 10);
+            if (blockNum >= 1 && blockNum <= pasteBlocks.length) {
+                const block = pasteBlocks[blockNum - 1];
+                if (block) {
+                    this.composableMessage.removePart(block.id);
+                    this.updateComposeStatusSummary();
+                    this.refreshPasteChipsDisplay();
+                    display.showInfo(`Removed block ${blockNum}.`);
+                    // Check if any blocks remain
+                    const remaining = this.composableMessage.getState().parts.filter(p => p.type === 'paste');
+                    if (remaining.length === 0) {
+                        this.pendingInteraction = null;
+                        display.showInfo('No more paste blocks.');
+                    }
+                }
+            }
+            else {
+                display.showWarning(`Invalid block number. Use 1-${pasteBlocks.length}.`);
+            }
+            this.rl.prompt();
+            return;
+        }
+        // Handle viewing a block by number
+        const blockNum = parseInt(trimmed, 10);
+        if (!Number.isNaN(blockNum) && blockNum >= 1 && blockNum <= pasteBlocks.length) {
+            const block = pasteBlocks[blockNum - 1];
+            if (block) {
+                output.write('\n');
+                display.showSystemMessage(`Block ${blockNum} Content:`);
+                output.write('\n');
+                // Show full content with line numbers
+                const lines = block.content.split('\n');
+                lines.forEach((line, i) => {
+                    const lineNum = theme.ui.muted(`${String(i + 1).padStart(4)} │ `);
+                    output.write(lineNum + line + '\n');
+                });
+                output.write('\n');
+            }
+            this.rl.prompt();
+            return;
+        }
+        display.showWarning('Enter a block number, "edit N", "remove N", "undo", "redo", "clear", or press Enter to return.');
+        this.rl.prompt();
+    }
+    /**
+     * Handle paste block inline editing mode
+     */
+    editBlockBuffer = [];
+    async handlePasteBlockEditInput(input, blockId, blockNum) {
+        // Check for cancel
+        if (input.toLowerCase() === 'cancel') {
+            this.editBlockBuffer = [];
+            this.pendingInteraction = { type: 'paste-edit' };
+            display.showInfo('Edit cancelled.');
+            this.showPasteBlockEditor();
+            return;
+        }
+        // Empty line - check if this is end of edit (double Enter)
+        if (!input.trim()) {
+            if (this.editBlockBuffer.length > 0) {
+                // Complete the edit
+                const newContent = this.editBlockBuffer.join('\n');
+                this.composableMessage.editPaste(blockId, newContent);
+                this.editBlockBuffer = [];
+                this.updateComposeStatusSummary();
+                this.refreshPasteChipsDisplay();
+                display.showInfo(`Block ${blockNum} updated (${newContent.split('\n').length} lines).`);
+                this.pendingInteraction = { type: 'paste-edit' };
+                this.showPasteBlockEditor();
+                return;
+            }
+            // First empty line with no buffer - just prompt again
+            this.rl.prompt();
+            return;
+        }
+        // Add line to edit buffer
+        this.editBlockBuffer.push(input);
+        this.rl.prompt();
+    }
+    /**
+     * Refresh paste chips display in prompt
+     */
+    refreshPasteChipsDisplay() {
+        const chips = this.composableMessage.formatPasteChips();
+        this.persistentPrompt.updateInput(chips ? chips + ' ' : '', chips ? chips.length + 1 : 0);
+        this.rl.line = chips ? chips + ' ' : '';
+        this.rl.cursor = chips ? chips.length + 1 : 0;
+    }
+    /**
+     * Cycle paste preview mode (Shift+Tab)
+     * Cycles through: collapsed → summary → expanded
+     */
+    pastePreviewMode = 'collapsed';
+    cyclePastePreview() {
+        const state = this.composableMessage.getState();
+        const pasteBlocks = state.parts.filter((p) => p.type === 'paste');
+        if (pasteBlocks.length === 0) {
+            return;
+        }
+        // Cycle through modes
+        const modes = ['collapsed', 'summary', 'expanded'];
+        const currentIndex = modes.indexOf(this.pastePreviewMode);
+        this.pastePreviewMode = modes[(currentIndex + 1) % modes.length];
+        output.write('\n');
+        switch (this.pastePreviewMode) {
+            case 'collapsed':
+                // Show just chips
+                display.showSystemMessage(`📋 Preview: Collapsed (${pasteBlocks.length} block${pasteBlocks.length > 1 ? 's' : ''})`);
+                output.write(theme.ui.muted(this.composableMessage.formatPasteChips()) + '\n');
+                break;
+            case 'summary':
+                // Show blocks with first line preview
+                display.showSystemMessage('📋 Preview: Summary');
+                pasteBlocks.forEach((block, i) => {
+                    const preview = block.summary.length > 60 ? block.summary.slice(0, 57) + '...' : block.summary;
+                    output.write(theme.ui.muted(`[${i + 1}] `) + theme.info(`${block.lineCount}L`) + theme.ui.muted(` ${preview}`) + '\n');
+                });
+                break;
+            case 'expanded':
+                // Show full content (up to 10 lines each)
+                display.showSystemMessage('📋 Preview: Expanded');
+                pasteBlocks.forEach((block, i) => {
+                    output.write(theme.ui.muted(`[${i + 1}] `) + theme.info(`${block.lineCount} lines, ${block.content.length} chars`) + '\n');
+                    const lines = block.content.split('\n').slice(0, 10);
+                    lines.forEach((line, j) => {
+                        const lineNum = theme.ui.muted(`${String(j + 1).padStart(3)} │ `);
+                        output.write(lineNum + line.slice(0, 80) + (line.length > 80 ? '...' : '') + '\n');
+                    });
+                    if (block.lineCount > 10) {
+                        output.write(theme.ui.muted(`    ... +${block.lineCount - 10} more lines\n`));
+                    }
+                    output.write('\n');
+                });
+                break;
+        }
+        output.write(theme.ui.muted('(Shift+Tab to cycle preview modes)') + '\n\n');
+        this.rl.prompt(true);
+    }
     async flushBufferedInput() {
         if (!this.bufferedInputLines.length) {
             this.bufferedInputTimer = null;
@@ -1359,6 +1669,12 @@ export class InteractiveShell {
             case 'agent-selection':
                 await this.handleAgentSelectionInput(input);
                 return true;
+            case 'paste-edit':
+                await this.handlePasteEditInput(input);
+                return true;
+            case 'paste-edit-block':
+                await this.handlePasteBlockEditInput(input, this.pendingInteraction.blockId, this.pendingInteraction.blockNum);
+                return true;
             default:
                 return false;
         }
@@ -1473,6 +1789,100 @@ export class InteractiveShell {
         ];
         display.showSystemMessage(info.join('\n'));
     }
+    /**
+     * Handle Tab key for slash command autocompletion
+     * Completes partial slash commands like /mo -> /model
+     */
+    handleTabCompletion() {
+        const currentLine = this.rl.line || '';
+        const cursorPos = this.rl.cursor || 0;
+        // Only complete if line starts with /
+        if (!currentLine.startsWith('/')) {
+            return;
+        }
+        // Get the partial command (from / to cursor)
+        const partial = currentLine.slice(0, cursorPos).toLowerCase();
+        // Available slash commands
+        const commands = [
+            '/help',
+            '/model',
+            '/secrets',
+            '/tools',
+            '/doctor',
+            '/clear',
+            '/cancel',
+            '/compact',
+            '/cost',
+            '/status',
+            '/undo',
+            '/redo',
+        ];
+        // Find matching commands
+        const matches = commands.filter(cmd => cmd.startsWith(partial));
+        if (matches.length === 0) {
+            // No matches - beep or do nothing
+            return;
+        }
+        if (matches.length === 1) {
+            // Single match - complete it
+            const completion = matches[0];
+            const suffix = currentLine.slice(cursorPos);
+            const newLine = completion + suffix;
+            const newCursor = completion.length;
+            // Update readline
+            this.rl.line = newLine;
+            this.rl.cursor = newCursor;
+            // Redraw
+            output.write('\r\x1b[K'); // Clear line
+            output.write(formatUserPrompt(this.profileLabel || this.profile));
+            output.write(newLine);
+            // Position cursor
+            if (suffix.length > 0) {
+                output.write(`\x1b[${suffix.length}D`);
+            }
+            // Sync to display components
+            this.persistentPrompt.updateInput(newLine, newCursor);
+            this.pinnedChatBox.setInput(newLine, newCursor);
+        }
+        else {
+            // Multiple matches - show them
+            output.write('\n');
+            output.write(theme.ui.muted('Completions: ') + matches.join('  ') + '\n');
+            this.rl.prompt();
+            // Find common prefix for partial completion
+            const commonPrefix = this.findCommonPrefix(matches);
+            if (commonPrefix.length > partial.length) {
+                const suffix = currentLine.slice(cursorPos);
+                const newLine = commonPrefix + suffix;
+                const newCursor = commonPrefix.length;
+                this.rl.line = newLine;
+                this.rl.cursor = newCursor;
+                this.persistentPrompt.updateInput(newLine, newCursor);
+                this.pinnedChatBox.setInput(newLine, newCursor);
+            }
+        }
+    }
+    /**
+     * Find the longest common prefix among strings
+     */
+    findCommonPrefix(strings) {
+        if (strings.length === 0)
+            return '';
+        if (strings.length === 1)
+            return strings[0];
+        let prefix = strings[0];
+        for (let i = 1; i < strings.length; i++) {
+            const str = strings[i];
+            let j = 0;
+            while (j < prefix.length && j < str.length && prefix[j] === str[j]) {
+                j++;
+            }
+            prefix = prefix.slice(0, j);
+            if (prefix.length === 0)
+                break;
+        }
+        return prefix;
+    }
     runDoctor() {
         const lines = [];
         lines.push(theme.bold('Environment diagnostics'));
@@ -2523,7 +2933,9 @@ export class InteractiveShell {
         try {
             // Add visual separator between user prompt and AI response
             display.newLine();
-            display.newLine();
+            // Claude Code style: Show unified streaming header before response
+            // This provides visual consistency with the startup Ready bar
+            display.showStreamingHeader();
             // Claude Code style: Start streaming mode using UnifiedChatBox
             // - Output flows naturally to stdout (NO cursor manipulation)
             // - User input is captured invisibly and queued
@@ -2611,6 +3023,8 @@ export class InteractiveShell {
         display.showSystemMessage(`📊 Using intelligent task completion detection with AI verification.`);
         this.uiAdapter.startProcessing('Continuous execution mode');
         this.setProcessingStatus();
+        // Claude Code style: Show unified streaming header before response
+        display.showStreamingHeader();
         // Claude Code style: Start streaming mode using UnifiedChatBox
         // - Output flows naturally to stdout (NO cursor manipulation)
         // - User input is captured invisibly and queued