erosolar-cli 1.7.383 → 1.7.386

package/dist/shell/terminalInput.js

@@ -67,6 +67,7 @@ const ESC = {
 export class TerminalInput extends EventEmitter {
     out;
     config;
+    inlinePanel = null;
     // Core state
     buffer = '';
     cursor = 0;
@@ -132,6 +133,11 @@ export class TerminalInput extends EventEmitter {
     showingSuggestions = false;
     selectedSuggestionIndex = 0;
     maxVisibleSuggestions = 10;
+    suggestionRenderState = null;
+    lastSuggestionStartRow = null;
+    lastChatBoxStartRow = null;
+    lastChatBoxHeight = 0;
+    displayInterceptorDispose = null;
     constructor(writeStream = process.stdout, config = {}) {
         super();
         this.out = writeStream;
@@ -192,7 +198,9 @@ export class TerminalInput extends EventEmitter {
         let match;
         while ((match = mousePattern.exec(data)) !== null) {
             const button = parseInt(match[1], 10);
-            this.handleMouseEvent(button, 0, 0, match[4]);
+            const x = parseInt(match[2], 10);
+            const y = parseInt(match[3], 10);
+            this.handleMouseEvent(button, x, y, match[4]);
             hadMouseEvents = true;
         }
         if (hadMouseEvents) {
@@ -240,7 +248,7 @@ export class TerminalInput extends EventEmitter {
     /**
      * Handle mouse events (button, x, y coordinates, action)
      */
-    handleMouseEvent(button, _x, _y, _action) {
+    handleMouseEvent(button, x, y, action) {
         // Mouse wheel events: button 64 = scroll up, button 65 = scroll down
         if (button === 64) {
             // Scroll up (3 lines per wheel tick)
@@ -252,6 +260,13 @@ export class TerminalInput extends EventEmitter {
             this.scrollDown(3);
             return;
         }
+        // Left-click selection inside the command suggestions menu
+        if (button === 0 && action === 'M') {
+            if (this.handleSuggestionClick(y)) {
+                return;
+            }
+            // No other left-click handling needed; fall through to consume silently
+        }
         // Left button (0), middle button (1), right button (2)
         // These are captured by SGR mouse tracking but we don't need to handle them
         // Just consume silently - the escape sequence has already been processed
@@ -292,6 +307,10 @@ export class TerminalInput extends EventEmitter {
             if (handled)
                 return;
         }
+        // Ignore orphaned escape fragments that sometimes leak through (e.g., "[D" from arrow keys)
+        if (str && this.isOrphanedEscapeSequence(str, key)) {
+            return;
+        }
         // Insert printable characters
         if (str && !key?.ctrl && !key?.meta) {
             this.insertText(str);
@@ -479,6 +498,26 @@ export class TerminalInput extends EventEmitter {
         this.scheduleRender();
         return true;
     }
+    /**
+     * Handle mouse selection inside the suggestions list.
+     * Returns true if the click selected a command.
+     */
+    handleSuggestionClick(clickRow) {
+        if (!this.showingSuggestions || !this.suggestionRenderState)
+            return false;
+        if (this.lastSuggestionStartRow === null)
+            return false;
+        // First line is the header; suggestions start on the next row
+        const relativeRow = clickRow - this.lastSuggestionStartRow - 1;
+        if (relativeRow < 0)
+            return false;
+        const { startIdx, visibleCount } = this.suggestionRenderState;
+        if (relativeRow >= visibleCount)
+            return false;
+        this.selectedSuggestionIndex = startIdx + relativeRow;
+        this.selectSuggestion();
+        return true;
+    }
     /**
      * Cancel suggestion display (Escape)
      */
@@ -493,6 +532,7 @@ export class TerminalInput extends EventEmitter {
      * Build command suggestion display lines
      */
     buildSuggestionLines(width) {
+        this.suggestionRenderState = null;
         if (!this.showingSuggestions)
             return [];
         const filtered = this.getFilteredCommands();
@@ -508,6 +548,10 @@ export class TerminalInput extends EventEmitter {
             startIdx = Math.max(0, this.selectedSuggestionIndex - padding);
             startIdx = Math.min(startIdx, filtered.length - maxDisplay);
         }
+        this.suggestionRenderState = {
+            startIdx,
+            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)`));
         // Render visible suggestions
@@ -542,6 +586,56 @@ export class TerminalInput extends EventEmitter {
         }
         return lines;
     }
+    /**
+     * Build inline panel lines for settings/menus rendered inside the input area.
+     */
+    buildInlinePanelLines(width) {
+        if (!this.inlinePanel)
+            return [];
+        const panel = this.inlinePanel;
+        const lines = [];
+        const safeWidth = Math.max(10, width - 2);
+        const colorize = (() => {
+            switch (panel.tone) {
+                case 'success':
+                    return theme.success;
+                case 'warning':
+                    return theme.warning;
+                case 'error':
+                    return theme.error;
+                case 'muted':
+                    return theme.ui.muted;
+                default:
+                    return theme.info;
+            }
+        })();
+        if (panel.title) {
+            const wrappedTitle = this.wrapPlainText(panel.title, safeWidth);
+            for (const line of wrappedTitle) {
+                lines.push(theme.primary(line));
+            }
+        }
+        for (const rawLine of panel.lines) {
+            const wrapped = this.wrapPlainText(rawLine, safeWidth);
+            for (const wrappedLine of wrapped) {
+                lines.push(`  ${colorize(wrappedLine)}`);
+            }
+        }
+        return lines;
+    }
+    countInlinePanelLines(width) {
+        if (!this.inlinePanel)
+            return 0;
+        const safeWidth = Math.max(10, width - 2);
+        let count = 0;
+        if (this.inlinePanel.title) {
+            count += this.wrapPlainText(this.inlinePanel.title, safeWidth).length;
+        }
+        for (const rawLine of this.inlinePanel.lines) {
+            count += this.wrapPlainText(rawLine, safeWidth).length;
+        }
+        return count;
+    }
     /**
      * Update the inline status message shown before the prompt (e.g., streaming heartbeat).
      */
@@ -670,6 +764,19 @@ export class TerminalInput extends EventEmitter {
         this.providerLabel = nextProvider;
         this.scheduleRender();
     }
+    /**
+     * Show an inline panel (menus/settings) within the pinned input area.
+     * This keeps configuration flows out of the scrollback history.
+     */
+    setInlinePanel(panel) {
+        if (panel && panel.lines.length === 0) {
+            this.inlinePanel = null;
+            this.scheduleRender();
+            return;
+        }
+        this.inlinePanel = panel ? { ...panel, lines: [...panel.lines] } : null;
+        this.scheduleRender();
+    }
     /**
      * Render the floating input area at contentRow.
      *
@@ -733,9 +840,16 @@ export class TerminalInput extends EventEmitter {
         // ALWAYS pin chat box at absolute bottom
         const chatBoxStartRow = Math.max(1, rows - chatBoxHeight + 1);
         const scrollEnd = chatBoxStartRow - 1;
+        this.lastChatBoxStartRow = chatBoxStartRow;
+        this.lastChatBoxHeight = chatBoxHeight;
+        this.lastSuggestionStartRow = null;
         writeLock.lock('terminalInput.renderPinned');
         this.isRendering = true;
         try {
+            // Ensure content stays above the expanded chat/menu area when idle
+            if (!streamingActive && !this.scrollRegionActive) {
+                this.ensureContentAboveChatBox(chatBoxStartRow, rows);
+            }
             this.write(ESC.SAVE);
             this.write(ESC.HIDE);
             // Temporarily reset scroll region to write chat box cleanly
@@ -773,15 +887,15 @@ export class TerminalInput extends EventEmitter {
                 const line = visibleLines[i] ?? '';
                 const isFirstLine = (startLine + i) === 0;
                 const isCursorLine = i === adjustedCursorLine;
+                const col = isCursorLine ? Math.max(0, Math.min(cursorCol, line.length)) : 0;
                 this.write(ESC.BG_DARK);
                 this.write(ESC.DIM);
                 this.write(isFirstLine ? this.config.promptChar : this.config.continuationChar);
                 this.write(ESC.RESET);
                 this.write(ESC.BG_DARK);
                 if (isCursorLine) {
-                    const col = Math.min(cursorCol, line.length);
                     const before = line.slice(0, col);
-                    const at = col < line.length ? line[col] : ' ';
+                    const at = line.charAt(col) || ' ';
                     const after = col < line.length ? line.slice(col + 1) : '';
                     this.write(before);
                     this.write(ESC.REVERSE + ESC.BOLD);
@@ -795,7 +909,9 @@ export class TerminalInput extends EventEmitter {
                     this.write(line);
                 }
                 // Pad to edge
-                const lineLen = this.config.promptChar.length + line.length + (isCursorLine && cursorCol >= line.length ? 1 : 0);
+                const lineLen = this.config.promptChar.length +
+                    line.length +
+                    (isCursorLine && col >= line.length ? 1 : 0);
                 const padding = Math.max(0, cols - lineLen - 1);
                 if (padding > 0)
                     this.write(' '.repeat(padding));
@@ -804,16 +920,27 @@ export class TerminalInput extends EventEmitter {
             // Command suggestions (shown above controls when "/" is typed)
             const suggestionLines = this.buildSuggestionLines(cols - 2);
             let suggestionRow = currentRow + visibleLines.length;
+            if (suggestionLines.length > 0) {
+                this.lastSuggestionStartRow = suggestionRow;
+            }
             for (const suggestionLine of suggestionLines) {
                 this.write(ESC.TO(suggestionRow, 1));
                 this.write('  '); // Indent to match input
                 this.write(suggestionLine);
                 suggestionRow += 1;
             }
+            // Inline panel (menus/settings) rendered inside the pinned area
+            const panelLines = this.buildInlinePanelLines(cols - 2);
+            let panelRow = suggestionRow;
+            for (const panelLine of panelLines) {
+                this.write(ESC.TO(panelRow, 1));
+                this.write(panelLine);
+                panelRow += 1;
+            }
             // Mode controls lines with all keyboard shortcuts
             // Can be multiple lines during streaming (status + toggles)
             const controlLines = this.buildModeControls(cols);
-            let controlRow = suggestionRow;
+            let controlRow = panelRow;
             for (const controlLine of controlLines) {
                 this.write(ESC.TO(controlRow, 1));
                 this.write(controlLine);
@@ -846,6 +973,69 @@ export class TerminalInput extends EventEmitter {
             this.isRendering = false;
         }
     }
+    /**
+     * Keep assistant/user content above the chat box when it expands (e.g., slash menu).
+     * Scrolls just enough to free space without moving the cursor.
+     */
+    ensureContentAboveChatBox(chatBoxStartRow, rows) {
+        const contentMaxRow = Math.max(1, chatBoxStartRow - 1);
+        if (this.contentRow < contentMaxRow)
+            return;
+        const overflow = (this.contentRow - contentMaxRow) + 1;
+        const scrollLines = Math.min(overflow, rows);
+        this.write(ESC.SAVE);
+        this.write(ESC.TO(rows, 1));
+        this.write('\n'.repeat(scrollLines));
+        this.write(ESC.RESTORE);
+        this.contentRow = contentMaxRow;
+    }
+    /**
+     * Track output written directly by the display (system/assistant messages) so
+     * it is captured in scrollback and accounted for when re-rendering the chat box.
+     */
+    trackExternalOutput(content) {
+        if (!content)
+            return;
+        // Normalize and capture in scrollback for history
+        const normalized = content.replace(/\r/g, '\n');
+        this.addToScrollback(normalized);
+        // Advance content row based on rendered height (accounts for wrapping)
+        const rowsUsed = this.countRenderedRows(normalized);
+        if (rowsUsed > 0) {
+            this.contentRow += rowsUsed;
+            if (!this.scrollRegionActive) {
+                this.scheduleRender();
+            }
+        }
+    }
+    /**
+     * Estimate how many terminal rows the provided content will consume.
+     * Considers ANSI-stripped visible length and terminal width so wrapped lines
+     * correctly advance the tracked cursor position.
+     */
+    countRenderedRows(content) {
+        if (!content)
+            return 0;
+        const width = Math.max(1, this.getSize().cols);
+        const normalized = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        const lines = normalized.split('\n');
+        let rows = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i] ?? '';
+            const visibleLen = this.visibleLength(line);
+            if (visibleLen > 0) {
+                const wraps = Math.ceil(visibleLen / width);
+                if (wraps > 1) {
+                    rows += wraps - 1;
+                }
+            }
+            // Each newline moves the cursor to the start of the next row
+            if (i < lines.length - 1) {
+                rows += 1;
+            }
+        }
+        return rows;
+    }
     /**
      * Build compact meta line above the divider.
      * Shows model/provider and key metrics in a single line.
@@ -1076,6 +1266,28 @@ export class TerminalInput extends EventEmitter {
         const ansiPattern = /\u001B\[[0-?]*[ -/]*[@-~]/g;
         return value.replace(ansiPattern, '').length;
     }
+    wrapPlainText(text, width) {
+        const lines = [];
+        const safeWidth = Math.max(1, width);
+        const words = text.split(/\s+/);
+        let current = '';
+        for (const word of words) {
+            const candidate = current ? `${current} ${word}` : word;
+            if (this.visibleLength(candidate) <= safeWidth) {
+                current = candidate;
+            }
+            else {
+                if (current) {
+                    lines.push(current);
+                }
+                current = word;
+            }
+        }
+        if (current) {
+            lines.push(current);
+        }
+        return lines.length ? lines : [''];
+    }
     /**
      * Debug-only snapshot used by tests to assert rendered strings without
      * needing a TTY. Not used by production code.
@@ -1192,9 +1404,9 @@ export class TerminalInput extends EventEmitter {
         try {
             // Write content - scroll region handles scrolling
             this.write(content);
-            // Track newlines
-            const newlines = (content.match(/\n/g) || []).length;
-            this.contentRow += newlines;
+            // Track rendered rows (handles wrapping)
+            const rowsUsed = this.countRenderedRows(content);
+            this.contentRow += rowsUsed;
         }
         finally {
             writeLock.unlock();
@@ -1229,9 +1441,8 @@ export class TerminalInput extends EventEmitter {
         // Calculate actual input lines needed (wrapped buffer)
         const maxWidth = Math.max(1, cols - 4); // Account for prompt and padding
         const { lines: wrappedLines } = this.wrapBuffer(maxWidth);
-        // Limit input lines to reasonable max (leave room for content)
-        const maxInputLines = Math.min(this.config.maxLines, Math.max(1, Math.floor(rows / 3)));
-        const inputLines = Math.min(wrappedLines.length, maxInputLines);
+        // Allow the chat box to grow with the prompt while respecting any explicit limit
+        const inputLines = Math.max(1, Math.min(wrappedLines.length, this.config.maxLines));
         // Calculate actual control lines (they wrap as needed)
         const controlLines = this.buildModeControls(cols);
         const controlLineCount = Math.max(1, controlLines.length);
@@ -1244,12 +1455,13 @@ export class TerminalInput extends EventEmitter {
             const filtered = this.getFilteredCommands();
             suggestionLines = Math.min(filtered.length, this.maxVisibleSuggestions) + 1; // +1 for header
         }
+        // Inline panel (menus/settings)
+        const inlinePanelLines = this.countInlinePanelLines(cols - 2);
         // Total: meta + divider + input lines + suggestions + controls + buffer
-        // Limit total height to leave room for content (max ~50% of terminal when showing suggestions)
-        const totalHeight = metaLines + 1 + inputLines + suggestionLines + controlLineCount + 1;
-        const maxHeight = this.showingSuggestions
-            ? Math.max(12, Math.floor(rows * 0.5))
-            : Math.max(6, Math.floor(rows * 0.4));
+        // Leave a small buffer so streamed content still has space above the chat box
+        const totalHeight = metaLines + 1 + inputLines + suggestionLines + inlinePanelLines + controlLineCount + 1;
+        const minContentRows = 2;
+        const maxHeight = Math.max(4, rows - minContentRows);
         return Math.min(totalHeight, maxHeight);
     }
     /**
@@ -1257,7 +1469,21 @@ export class TerminalInput extends EventEmitter {
      * Register with display's output interceptor - kept for backwards compatibility
      */
     registerOutputInterceptor(_display) {
-        // No-op: Use streamContent() for cleaner floating chat box behavior
+        const display = _display;
+        if (!display?.registerOutputInterceptor)
+            return;
+        // Remove prior hook if present
+        if (this.displayInterceptorDispose) {
+            this.displayInterceptorDispose();
+            this.displayInterceptorDispose = null;
+        }
+        this.displayInterceptorDispose = display.registerOutputInterceptor({
+            afterWrite: (content) => {
+                if (!content)
+                    return;
+                this.trackExternalOutput(content);
+            },
+        });
     }
     /**
      * Write content above the floating chat box.
@@ -1273,9 +1499,9 @@ export class TerminalInput extends EventEmitter {
             // Position cursor at content row and write
             this.write(ESC.TO(this.contentRow, 1));
             this.write(content);
-            // Track newlines
-            const newlines = (content.match(/\n/g) || []).length;
-            this.contentRow += newlines;
+            // Track rendered rows (handles wrapping)
+            const rowsUsed = this.countRenderedRows(content);
+            this.contentRow += rowsUsed;
         }
         finally {
             writeLock.unlock();
@@ -1359,6 +1585,10 @@ export class TerminalInput extends EventEmitter {
             return;
         this.disposed = true;
         this.enabled = false;
+        if (this.displayInterceptorDispose) {
+            this.displayInterceptorDispose();
+            this.displayInterceptorDispose = null;
+        }
         this.disableScrollRegion();
         this.resetStreamingRenderThrottle();
         this.disableBracketedPaste();
@@ -1856,12 +2086,13 @@ export class TerminalInput extends EventEmitter {
         };
     }
     submit() {
-        const text = this.assembleText().trim();
-        if (!text)
+        const text = this.assembleText();
+        if (!text.trim())
             return;
+        const submission = text;
         // Add to history
-        if (this.history[this.history.length - 1] !== text) {
-            this.history.push(text);
+        if (this.history[this.history.length - 1] !== submission) {
+            this.history.push(submission);
             if (this.history.length > this.maxHistory) {
                 this.history.shift();
             }
@@ -1875,17 +2106,17 @@ export class TerminalInput extends EventEmitter {
             }
             this.queue.push({
                 id: ++this.queueIdCounter,
-                text,
+                text: submission,
                 timestamp: Date.now(),
             });
-            this.emit('queue', text);
+            this.emit('queue', submission);
             this.clear(); // Clear immediately for queued input
         }
         else {
             // In idle mode, clear the input first, then emit submit.
             // The prompt will be logged as a visible message by the caller.
             this.clear();
-            this.emit('submit', text);
+            this.emit('submit', submission);
         }
     }
     finishPaste() {
@@ -2338,6 +2569,20 @@ export class TerminalInput extends EventEmitter {
             .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, '') // Control chars except \n and \r
             .replace(/\r\n?/g, '\n'); // Normalize line endings
     }
+    isOrphanedEscapeSequence(text, key) {
+        if (!text || key?.name)
+            return false;
+        const looksLikeArrowFragment = text.length <= 5 && (/^[\[O][0-9;]*[A-Za-z]$/.test(text));
+        const sanitized = this.sanitize(text);
+        // If sanitization leaves visible text and this isn't an arrow fragment, treat it as real input
+        if (sanitized.trim().length > 0 && !looksLikeArrowFragment) {
+            return false;
+        }
+        if (text.includes('\x1b'))
+            return true;
+        // Common stray fragments when terminals partially echo arrow sequences (e.g., "[D")
+        return looksLikeArrowFragment;
+    }
     isWhitespace(char) {
         return char === ' ' || char === '\t' || char === '\n';
     }