erosolar-cli 1.7.184 → 1.7.185

package/dist/ui/persistentPrompt.js

@@ -246,6 +246,12 @@ export class PinnedChatBox {
     pastedFullContent = '';
     /** Cleanup function for output interceptor registration */
     outputInterceptorCleanup;
+    // Render deduplication - prevent duplicate displays
+    lastRenderedContent = '';
+    lastRenderedCursor = -1;
+    lastRenderedRows = 0;
+    lastRenderedCols = 0;
+    isRendering = false; // Render lock to prevent concurrent renders
     constructor(writeStream, _promptText = '> ', // Unused - readline handles input display
     options = {}) {
         this.writeStream = writeStream;
@@ -315,6 +321,8 @@ export class PinnedChatBox {
         const scrollBottom = rows - this.reservedLines;
         // Step 1: Set scroll region (excludes bottom reserved lines)
         this.safeWrite(ANSI.SET_SCROLL_REGION(1, scrollBottom));
+        // Invalidate render state to ensure fresh render in the new scroll region
+        this.invalidateRenderedState();
         // Step 2: Render the prompt in the protected bottom area
         this.renderPersistentInput();
         // Mark scroll region as active AFTER rendering
@@ -344,14 +352,52 @@ export class PinnedChatBox {
         // Move cursor to the end of the terminal
         this.safeWrite(ANSI.CURSOR_TO_BOTTOM(rows));
     }
+    /**
+     * Check if render is needed by comparing with last rendered state.
+     * Returns true if content, cursor, or terminal size has changed.
+     */
+    needsRender() {
+        const rows = this.writeStream.rows || 24;
+        const cols = this.writeStream.columns || 80;
+        // Check if anything changed that requires a re-render
+        if (this.inputBuffer !== this.lastRenderedContent)
+            return true;
+        if (this.cursorPosition !== this.lastRenderedCursor)
+            return true;
+        if (rows !== this.lastRenderedRows)
+            return true;
+        if (cols !== this.lastRenderedCols)
+            return true;
+        return false;
+    }
+    /**
+     * Update last rendered state after successful render.
+     */
+    updateRenderedState() {
+        this.lastRenderedContent = this.inputBuffer;
+        this.lastRenderedCursor = this.cursorPosition;
+        this.lastRenderedRows = this.writeStream.rows || 24;
+        this.lastRenderedCols = this.writeStream.columns || 80;
+    }
+    /**
+     * Reset rendered state to force next render.
+     */
+    invalidateRenderedState() {
+        this.lastRenderedContent = '';
+        this.lastRenderedCursor = -1;
+        this.lastRenderedRows = 0;
+        this.lastRenderedCols = 0;
+    }
     /**
      * Render the persistent input area at the bottom of the terminal.
      *
      * CLEAN CLAUDE CODE STYLE:
      * - Line 1: Simple separator with optional queue count
-     * - Line 2: Clean prompt "> " with input and visible block cursor
+     * - Line 2+: Clean prompt "> " with input and visible block cursor
      *
      * Key for clean rendering:
+     * - Render deduplication via content/cursor comparison
+     * - Render lock to prevent concurrent renders
      * - Hide cursor during render (prevents flicker)
      * - Clear lines completely before writing
      * - Reset styles explicitly
@@ -361,63 +407,135 @@ export class PinnedChatBox {
     renderPersistentInput() {
         if (!this.supportsRendering())
             return;
-        const rows = this.writeStream.rows || 24;
-        const cols = Math.max(this.writeStream.columns || 80, 40);
-        // ANSI codes - keep simple, no theme functions
-        const HIDE_CURSOR = '\x1b[?25l';
-        const SHOW_CURSOR = '\x1b[?25h';
-        const REVERSE_VIDEO = '\x1b[7m';
-        const RESET = '\x1b[0m';
-        const DIM = '\x1b[2m';
-        // Hide cursor during render
-        this.safeWrite(HIDE_CURSOR);
-        this.safeWrite(RESET);
-        // Line 1: Separator (at row N-1)
-        this.safeWrite(ANSI.CURSOR_TO_BOTTOM(rows - 1));
-        this.safeWrite(ANSI.CLEAR_LINE);
-        const separatorWidth = Math.min(cols - 2, 60);
-        this.safeWrite(DIM);
-        this.safeWrite('─'.repeat(separatorWidth));
-        this.safeWrite(RESET);
-        // Queue count hint if processing
-        const queueCount = this.state.queuedCommands.length;
-        if (this.state.isProcessing && queueCount > 0) {
+        // Render lock - prevent concurrent renders that cause flicker
+        if (this.isRendering)
+            return;
+        // Deduplication - skip if nothing changed
+        if (!this.needsRender())
+            return;
+        this.isRendering = true;
+        try {
+            const rows = this.writeStream.rows || 24;
+            const cols = Math.max(this.writeStream.columns || 80, 40);
+            // ANSI codes - keep simple, no theme functions
+            const HIDE_CURSOR = '\x1b[?25l';
+            const SHOW_CURSOR = '\x1b[?25h';
+            const REVERSE_VIDEO = '\x1b[7m';
+            const RESET = '\x1b[0m';
+            const DIM = '\x1b[2m';
+            // Hide cursor during render
+            this.safeWrite(HIDE_CURSOR);
+            this.safeWrite(RESET);
+            // Split input into lines for multi-line support
+            const inputLines = this.inputBuffer.split('\n');
+            const totalInputLines = inputLines.length;
+            const displayLineCount = Math.min(totalInputLines, this.maxDisplayLines);
+            // Find cursor position: which line and column
+            let cursorLineIndex = 0;
+            let cursorColInLine = 0;
+            let charCount = 0;
+            for (let i = 0; i < inputLines.length; i++) {
+                const currentLine = inputLines[i] ?? '';
+                const lineLen = currentLine.length;
+                if (charCount + lineLen >= this.cursorPosition) {
+                    cursorLineIndex = i;
+                    cursorColInLine = this.cursorPosition - charCount;
+                    break;
+                }
+                charCount += lineLen + 1; // +1 for newline
+                if (i === inputLines.length - 1) {
+                    cursorLineIndex = i;
+                    cursorColInLine = currentLine.length;
+                }
+            }
+            // Calculate display window to keep cursor visible
+            let displayStartLine = 0;
+            if (totalInputLines > displayLineCount) {
+                if (cursorLineIndex >= displayLineCount - 1) {
+                    displayStartLine = cursorLineIndex - displayLineCount + 2;
+                }
+                displayStartLine = Math.min(displayStartLine, totalInputLines - displayLineCount);
+                displayStartLine = Math.max(0, displayStartLine);
+            }
+            const linesToShow = inputLines.slice(displayStartLine, displayStartLine + displayLineCount);
+            // Move to the start of reserved area
+            const reservedStart = rows - this.reservedLines + 1;
+            this.safeWrite(ANSI.CURSOR_TO_BOTTOM(reservedStart));
+            this.safeWrite(ANSI.CLEAR_LINE);
+            // Line 1: Separator
+            const separatorWidth = Math.min(cols - 2, 60);
             this.safeWrite(DIM);
-            this.safeWrite(`  ${queueCount} queued`);
+            this.safeWrite('─'.repeat(separatorWidth));
             this.safeWrite(RESET);
-        }
-        // Line 2: Prompt (at row N)
-        this.safeWrite(ANSI.CURSOR_TO_BOTTOM(rows));
-        this.safeWrite(ANSI.CLEAR_LINE);
-        const promptPrefix = '> ';
-        const maxInputWidth = cols - 5;
-        const input = this.inputBuffer;
-        const cursorPos = Math.min(this.cursorPosition, input.length);
-        // Handle long input
-        let displayStart = 0;
-        let displayInput = input;
-        if (input.length > maxInputWidth) {
-            if (cursorPos > maxInputWidth - 5) {
-                displayStart = cursorPos - maxInputWidth + 5;
+            // Status hints (line count, queue count)
+            const queueCount = this.state.queuedCommands.length;
+            const hints = [];
+            if (totalInputLines > 1) {
+                hints.push(`${totalInputLines} lines`);
+            }
+            if (this.state.isProcessing && queueCount > 0) {
+                hints.push(`${queueCount} queued`);
+            }
+            if (hints.length > 0) {
+                this.safeWrite(DIM);
+                this.safeWrite('  ' + hints.join(' • '));
+                this.safeWrite(RESET);
+            }
+            const maxInputWidth = cols - 5;
+            let finalCursorRow = reservedStart + 1;
+            let finalCursorCol = 3;
+            // Render each input line
+            for (let lineIdx = 0; lineIdx < linesToShow.length; lineIdx++) {
+                this.safeWrite('\n');
+                this.safeWrite(ANSI.CLEAR_LINE);
+                const line = linesToShow[lineIdx] ?? '';
+                const absoluteLineIdx = displayStartLine + lineIdx;
+                const isFirstLine = absoluteLineIdx === 0;
+                const isCursorLine = absoluteLineIdx === cursorLineIndex;
+                // Prompt prefix: ">" for first line, "│" for continuation lines
+                this.safeWrite(DIM);
+                this.safeWrite(isFirstLine ? '>' : '│');
+                this.safeWrite(RESET);
+                this.safeWrite(' ');
+                // Handle long lines - scroll horizontally to keep cursor visible
+                let displayStart = 0;
+                let displayLine = line;
+                if (line.length > maxInputWidth) {
+                    if (isCursorLine && cursorColInLine > maxInputWidth - 5) {
+                        displayStart = cursorColInLine - maxInputWidth + 5;
+                    }
+                    displayLine = line.slice(displayStart, displayStart + maxInputWidth);
+                }
+                if (isCursorLine) {
+                    // Render line with cursor
+                    const displayCursorCol = Math.max(0, cursorColInLine - displayStart);
+                    const beforeCursor = displayLine.slice(0, displayCursorCol);
+                    const atCursor = displayLine[displayCursorCol] ?? ' ';
+                    const afterCursor = displayLine.slice(displayCursorCol + 1);
+                    this.safeWrite(beforeCursor);
+                    this.safeWrite(REVERSE_VIDEO);
+                    this.safeWrite(atCursor);
+                    this.safeWrite(RESET);
+                    this.safeWrite(afterCursor);
+                    // Remember cursor position for final positioning
+                    finalCursorRow = reservedStart + 1 + lineIdx;
+                    finalCursorCol = 3 + displayCursorCol;
+                }
+                else {
+                    // Render line without cursor
+                    this.safeWrite(displayLine);
+                }
             }
-            displayInput = input.slice(displayStart, displayStart + maxInputWidth);
+            // Position terminal cursor and show it
+            this.safeWrite(ANSI.CURSOR_TO_BOTTOM(finalCursorRow));
+            this.safeWrite(ANSI.MOVE_TO_COL(finalCursorCol));
+            this.safeWrite(SHOW_CURSOR);
+            // Update rendered state for deduplication
+            this.updateRenderedState();
+        }
+        finally {
+            this.isRendering = false;
         }
-        const displayCursorPos = cursorPos - displayStart;
-        // Write prompt
-        this.safeWrite(promptPrefix);
-        // Text before cursor
-        this.safeWrite(displayInput.slice(0, displayCursorPos));
-        // Cursor block (reverse video)
-        const atCursor = displayInput[displayCursorPos] || ' ';
-        this.safeWrite(REVERSE_VIDEO);
-        this.safeWrite(atCursor);
-        this.safeWrite(RESET);
-        // Text after cursor
-        this.safeWrite(displayInput.slice(displayCursorPos + 1));
-        // Position terminal cursor and show it
-        const terminalCursorCol = promptPrefix.length + displayCursorPos + 1;
-        this.safeWrite(ANSI.MOVE_TO_COL(terminalCursorCol));
-        this.safeWrite(SHOW_CURSOR);
     }
     /**
      * Update the persistent input during streaming.
@@ -492,6 +610,95 @@ export class PinnedChatBox {
             return null;
         return clean.slice(0, this.maxStatusMessageLength);
     }
+    /**
+     * Clear paste-specific state when the user edits the buffer manually.
+     * Prevents us from sending stale paste content after edits.
+     */
+    startManualEdit() {
+        if (this.isPastedBlock) {
+            this.clearPastedBlock();
+        }
+    }
+    /**
+     * Apply a new buffer/cursor position and trigger downstream updates.
+     */
+    applyBufferChange(buffer, cursorPos) {
+        this.inputBuffer = buffer;
+        const nextCursor = typeof cursorPos === 'number' ? cursorPos : buffer.length;
+        this.cursorPosition = Math.max(0, Math.min(nextCursor, this.inputBuffer.length));
+        this.state.currentInput = this.inputBuffer;
+        this.updateReservedLinesForContent();
+        this.scheduleRender();
+    }
+    /**
+     * Update cursor position while keeping it in bounds and re-rendering.
+     */
+    setCursorPosition(position) {
+        this.cursorPosition = Math.max(0, Math.min(position, this.inputBuffer.length));
+        this.scheduleRender();
+    }
+    /**
+     * Convert the current cursor index into line/column info.
+     */
+    getCursorLineInfo() {
+        const lines = this.inputBuffer.split('\n');
+        let remaining = this.cursorPosition;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i] ?? '';
+            if (remaining <= line.length) {
+                return { lines, lineIndex: i, column: remaining };
+            }
+            remaining -= line.length + 1; // account for newline
+        }
+        // Fallback to last line
+        const lastLine = Math.max(0, lines.length - 1);
+        return { lines, lineIndex: lastLine, column: (lines[lastLine] ?? '').length };
+    }
+    /**
+     * Convert line/column back to a single cursor index.
+     */
+    positionFromLineCol(lines, lineIndex, column) {
+        let pos = 0;
+        for (let i = 0; i < lineIndex; i++) {
+            pos += (lines[i] ?? '').length + 1; // +1 for newline
+        }
+        return pos + column;
+    }
+    /**
+     * Move cursor vertically within a multi-line buffer.
+     * Returns true if a movement occurred.
+     */
+    moveCursorVertical(direction) {
+        const info = this.getCursorLineInfo();
+        if (info.lines.length <= 1) {
+            return false;
+        }
+        const targetLine = info.lineIndex + direction;
+        if (targetLine < 0 || targetLine >= info.lines.length) {
+            return false;
+        }
+        const targetCol = Math.min(info.column, (info.lines[targetLine] ?? '').length);
+        const newPos = this.positionFromLineCol(info.lines, targetLine, targetCol);
+        this.setCursorPosition(newPos);
+        return true;
+    }
+    /**
+     * Insert multi-line content directly into the buffer (manual typing).
+     */
+    insertMultilineText(text) {
+        const sanitized = this.sanitizeMultilineForDisplay(text);
+        if (!sanitized)
+            return;
+        // Respect max input length
+        const availableSpace = this.maxInputLength - this.inputBuffer.length;
+        if (availableSpace <= 0)
+            return;
+        const chunk = sanitized.slice(0, availableSpace);
+        this.startManualEdit();
+        this.applyBufferChange(this.inputBuffer.slice(0, this.cursorPosition) +
+            chunk +
+            this.inputBuffer.slice(this.cursorPosition), this.cursorPosition + chunk.length);
+    }
     /**
      * Safely write to the output stream, swallowing non-fatal errors
      */
@@ -681,15 +888,13 @@ export class PinnedChatBox {
     handleMultilinePaste(content) {
         // Keep the original content for submission
         const displaySafeContent = this.sanitizeMultilineForDisplay(content);
-        this.pastedFullContent = content;
+        if (!displaySafeContent)
+            return;
+        const truncatedDisplay = displaySafeContent.slice(0, this.maxInputLength);
+        const truncatedOriginal = content.slice(0, this.maxInputLength);
+        this.pastedFullContent = truncatedOriginal;
         this.isPastedBlock = true;
-        // Store the full content for display (not just a summary)
-        this.inputBuffer = displaySafeContent;
-        this.cursorPosition = displaySafeContent.length;
-        this.state.currentInput = displaySafeContent;
-        // Update reserved lines based on content
-        this.updateReservedLinesForContent();
-        this.scheduleRender();
+        this.applyBufferChange(truncatedDisplay, truncatedDisplay.length);
     }
     /**
      * Public helper for routing external multi-line pastes directly into the chat box
@@ -766,12 +971,11 @@ export class PinnedChatBox {
         this.cursorPosition = Math.min(this.cursorPosition, this.inputBuffer.length);
         if (this.cursorPosition === 0)
             return;
-        this.inputBuffer =
-            this.inputBuffer.slice(0, this.cursorPosition - 1) +
-                this.inputBuffer.slice(this.cursorPosition);
-        this.cursorPosition = Math.max(0, this.cursorPosition - 1);
-        this.state.currentInput = this.inputBuffer;
-        this.scheduleRender();
+        const newBuffer = this.inputBuffer.slice(0, this.cursorPosition - 1) +
+            this.inputBuffer.slice(this.cursorPosition);
+        const newCursor = Math.max(0, this.cursorPosition - 1);
+        this.startManualEdit();
+        this.applyBufferChange(newBuffer, newCursor);
     }
     /**
      * Handle delete key
@@ -782,11 +986,10 @@ export class PinnedChatBox {
         this.cursorPosition = Math.min(this.cursorPosition, this.inputBuffer.length);
         if (this.cursorPosition >= this.inputBuffer.length)
             return;
-        this.inputBuffer =
-            this.inputBuffer.slice(0, this.cursorPosition) +
-                this.inputBuffer.slice(this.cursorPosition + 1);
-        this.state.currentInput = this.inputBuffer;
-        this.scheduleRender();
+        const newBuffer = this.inputBuffer.slice(0, this.cursorPosition) +
+            this.inputBuffer.slice(this.cursorPosition + 1);
+        this.startManualEdit();
+        this.applyBufferChange(newBuffer, this.cursorPosition);
     }
     /**
      * Handle cursor left
@@ -813,29 +1016,107 @@ export class PinnedChatBox {
         }
     }
     /**
-     * Handle home key
+     * Handle home key - move to start of current line (not start of buffer)
      */
     handleHome() {
         if (this.isDisposed)
             return;
-        this.cursorPosition = 0;
+        // In multi-line mode, move to start of current line
+        const { lineIndex, lines } = this.getCursorLinePosition();
+        // Calculate position at start of current line
+        let newPos = 0;
+        for (let i = 0; i < lineIndex; i++) {
+            newPos += (lines[i] ?? '').length + 1;
+        }
+        this.cursorPosition = newPos;
         this.scheduleRender();
     }
     /**
-     * Handle end key (Ctrl+E)
+     * Handle end key (Ctrl+E) - move to end of current line (not end of buffer)
      */
     handleEnd() {
         if (this.isDisposed)
             return;
-        this.cursorPosition = this.inputBuffer.length;
+        // In multi-line mode, move to end of current line
+        const { lineIndex, lines } = this.getCursorLinePosition();
+        const currentLine = lines[lineIndex] ?? '';
+        // Calculate position at end of current line
+        let newPos = 0;
+        for (let i = 0; i < lineIndex; i++) {
+            newPos += (lines[i] ?? '').length + 1;
+        }
+        newPos += currentLine.length;
+        this.cursorPosition = newPos;
         this.scheduleRender();
     }
     /**
-     * Handle up arrow - navigate to previous history entry
+     * Handle inserting a newline character at cursor position (Shift+Enter or Option+Enter)
+     */
+    handleNewline() {
+        if (!this.isEnabled || this.isDisposed)
+            return;
+        // Respect max input length
+        if (this.inputBuffer.length >= this.maxInputLength)
+            return;
+        // Insert newline at cursor position
+        this.inputBuffer =
+            this.inputBuffer.slice(0, this.cursorPosition) +
+                '\n' +
+                this.inputBuffer.slice(this.cursorPosition);
+        this.cursorPosition++;
+        this.state.currentInput = this.inputBuffer;
+        // Update reserved lines for the new content
+        this.updateReservedLinesForContent();
+        this.scheduleRender();
+    }
+    /**
+     * Get cursor line and column position within multi-line content.
+     */
+    getCursorLinePosition() {
+        const lines = this.inputBuffer.split('\n');
+        let charCount = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const lineLen = (lines[i] ?? '').length;
+            if (charCount + lineLen >= this.cursorPosition) {
+                return {
+                    lineIndex: i,
+                    colInLine: this.cursorPosition - charCount,
+                    lines,
+                };
+            }
+            charCount += lineLen + 1; // +1 for newline
+        }
+        // Cursor at end
+        return {
+            lineIndex: lines.length - 1,
+            colInLine: (lines[lines.length - 1] ?? '').length,
+            lines,
+        };
+    }
+    /**
+     * Handle up arrow - move cursor up in multi-line content, or navigate history if on first line
      */
     handleHistoryUp() {
         if (this.isDisposed)
             return;
+        // For multi-line content, move cursor up within content first
+        const { lineIndex, colInLine, lines } = this.getCursorLinePosition();
+        if (lineIndex > 0) {
+            // Move cursor to previous line, keeping column position if possible
+            const prevLine = lines[lineIndex - 1] ?? '';
+            const newCol = Math.min(colInLine, prevLine.length);
+            // Calculate new cursor position
+            let newPos = 0;
+            for (let i = 0; i < lineIndex - 1; i++) {
+                newPos += (lines[i] ?? '').length + 1;
+            }
+            newPos += newCol;
+            this.cursorPosition = newPos;
+            this.state.currentInput = this.inputBuffer;
+            this.scheduleRender();
+            return;
+        }
+        // On first line - navigate history
         if (this.inputHistory.length === 0)
             return;
         // If at current input, save it temporarily
@@ -852,11 +1133,29 @@ export class PinnedChatBox {
         }
     }
     /**
-     * Handle down arrow - navigate to next history entry
+     * Handle down arrow - move cursor down in multi-line content, or navigate history if on last line
      */
     handleHistoryDown() {
         if (this.isDisposed)
             return;
+        // For multi-line content, move cursor down within content first
+        const { lineIndex, colInLine, lines } = this.getCursorLinePosition();
+        if (lineIndex < lines.length - 1) {
+            // Move cursor to next line, keeping column position if possible
+            const nextLine = lines[lineIndex + 1] ?? '';
+            const newCol = Math.min(colInLine, nextLine.length);
+            // Calculate new cursor position
+            let newPos = 0;
+            for (let i = 0; i <= lineIndex; i++) {
+                newPos += (lines[i] ?? '').length + 1;
+            }
+            newPos += newCol;
+            this.cursorPosition = newPos;
+            this.state.currentInput = this.inputBuffer;
+            this.scheduleRender();
+            return;
+        }
+        // On last line - navigate history
         if (this.historyIndex > 0) {
             // Move down in history
             this.historyIndex--;
@@ -1183,6 +1482,8 @@ export class PinnedChatBox {
      * Handle terminal resize - update scroll region if active
      */
     handleResize() {
+        // Invalidate render state to force re-render with new dimensions
+        this.invalidateRenderedState();
         if (this.scrollRegionActive) {
             // Reset and re-enable scroll region with new dimensions
             this.safeWrite(ANSI.RESET_SCROLL_REGION);
@@ -1239,13 +1540,14 @@ export class PinnedChatBox {
         return !this.isDisposed && this.isEnabled;
     }
     /**
-     * Force immediate render (bypass throttling)
+     * Force immediate render (bypass throttling and deduplication)
      */
     forceRender() {
         if (this.isDisposed)
             return;
         this.lastRenderTime = 0;
         this.renderScheduled = false;
+        this.invalidateRenderedState(); // Force re-render even if content unchanged
         this.render();
     }
     /**
@@ -1264,6 +1566,7 @@ export class PinnedChatBox {
             statusMessage: null,
             isVisible: true,
         };
+        this.invalidateRenderedState();
         this.scheduleRender();
     }
 }