erosolar-cli 1.7.392 → 1.7.394

package/dist/shell/terminalInput.js

@@ -118,9 +118,9 @@ export class TerminalInput extends EventEmitter {
     editMode = 'display-edits';
     verificationEnabled = true;
     autoContinueEnabled = false;
-    verificationHotkey = 'alt+v';
-    autoContinueHotkey = 'alt+c';
-    thinkingHotkey = '/thinking';
+    verificationHotkey = 'ctrl+shift+v';
+    autoContinueHotkey = 'ctrl+shift+c';
+    thinkingHotkey = 'ctrl+shift+t';
     modelLabel = null;
     providerLabel = null;
     // Streaming render throttle
@@ -293,10 +293,13 @@ export class TerminalInput extends EventEmitter {
         const normalizedName = key?.name ?? this.getArrowKeyName(key?.sequence ?? str);
         const effectiveKey = normalizedName ? { ...key, name: normalizedName } : key;
         const safeStr = this.isArrowEscapeFragment(str) ? undefined : str;
+        let handled = false;
         // Handle control keys
         if (effectiveKey?.ctrl) {
-            this.handleCtrlKey(effectiveKey);
-            return;
+            handled = this.handleCtrlKey(effectiveKey);
+            if (handled) {
+                return;
+            }
         }
         // Handle meta/alt keys
         if (effectiveKey?.meta) {
@@ -458,7 +461,8 @@ export class TerminalInput extends EventEmitter {
     /**
      * Handle selecting a suggestion (Enter key or click)
      */
-    selectSuggestion() {
+    selectSuggestion(options = {}) {
+        const { submit = false } = options;
         if (!this.showingSuggestions)
             return false;
         const filtered = this.getFilteredCommands();
@@ -468,10 +472,14 @@ export class TerminalInput extends EventEmitter {
         if (!selected)
             return false;
         // Replace buffer with selected command
-        this.buffer = selected.command + ' ';
+        const nextBuffer = submit ? selected.command : `${selected.command} `;
+        this.buffer = nextBuffer;
         this.cursor = this.buffer.length;
         this.showingSuggestions = false;
         this.scheduleRender();
+        if (submit) {
+            this.submit();
+        }
         return true;
     }
     /**
@@ -555,7 +563,7 @@ export class TerminalInput extends EventEmitter {
             visibleCount: Math.min(maxDisplay, Math.max(0, filtered.length - startIdx))
         };
         // Header with navigation hint - keep it short
-        lines.push(theme.ui.muted(`Commands (↑↓ Tab Enter)`));
+        lines.push(theme.ui.muted(`Commands (↑↓ Enter to run · Tab to fill)`));
         // Render visible suggestions
         for (let i = 0; i < maxDisplay; i++) {
             const idx = startIdx + i;
@@ -729,8 +737,15 @@ export class TerminalInput extends EventEmitter {
         if (this.isRendering)
             return;
         const streamingActive = this.mode === 'streaming' || isStreamingMode();
-        // During streaming, throttle re-renders
-        if (streamingActive && this.lastStreamingRender > 0) {
+        const bufferChanged = this.buffer !== this.lastRenderContent || this.cursor !== this.lastRenderCursor;
+        // During streaming, throttle re-renders unless the buffer actually changed
+        // (e.g., typing slash commands while streaming should update immediately).
+        const shouldThrottle = streamingActive &&
+            this.lastStreamingRender > 0 &&
+            !this.renderDirty &&
+            !bufferChanged &&
+            !this.showingSuggestions;
+        if (shouldThrottle) {
             const elapsed = Date.now() - this.lastStreamingRender;
             const waitMs = Math.max(0, this.streamingRenderInterval - elapsed);
             if (waitMs > 0) {
@@ -739,9 +754,7 @@ export class TerminalInput extends EventEmitter {
                 return;
             }
         }
-        const shouldSkip = !this.renderDirty &&
-            this.buffer === this.lastRenderContent &&
-            this.cursor === this.lastRenderCursor;
+        const shouldSkip = !this.renderDirty && !bufferChanged;
         this.renderDirty = false;
         if (shouldSkip) {
             return;
@@ -761,6 +774,8 @@ export class TerminalInput extends EventEmitter {
         const { rows, cols } = this.getSize();
         const maxWidth = Math.max(8, cols - 4);
         const streamingActive = this.mode === 'streaming' || isStreamingMode();
+        const prevChatBoxStart = this.lastChatBoxStartRow;
+        const prevChatBoxHeight = this.lastChatBoxHeight;
         // Wrap buffer into display lines
         const { lines, cursorLine, cursorCol } = this.wrapBuffer(maxWidth);
         const maxVisible = Math.max(1, Math.min(this.config.maxLines, rows - 3));
@@ -795,13 +810,16 @@ export class TerminalInput extends EventEmitter {
             if (this.scrollRegionActive) {
                 this.write(ESC.RESET_SCROLL);
             }
-            // Clear the chat box area
-            for (let i = 0; i < chatBoxHeight; i++) {
-                const row = chatBoxStartRow + i;
-                if (row <= rows) {
-                    this.write(ESC.TO(row, 1));
-                    this.write(ESC.CLEAR_LINE);
-                }
+            // Clear the current and previous chat box footprint to avoid ghost text when the height shrinks
+            const prevHeight = prevChatBoxStart !== null ? Math.max(1, prevChatBoxHeight) : chatBoxHeight;
+            const prevStart = prevChatBoxStart ?? chatBoxStartRow;
+            const prevEnd = prevStart + prevHeight - 1;
+            const newEnd = chatBoxStartRow + chatBoxHeight - 1;
+            const clearStart = Math.max(1, Math.min(prevStart, chatBoxStartRow));
+            const clearEnd = Math.min(rows, Math.max(prevEnd, newEnd));
+            for (let row = clearStart; row <= clearEnd; row++) {
+                this.write(ESC.TO(row, 1));
+                this.write(ESC.CLEAR_LINE);
             }
             let currentRow = chatBoxStartRow;
             // Render scroll/status indicator on the left (Claude Code style)
@@ -1080,24 +1098,25 @@ export class TerminalInput extends EventEmitter {
             const contextTone = this.contextUsage > 80 ? 'warn' : this.contextUsage > 60 ? 'info' : 'muted';
             toggleParts.push({ text: `ctx:${remaining}%`, tone: contextTone });
         }
-        // Verification toggle (Alt+V)
-        const verifyStatus = this.verificationEnabled ? '✓' : '○';
+        const verifyHotkey = this.formatHotkey(this.verificationHotkey);
+        const verifyStatus = this.verificationEnabled ? 'Verify on' : 'Verify off';
         toggleParts.push({
-            text: `⌥V:${verifyStatus}verify`,
+            text: `${verifyHotkey} ${verifyStatus}`,
             tone: this.verificationEnabled ? 'success' : 'muted'
         });
-        // Auto-continue toggle (Alt+C)
-        const autoStatus = this.autoContinueEnabled ? '↻' : '○';
+        const autoHotkey = this.formatHotkey(this.autoContinueHotkey);
+        const autoStatus = this.autoContinueEnabled ? 'Auto-continue on' : 'Auto-continue off';
         toggleParts.push({
-            text: `⌥C:${autoStatus}auto`,
+            text: `${autoHotkey} ${autoStatus}`,
             tone: this.autoContinueEnabled ? 'info' : 'muted'
         });
-        // Thinking mode toggle (Alt+T)
+        // Thinking mode toggle
         if (this.thinkingModeLabel) {
             const shortThinking = this.thinkingModeLabel.length > 10
                 ? this.thinkingModeLabel.slice(0, 8) + '..'
                 : this.thinkingModeLabel;
-            toggleParts.push({ text: `⌥T:${shortThinking}`, tone: 'info' });
+            const thinkingHotkey = this.formatHotkey(this.thinkingHotkey);
+            toggleParts.push({ text: `${thinkingHotkey} Thinking ${shortThinking}`, tone: 'info' });
         }
         // Navigation shortcuts - always show these
         toggleParts.push({ text: 'PgUp/Dn:scroll', tone: 'muted' });
@@ -1156,24 +1175,28 @@ export class TerminalInput extends EventEmitter {
             return hotkey;
         const parts = normalized.split('+').filter(Boolean);
         const map = {
-            shift: '⇧',
-            sh: '⇧',
-            alt: '⌥',
-            option: '⌥',
-            opt: '⌥',
-            ctrl: '⌃',
-            control: '⌃',
-            cmd: '⌘',
-            meta: '⌘',
+            shift: 'Shift',
+            sh: 'Shift',
+            alt: 'Alt',
+            option: 'Alt',
+            opt: 'Alt',
+            ctrl: 'Ctrl',
+            control: 'Ctrl',
+            cmd: 'Cmd',
+            meta: 'Cmd',
         };
         const formatted = parts
             .map((part) => {
             const symbol = map[part];
             if (symbol)
                 return symbol;
-            return part.length === 1 ? part.toUpperCase() : part.toUpperCase();
+            if (part.startsWith('/'))
+                return part;
+            if (part.length === 1)
+                return part.toUpperCase();
+            return part.charAt(0).toUpperCase() + part.slice(1);
         })
-            .join('');
+            .join('+');
         return formatted || hotkey;
     }
     computeContextRemaining() {
@@ -1336,8 +1359,16 @@ export class TerminalInput extends EventEmitter {
         finally {
             writeLock.unlock();
         }
-        // Throttle chat box updates during streaming
-        this.scheduleStreamingRender(200);
+        // Throttle chat box updates only when a re-render is needed.
+        // In streaming mode the chat box stays pinned, so skip redundant redraws.
+        const needsRender = !this.scrollRegionActive || this.renderDirty;
+        if (needsRender) {
+            if (!this.scrollRegionActive) {
+                // Content moved; force a render so the chat box follows.
+                this.renderDirty = true;
+            }
+            this.scheduleStreamingRender(200);
+        }
     }
     /**
      * Enable scroll region (no-op in floating mode).
@@ -1531,33 +1562,72 @@ export class TerminalInput extends EventEmitter {
                 else {
                     this.emit('interrupt');
                 }
-                break;
+                return true;
             case 'a': // Home
                 this.moveCursorToLineStart();
-                break;
+                return true;
             case 'e': // End
+                if (key.shift) {
+                    this.toggleEditMode();
+                    this.emit('toggleEditMode');
+                    return true;
+                }
                 this.moveCursorToLineEnd();
-                break;
+                return true;
             case 'u': // Delete to start
                 this.deleteToStart();
-                break;
+                return true;
             case 'k': // Delete to end
                 this.deleteToEnd();
-                break;
+                return true;
             case 'w': // Delete word
                 this.deleteWord();
-                break;
+                return true;
             case 'left': // Word left
                 this.moveCursorWordLeft();
-                break;
+                return true;
             case 'right': // Word right
                 this.moveCursorWordRight();
+                return true;
+            case 'return': // Ctrl+Enter => newline instead of submit
+                this.insertNewline();
+                return true;
+            case 'v':
+                if (key.shift) {
+                    this.emit('toggleVerify');
+                    return true;
+                }
+                break;
+            case 'c':
+                if (key.shift) {
+                    this.emit('toggleAutoContinue');
+                    return true;
+                }
+                break;
+            case 't':
+                if (key.shift) {
+                    this.emit('toggleThinking');
+                    return true;
+                }
+                break;
+            case 'x':
+                if (key.shift) {
+                    this.emit('clearContext');
+                    return true;
+                }
+                break;
+            case 's':
+                if (key.shift) {
+                    this.toggleScrollbackMode();
+                    return true;
+                }
                 break;
         }
+        return false;
     }
     /**
      * Handle Alt/Meta key combinations for mode toggles and navigation.
-     * All major erosolar-cli features accessible via keyboard shortcuts.
+     * Ctrl-based shortcuts are primary; Alt/Meta remains as a compatibility fallback.
      */
     handleMetaKey(key) {
         switch (key.name) {
@@ -1656,12 +1726,12 @@ export class TerminalInput extends EventEmitter {
     handleSpecialKey(_str, key) {
         switch (key.name) {
             case 'return':
-                if (key.shift || key.meta) {
+                if (key.shift || key.meta || key.ctrl) {
                     this.insertNewline();
                 }
                 else if (this.showingSuggestions) {
-                    // Select suggestion and don't submit yet
-                    this.selectSuggestion();
+                    // Select highlighted suggestion and submit immediately
+                    this.selectSuggestion({ submit: true });
                 }
                 else {
                     this.submit();
@@ -1748,7 +1818,7 @@ export class TerminalInput extends EventEmitter {
                 // Scrollback disabled in alternate screen mode
                 return true;
             case 'tab':
-                // Tab can select suggestion too
+                // Tab can select suggestion too without submitting
                 if (this.showingSuggestions && !key.shift) {
                     this.selectSuggestion();
                     return true;
@@ -2184,7 +2254,7 @@ export class TerminalInput extends EventEmitter {
         this.isInScrollbackMode = false;
     }
     /**
-     * Toggle scrollback mode on/off (Alt+S hotkey)
+     * Toggle scrollback mode on/off (Ctrl+Shift+S hotkey; Alt+S legacy)
      * DISABLED: Scrollback navigation causes display corruption in alternate screen mode.
      */
     toggleScrollbackMode() {
@@ -2440,13 +2510,37 @@ export class TerminalInput extends EventEmitter {
             this.streamingRenderTimer = null;
             // During streaming, only update chat box (not full render)
             if (this.scrollRegionActive) {
-                this.renderChatBoxAtBottom();
+                this.renderStreamingFrame();
             }
             else {
                 this.render();
             }
         }, wait);
     }
+    /**
+     * Render the pinned chat box during streaming only when we actually have
+     * pending UI changes. Prevents meta/header lines from being echoed into the
+     * streamed log when nothing changed.
+     */
+    renderStreamingFrame() {
+        if (!this.canRender())
+            return;
+        if (this.isRendering)
+            return;
+        const shouldSkip = !this.renderDirty &&
+            this.buffer === this.lastRenderContent &&
+            this.cursor === this.lastRenderCursor;
+        // Clear the dirty flag even when skipping to avoid runaway retries.
+        this.renderDirty = false;
+        if (shouldSkip) {
+            return;
+        }
+        if (writeLock.isLocked()) {
+            writeLock.safeWrite(() => this.renderStreamingFrame());
+            return;
+        }
+        this.renderPinnedChatBox();
+    }
     resetStreamingRenderThrottle() {
         if (this.streamingRenderTimer) {
             clearTimeout(this.streamingRenderTimer);
@@ -2523,6 +2617,11 @@ export class TerminalInput extends EventEmitter {
     isOrphanedEscapeSequence(text, key) {
         if (!text || key?.name)
             return false;
+        // If sanitizing leaves printable content, treat it as user input.
+        const sanitized = this.sanitize(text);
+        if (sanitized.length > 0) {
+            return false;
+        }
         if (text.includes('\x1b'))
             return true;
         // Common stray fragments when terminals partially echo arrow sequences (e.g., "[D")