erosolar-cli 1.7.195 → 1.7.196

package/dist/shell/terminalInput.js

@@ -0,0 +1,1089 @@
+/**
+ * TerminalInput - Clean, unified terminal input handling
+ *
+ * Design principles:
+ * - Single source of truth for input state
+ * - Native bracketed paste support (no heuristics)
+ * - Clean cursor model with render-time wrapping
+ * - State machine for different input modes
+ * - No readline dependency for display
+ */
+import { EventEmitter } from 'node:events';
+import { isMultilinePaste } from '../core/multilinePasteHandler.js';
+// ANSI escape codes
+const ESC = {
+    // Cursor control
+    SAVE: '\x1b7',
+    RESTORE: '\x1b8',
+    HIDE: '\x1b[?25l',
+    SHOW: '\x1b[?25h',
+    TO: (row, col) => `\x1b[${row};${col}H`,
+    TO_COL: (col) => `\x1b[${col}G`,
+    // Line control
+    CLEAR_LINE: '\x1b[2K',
+    CLEAR_TO_END: '\x1b[0J',
+    // Scroll region
+    SET_SCROLL: (top, bottom) => `\x1b[${top};${bottom}r`,
+    RESET_SCROLL: '\x1b[r',
+    // Style
+    RESET: '\x1b[0m',
+    DIM: '\x1b[2m',
+    REVERSE: '\x1b[7m',
+    BOLD: '\x1b[1m',
+    BG_DARK: '\x1b[48;5;236m', // Dark gray background
+    // Bracketed paste mode
+    PASTE_ENABLE: '\x1b[?2004h',
+    PASTE_DISABLE: '\x1b[?2004l',
+    PASTE_START: '\x1b[200~',
+    PASTE_END: '\x1b[201~',
+};
+/**
+ * Unified terminal input handler
+ */
+export class TerminalInput extends EventEmitter {
+    out;
+    config;
+    // Core state
+    buffer = '';
+    cursor = 0;
+    mode = 'idle';
+    // Paste accumulation
+    pasteBuffer = '';
+    isPasting = false;
+    pastePlaceholders = [];
+    pasteCounter = 0;
+    // History
+    history = [];
+    historyIndex = -1;
+    tempInput = '';
+    maxHistory = 100;
+    // Queue for streaming mode
+    queue = [];
+    queueIdCounter = 0;
+    // Display state
+    reservedLines = 2;
+    scrollRegionActive = false;
+    lastRenderContent = '';
+    lastRenderCursor = -1;
+    renderDirty = false;
+    isRendering = false;
+    // Lifecycle
+    disposed = false;
+    enabled = true;
+    contextUsage = null;
+    editMode = 'display-edits';
+    // Output interceptor cleanup
+    outputInterceptorCleanup;
+    constructor(writeStream = process.stdout, config = {}) {
+        super();
+        this.out = writeStream;
+        this.config = {
+            maxLines: config.maxLines ?? 1000,
+            maxLength: config.maxLength ?? 10000,
+            maxQueueSize: config.maxQueueSize ?? 100,
+            promptChar: config.promptChar ?? '> ',
+            continuationChar: config.continuationChar ?? '│ ',
+        };
+    }
+    // ===========================================================================
+    // PUBLIC API
+    // ===========================================================================
+    /**
+     * Enable bracketed paste mode in terminal
+     */
+    enableBracketedPaste() {
+        if (this.isTTY()) {
+            this.write(ESC.PASTE_ENABLE);
+        }
+    }
+    /**
+     * Disable bracketed paste mode
+     */
+    disableBracketedPaste() {
+        if (this.isTTY()) {
+            this.write(ESC.PASTE_DISABLE);
+        }
+    }
+    /**
+     * Process raw terminal data (handles bracketed paste sequences)
+     * Returns true if the data was consumed (paste sequence)
+     */
+    processRawData(data) {
+        // Check for paste start
+        if (data.includes(ESC.PASTE_START)) {
+            this.isPasting = true;
+            this.pasteBuffer = '';
+            // Extract content after paste start
+            const startIdx = data.indexOf(ESC.PASTE_START) + ESC.PASTE_START.length;
+            const remaining = data.slice(startIdx);
+            // Check if paste end is also in this chunk
+            if (remaining.includes(ESC.PASTE_END)) {
+                const endIdx = remaining.indexOf(ESC.PASTE_END);
+                this.pasteBuffer = remaining.slice(0, endIdx);
+                this.finishPaste();
+                return { consumed: true, passthrough: remaining.slice(endIdx + ESC.PASTE_END.length) };
+            }
+            this.pasteBuffer = remaining;
+            return { consumed: true, passthrough: '' };
+        }
+        // Accumulating paste
+        if (this.isPasting) {
+            if (data.includes(ESC.PASTE_END)) {
+                const endIdx = data.indexOf(ESC.PASTE_END);
+                this.pasteBuffer += data.slice(0, endIdx);
+                this.finishPaste();
+                return { consumed: true, passthrough: data.slice(endIdx + ESC.PASTE_END.length) };
+            }
+            this.pasteBuffer += data;
+            return { consumed: true, passthrough: '' };
+        }
+        return { consumed: false, passthrough: data };
+    }
+    /**
+     * Handle a keypress event
+     */
+    handleKeypress(str, key) {
+        if (this.disposed || !this.enabled)
+            return;
+        // Handle control keys
+        if (key?.ctrl) {
+            this.handleCtrlKey(key);
+            return;
+        }
+        // Handle meta/alt keys
+        if (key?.meta) {
+            this.handleMetaKey(key);
+            return;
+        }
+        // Handle special keys
+        if (key?.name) {
+            const handled = this.handleSpecialKey(str, key);
+            if (handled)
+                return;
+        }
+        // Insert printable characters
+        if (str && !key?.ctrl && !key?.meta) {
+            this.insertText(str);
+        }
+    }
+    /**
+     * Set the input mode
+     */
+    setMode(mode) {
+        const prevMode = this.mode;
+        this.mode = mode;
+        if (mode === 'streaming' && prevMode !== 'streaming') {
+            this.enableScrollRegion();
+        }
+        else if (mode !== 'streaming' && prevMode === 'streaming') {
+            this.disableScrollRegion();
+        }
+    }
+    /**
+     * Get current mode
+     */
+    getMode() {
+        return this.mode;
+    }
+    /**
+     * Get the current buffer content (may contain placeholders for pasted text)
+     */
+    getBuffer() {
+        return this.buffer;
+    }
+    /**
+     * Get the actual text with paste placeholders expanded
+     */
+    getText() {
+        return this.assembleText();
+    }
+    /**
+     * Set buffer content
+     */
+    setBuffer(text, cursorPos) {
+        this.pastePlaceholders = [];
+        const clean = this.sanitize(text).slice(0, this.config.maxLength);
+        this.buffer = clean;
+        this.cursor = cursorPos ?? this.buffer.length;
+        this.clampCursor();
+        this.scheduleRender();
+    }
+    /**
+     * Clear the buffer
+     */
+    clear() {
+        this.buffer = '';
+        this.cursor = 0;
+        this.historyIndex = -1;
+        this.tempInput = '';
+        this.pastePlaceholders = [];
+        this.scheduleRender();
+    }
+    /**
+     * Get queued inputs
+     */
+    getQueue() {
+        return [...this.queue];
+    }
+    /**
+     * Dequeue next input
+     */
+    dequeue() {
+        const item = this.queue.shift();
+        this.scheduleRender();
+        return item;
+    }
+    /**
+     * Clear the queue
+     */
+    clearQueue() {
+        this.queue = [];
+        this.scheduleRender();
+    }
+    /**
+     * Render the input area
+     */
+    render() {
+        if (!this.canRender())
+            return;
+        if (this.isRendering)
+            return;
+        const shouldSkip = !this.renderDirty &&
+            this.buffer === this.lastRenderContent &&
+            this.cursor === this.lastRenderCursor;
+        this.renderDirty = false;
+        // Skip if nothing changed and no explicit refresh requested
+        if (shouldSkip) {
+            return;
+        }
+        this.isRendering = true;
+        try {
+            const { rows, cols } = this.getSize();
+            const maxWidth = Math.max(8, cols - 4);
+            // Wrap buffer into display lines
+            const { lines, cursorLine, cursorCol } = this.wrapBuffer(maxWidth);
+            const maxVisible = Math.max(1, Math.min(this.config.maxLines, rows - 1));
+            const displayLines = Math.min(lines.length, maxVisible);
+            // Update reserved lines if needed
+            this.updateReservedLines(displayLines);
+            // Calculate display window (keep cursor visible)
+            let startLine = 0;
+            if (lines.length > displayLines) {
+                startLine = Math.max(0, cursorLine - displayLines + 1);
+                startLine = Math.min(startLine, lines.length - displayLines);
+            }
+            const visibleLines = lines.slice(startLine, startLine + displayLines);
+            const adjustedCursorLine = cursorLine - startLine;
+            // Render
+            this.write(ESC.HIDE);
+            this.write(ESC.RESET);
+            const startRow = rows - this.reservedLines + 1;
+            this.write(ESC.TO(startRow, 1));
+            this.write(ESC.CLEAR_LINE);
+            // Separator line
+            const sepWidth = Math.min(cols - 2, 55);
+            this.write(ESC.DIM);
+            this.write('─'.repeat(sepWidth));
+            // Status hints
+            const hints = [];
+            if (this.contextUsage !== null) {
+                const remaining = Math.max(0, 100 - this.contextUsage);
+                hints.push(`context ${remaining}% left`);
+            }
+            hints.push(this.editMode === 'display-edits' ? 'mode: display edits' : 'mode: ask permission');
+            if (this.pastePlaceholders.length > 0) {
+                const count = this.pastePlaceholders.length;
+                hints.push(`${count} paste block${count === 1 ? '' : 's'}`);
+            }
+            if (lines.length > 1)
+                hints.push(`${lines.length} lines`);
+            if (this.mode === 'streaming' && this.queue.length > 0) {
+                hints.push(`${this.queue.length} queued`);
+            }
+            if (hints.length > 0) {
+                this.write('  ' + hints.join(' • '));
+            }
+            this.write(ESC.RESET);
+            // Render input lines
+            let finalRow = startRow + 1;
+            let finalCol = 3;
+            for (let i = 0; i < visibleLines.length; i++) {
+                this.write('\n');
+                this.write(ESC.CLEAR_LINE);
+                const line = visibleLines[i] ?? '';
+                const absoluteLineIdx = startLine + i;
+                const isFirstLine = absoluteLineIdx === 0;
+                const isCursorLine = i === adjustedCursorLine;
+                // Background
+                this.write(ESC.BG_DARK);
+                // Prompt prefix
+                this.write(ESC.DIM);
+                this.write(isFirstLine ? this.config.promptChar : this.config.continuationChar);
+                this.write(ESC.RESET);
+                this.write(ESC.BG_DARK);
+                if (isCursorLine) {
+                    // Render with block cursor
+                    const col = Math.min(cursorCol, line.length);
+                    const before = line.slice(0, col);
+                    const at = col < line.length ? line[col] : ' ';
+                    const after = col < line.length ? line.slice(col + 1) : '';
+                    this.write(before);
+                    this.write(ESC.REVERSE + ESC.BOLD);
+                    this.write(at);
+                    this.write(ESC.RESET + ESC.BG_DARK);
+                    this.write(after);
+                    finalRow = startRow + 1 + i;
+                    finalCol = this.config.promptChar.length + col + 1;
+                }
+                else {
+                    this.write(line);
+                }
+                // Pad to edge
+                const lineLen = this.config.promptChar.length + line.length + (isCursorLine && cursorCol >= line.length ? 1 : 0);
+                const padding = Math.max(0, cols - lineLen - 1);
+                if (padding > 0)
+                    this.write(' '.repeat(padding));
+                this.write(ESC.RESET);
+            }
+            // Position cursor
+            this.write(ESC.TO(finalRow, Math.min(finalCol, cols)));
+            this.write(ESC.SHOW);
+            // Update state
+            this.lastRenderContent = this.buffer;
+            this.lastRenderCursor = this.cursor;
+        }
+        finally {
+            this.isRendering = false;
+        }
+    }
+    /**
+     * Force a re-render
+     */
+    forceRender() {
+        this.lastRenderContent = '';
+        this.lastRenderCursor = -1;
+        this.renderDirty = true;
+        this.render();
+    }
+    /**
+     * Enable/disable input
+     */
+    setEnabled(enabled) {
+        this.enabled = enabled;
+    }
+    /**
+     * Handle terminal resize
+     */
+    handleResize() {
+        this.lastRenderContent = '';
+        this.lastRenderCursor = -1;
+        if (this.scrollRegionActive) {
+            this.disableScrollRegion();
+            this.enableScrollRegion();
+        }
+        this.scheduleRender();
+    }
+    /**
+     * Register with display's output interceptor to position cursor correctly.
+     * When scroll region is active, output needs to go to the scroll region,
+     * not the protected bottom area where the input is rendered.
+     */
+    registerOutputInterceptor(display) {
+        if (this.outputInterceptorCleanup) {
+            this.outputInterceptorCleanup();
+        }
+        this.outputInterceptorCleanup = display.registerOutputInterceptor({
+            beforeWrite: () => {
+                // When scroll region is active, move cursor to scroll area before output
+                if (this.scrollRegionActive) {
+                    const { rows } = this.getSize();
+                    const scrollBottom = Math.max(1, rows - this.reservedLines);
+                    this.write(ESC.SAVE);
+                    this.write(ESC.TO(scrollBottom, 1));
+                }
+            },
+            afterWrite: () => {
+                // Restore cursor position after output
+                if (this.scrollRegionActive) {
+                    this.write(ESC.RESTORE);
+                }
+            },
+        });
+    }
+    /**
+     * Dispose and clean up
+     */
+    dispose() {
+        if (this.disposed)
+            return;
+        // Clean up output interceptor
+        if (this.outputInterceptorCleanup) {
+            this.outputInterceptorCleanup();
+            this.outputInterceptorCleanup = undefined;
+        }
+        this.disposed = true;
+        this.enabled = false;
+        this.disableScrollRegion();
+        this.disableBracketedPaste();
+        this.buffer = '';
+        this.queue = [];
+        this.removeAllListeners();
+    }
+    // ===========================================================================
+    // INPUT HANDLING
+    // ===========================================================================
+    handleCtrlKey(key) {
+        switch (key.name) {
+            case 'c':
+                if (this.buffer.length > 0) {
+                    this.clear();
+                }
+                else {
+                    this.emit('interrupt');
+                }
+                break;
+            case 'a': // Home
+                this.moveCursorToLineStart();
+                break;
+            case 'e': // End
+                this.moveCursorToLineEnd();
+                break;
+            case 'u': // Delete to start
+                this.deleteToStart();
+                break;
+            case 'k': // Delete to end
+                this.deleteToEnd();
+                break;
+            case 'w': // Delete word
+                this.deleteWord();
+                break;
+            case 'left': // Word left
+                this.moveCursorWordLeft();
+                break;
+            case 'right': // Word right
+                this.moveCursorWordRight();
+                break;
+        }
+    }
+    handleMetaKey(key) {
+        switch (key.name) {
+            case 'left':
+            case 'b':
+                this.moveCursorWordLeft();
+                break;
+            case 'right':
+            case 'f':
+                this.moveCursorWordRight();
+                break;
+            case 'backspace':
+                this.deleteWord();
+                break;
+            case 'return':
+                this.insertNewline();
+                break;
+        }
+    }
+    handleSpecialKey(_str, key) {
+        switch (key.name) {
+            case 'return':
+                if (key.shift || key.meta) {
+                    this.insertNewline();
+                }
+                else {
+                    this.submit();
+                }
+                return true;
+            case 'backspace':
+                this.deleteBackward();
+                return true;
+            case 'delete':
+                this.deleteForward();
+                return true;
+            case 'left':
+                this.moveCursorLeft();
+                return true;
+            case 'right':
+                this.moveCursorRight();
+                return true;
+            case 'up':
+                this.handleUp();
+                return true;
+            case 'down':
+                this.handleDown();
+                return true;
+            case 'home':
+                this.moveCursorToLineStart();
+                return true;
+            case 'end':
+                this.moveCursorToLineEnd();
+                return true;
+            case 'tab':
+                if (key.shift) {
+                    this.toggleEditMode();
+                    return true;
+                }
+                this.insertText('  ');
+                return true;
+        }
+        return false;
+    }
+    insertText(text) {
+        const clean = this.sanitize(text);
+        if (!clean)
+            return;
+        const available = this.config.maxLength - this.getComposedLength();
+        if (available <= 0)
+            return;
+        const chunk = clean.slice(0, available);
+        const placeholder = this.findPlaceholderAt(this.cursor);
+        const insertPos = placeholder && this.cursor > placeholder.start ? placeholder.end : this.cursor;
+        this.insertPlainText(chunk, insertPos);
+        this.cursor = insertPos + chunk.length;
+        this.emit('change', this.buffer);
+        this.scheduleRender();
+    }
+    insertNewline() {
+        if (this.getComposedLength() >= this.config.maxLength)
+            return;
+        const placeholder = this.findPlaceholderAt(this.cursor);
+        const insertPos = placeholder && this.cursor > placeholder.start ? placeholder.end : this.cursor;
+        this.insertPlainText('\n', insertPos);
+        this.cursor = insertPos + 1;
+        this.emit('change', this.buffer);
+        this.scheduleRender();
+    }
+    deleteBackward() {
+        if (this.cursor === 0)
+            return;
+        const placeholder = this.findPlaceholderAt(this.cursor - 1);
+        if (placeholder) {
+            this.deletePlaceholder(placeholder);
+        }
+        else {
+            this.removeRange(this.cursor - 1, this.cursor);
+            this.cursor = Math.max(0, this.cursor - 1);
+        }
+        this.emit('change', this.buffer);
+        this.scheduleRender();
+    }
+    deleteForward() {
+        if (this.cursor >= this.buffer.length)
+            return;
+        const placeholder = this.findPlaceholderAt(this.cursor);
+        if (placeholder) {
+            this.deletePlaceholder(placeholder);
+        }
+        else {
+            this.removeRange(this.cursor, this.cursor + 1);
+        }
+        this.emit('change', this.buffer);
+        this.scheduleRender();
+    }
+    deleteToStart() {
+        if (this.cursor === 0)
+            return;
+        this.removeRange(0, this.cursor);
+        this.cursor = 0;
+        this.emit('change', this.buffer);
+        this.scheduleRender();
+    }
+    deleteToEnd() {
+        if (this.cursor >= this.buffer.length)
+            return;
+        this.removeRange(this.cursor, this.buffer.length);
+        this.emit('change', this.buffer);
+        this.scheduleRender();
+    }
+    deleteWord() {
+        if (this.cursor === 0)
+            return;
+        const placeholder = this.findPlaceholderAt(this.cursor - 1);
+        if (placeholder) {
+            this.deletePlaceholder(placeholder);
+            this.emit('change', this.buffer);
+            this.scheduleRender();
+            return;
+        }
+        let pos = this.cursor;
+        // Skip whitespace
+        while (pos > 0 && this.isWhitespace(this.buffer[pos - 1]))
+            pos--;
+        // Skip word
+        while (pos > 0 && !this.isWhitespace(this.buffer[pos - 1]))
+            pos--;
+        this.buffer = this.buffer.slice(0, pos) + this.buffer.slice(this.cursor);
+        this.cursor = pos;
+        this.emit('change', this.buffer);
+        this.scheduleRender();
+    }
+    moveCursorLeft() {
+        if (this.cursor > 0) {
+            this.cursor--;
+            this.scheduleRender();
+        }
+    }
+    moveCursorRight() {
+        if (this.cursor < this.buffer.length) {
+            this.cursor++;
+            this.scheduleRender();
+        }
+    }
+    moveCursorWordLeft() {
+        let pos = this.cursor;
+        while (pos > 0 && this.isWhitespace(this.buffer[pos - 1]))
+            pos--;
+        while (pos > 0 && !this.isWhitespace(this.buffer[pos - 1]))
+            pos--;
+        this.cursor = pos;
+        this.scheduleRender();
+    }
+    moveCursorWordRight() {
+        let pos = this.cursor;
+        while (pos < this.buffer.length && !this.isWhitespace(this.buffer[pos]))
+            pos++;
+        while (pos < this.buffer.length && this.isWhitespace(this.buffer[pos]))
+            pos++;
+        this.cursor = pos;
+        this.scheduleRender();
+    }
+    moveCursorToLineStart() {
+        // Find start of current line
+        let pos = this.cursor;
+        while (pos > 0 && this.buffer[pos - 1] !== '\n')
+            pos--;
+        this.cursor = pos;
+        this.scheduleRender();
+    }
+    moveCursorToLineEnd() {
+        // Find end of current line
+        let pos = this.cursor;
+        while (pos < this.buffer.length && this.buffer[pos] !== '\n')
+            pos++;
+        this.cursor = pos;
+        this.scheduleRender();
+    }
+    handleUp() {
+        // Check if we can move up within buffer (multi-line)
+        const { cursorLine } = this.getCursorPosition();
+        if (cursorLine > 0) {
+            this.moveCursorUp();
+            return;
+        }
+        // Otherwise navigate history
+        if (this.history.length === 0)
+            return;
+        if (this.historyIndex === -1) {
+            this.tempInput = this.buffer;
+        }
+        if (this.historyIndex < this.history.length - 1) {
+            this.historyIndex++;
+            this.buffer = this.history[this.history.length - 1 - this.historyIndex] ?? '';
+            this.cursor = this.buffer.length;
+            this.scheduleRender();
+        }
+    }
+    handleDown() {
+        // Check if we can move down within buffer
+        const { cursorLine, totalLines } = this.getCursorPosition();
+        if (cursorLine < totalLines - 1) {
+            this.moveCursorDown();
+            return;
+        }
+        // Otherwise navigate history
+        if (this.historyIndex > 0) {
+            this.historyIndex--;
+            this.buffer = this.history[this.history.length - 1 - this.historyIndex] ?? '';
+            this.cursor = this.buffer.length;
+            this.scheduleRender();
+        }
+        else if (this.historyIndex === 0) {
+            this.historyIndex = -1;
+            this.buffer = this.tempInput;
+            this.cursor = this.buffer.length;
+            this.scheduleRender();
+        }
+    }
+    moveCursorUp() {
+        const lines = this.buffer.split('\n');
+        let lineStart = 0;
+        let lineIdx = 0;
+        // Find current line
+        for (let i = 0; i < lines.length; i++) {
+            const lineEnd = lineStart + (lines[i]?.length ?? 0);
+            if (this.cursor <= lineEnd) {
+                lineIdx = i;
+                break;
+            }
+            lineStart = lineEnd + 1; // +1 for newline
+        }
+        if (lineIdx === 0)
+            return;
+        // Calculate column in current line
+        const colInLine = this.cursor - lineStart;
+        // Move to previous line
+        const prevLineStart = lineStart - 1 - (lines[lineIdx - 1]?.length ?? 0);
+        const prevLineLen = lines[lineIdx - 1]?.length ?? 0;
+        this.cursor = prevLineStart + Math.min(colInLine, prevLineLen);
+        this.scheduleRender();
+    }
+    moveCursorDown() {
+        const lines = this.buffer.split('\n');
+        let lineStart = 0;
+        let lineIdx = 0;
+        // Find current line
+        for (let i = 0; i < lines.length; i++) {
+            const lineEnd = lineStart + (lines[i]?.length ?? 0);
+            if (this.cursor <= lineEnd) {
+                lineIdx = i;
+                break;
+            }
+            lineStart = lineEnd + 1;
+        }
+        if (lineIdx >= lines.length - 1)
+            return;
+        const colInLine = this.cursor - lineStart;
+        const nextLineStart = lineStart + (lines[lineIdx]?.length ?? 0) + 1;
+        const nextLineLen = lines[lineIdx + 1]?.length ?? 0;
+        this.cursor = nextLineStart + Math.min(colInLine, nextLineLen);
+        this.scheduleRender();
+    }
+    getCursorPosition() {
+        const lines = this.buffer.split('\n');
+        let pos = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const lineLen = lines[i]?.length ?? 0;
+            if (this.cursor <= pos + lineLen) {
+                return {
+                    cursorLine: i,
+                    cursorCol: this.cursor - pos,
+                    totalLines: lines.length,
+                };
+            }
+            pos += lineLen + 1;
+        }
+        return {
+            cursorLine: lines.length - 1,
+            cursorCol: lines[lines.length - 1]?.length ?? 0,
+            totalLines: lines.length,
+        };
+    }
+    submit() {
+        const text = this.assembleText().trim();
+        if (!text)
+            return;
+        // Add to history
+        if (this.history[this.history.length - 1] !== text) {
+            this.history.push(text);
+            if (this.history.length > this.maxHistory) {
+                this.history.shift();
+            }
+        }
+        this.historyIndex = -1;
+        this.tempInput = '';
+        // Queue or submit based on mode
+        if (this.mode === 'streaming') {
+            if (this.queue.length >= this.config.maxQueueSize) {
+                return; // Queue full
+            }
+            this.queue.push({
+                id: ++this.queueIdCounter,
+                text,
+                timestamp: Date.now(),
+            });
+            this.emit('queue', text);
+            this.clear();
+        }
+        else {
+            this.emit('submit', text);
+            this.clear();
+        }
+    }
+    finishPaste() {
+        const content = this.pasteBuffer;
+        this.pasteBuffer = '';
+        this.isPasting = false;
+        if (!content)
+            return;
+        const clean = this.sanitize(content);
+        if (!clean)
+            return;
+        const available = this.config.maxLength - this.getComposedLength();
+        if (available <= 0)
+            return;
+        const chunk = clean.slice(0, available);
+        if (isMultilinePaste(chunk)) {
+            this.insertPastePlaceholder(chunk);
+        }
+        else {
+            const placeholder = this.findPlaceholderAt(this.cursor);
+            const insertPos = placeholder && this.cursor > placeholder.start ? placeholder.end : this.cursor;
+            this.insertPlainText(chunk, insertPos);
+            this.cursor = insertPos + chunk.length;
+        }
+        this.emit('change', this.buffer);
+        this.scheduleRender();
+    }
+    // ===========================================================================
+    // SCROLL REGION
+    // ===========================================================================
+    enableScrollRegion() {
+        if (this.scrollRegionActive || !this.isTTY())
+            return;
+        const { rows } = this.getSize();
+        const scrollBottom = Math.max(1, rows - this.reservedLines);
+        this.write(ESC.SET_SCROLL(1, scrollBottom));
+        this.scrollRegionActive = true;
+        this.forceRender();
+    }
+    disableScrollRegion() {
+        if (!this.scrollRegionActive)
+            return;
+        this.write(ESC.RESET_SCROLL);
+        this.scrollRegionActive = false;
+    }
+    updateReservedLines(contentLines) {
+        const { rows } = this.getSize();
+        const needed = 1 + contentLines; // separator + content
+        const maxAllowed = Math.max(1, rows - 1);
+        const newReserved = Math.min(Math.max(2, needed), maxAllowed);
+        if (newReserved !== this.reservedLines) {
+            this.reservedLines = newReserved;
+            if (this.scrollRegionActive) {
+                const scrollBottom = Math.max(1, rows - this.reservedLines);
+                this.write(ESC.SET_SCROLL(1, scrollBottom));
+            }
+        }
+    }
+    // ===========================================================================
+    // BUFFER WRAPPING
+    // ===========================================================================
+    wrapBuffer(maxWidth) {
+        const width = Math.max(1, maxWidth);
+        const lines = [];
+        let cursorLine = 0;
+        let cursorCol = 0;
+        let charIndex = 0;
+        if (this.buffer.length === 0) {
+            return { lines: [''], cursorLine: 0, cursorCol: 0 };
+        }
+        const rawLines = this.buffer.split('\n');
+        for (let i = 0; i < rawLines.length; i++) {
+            const raw = rawLines[i] ?? '';
+            if (raw.length === 0) {
+                // Empty line from newline
+                if (this.cursor === charIndex) {
+                    cursorLine = lines.length;
+                    cursorCol = 0;
+                }
+                lines.push('');
+            }
+            else {
+                // Wrap long lines
+                for (let start = 0; start < raw.length; start += width) {
+                    const segment = raw.slice(start, start + width);
+                    const segmentStart = charIndex + start;
+                    const segmentEnd = segmentStart + segment.length;
+                    if (this.cursor >= segmentStart && this.cursor <= segmentEnd) {
+                        cursorLine = lines.length;
+                        cursorCol = this.cursor - segmentStart;
+                    }
+                    lines.push(segment);
+                }
+            }
+            charIndex += raw.length;
+            // Account for newline between raw lines
+            if (i < rawLines.length - 1) {
+                if (this.cursor === charIndex) {
+                    cursorLine = lines.length;
+                    cursorCol = 0;
+                }
+                charIndex++;
+            }
+        }
+        // Safety: clamp values
+        cursorLine = Math.max(0, Math.min(cursorLine, lines.length - 1));
+        cursorCol = Math.max(0, Math.min(cursorCol, lines[cursorLine]?.length ?? 0));
+        return { lines, cursorLine, cursorCol };
+    }
+    // ===========================================================================
+    // UTILITIES
+    // ===========================================================================
+    getComposedLength() {
+        if (this.pastePlaceholders.length === 0) {
+            return this.buffer.length;
+        }
+        const sorted = [...this.pastePlaceholders].sort((a, b) => a.start - b.start);
+        let composed = 0;
+        let cursor = 0;
+        for (const placeholder of sorted) {
+            composed += Math.max(0, placeholder.start - cursor);
+            composed += placeholder.content.length;
+            cursor = placeholder.end;
+        }
+        composed += Math.max(0, this.buffer.length - cursor);
+        return composed;
+    }
+    assembleText() {
+        if (this.pastePlaceholders.length === 0) {
+            return this.buffer;
+        }
+        const sorted = [...this.pastePlaceholders].sort((a, b) => a.start - b.start);
+        let result = '';
+        let cursor = 0;
+        for (const placeholder of sorted) {
+            result += this.buffer.slice(cursor, placeholder.start);
+            result += placeholder.content;
+            cursor = placeholder.end;
+        }
+        result += this.buffer.slice(cursor);
+        return result;
+    }
+    shiftPlaceholders(start, delta, excludeId) {
+        if (delta === 0)
+            return;
+        for (const placeholder of this.pastePlaceholders) {
+            if (excludeId && placeholder.id === excludeId)
+                continue;
+            if (placeholder.start >= start) {
+                placeholder.start += delta;
+                placeholder.end += delta;
+            }
+        }
+    }
+    removeRange(start, end) {
+        // Expand deletion to cover any placeholder that overlaps the range
+        let adjustedStart = start;
+        let adjustedEnd = end;
+        for (const ph of this.pastePlaceholders) {
+            if (ph.start < adjustedEnd && ph.end > adjustedStart) {
+                adjustedStart = Math.min(adjustedStart, ph.start);
+                adjustedEnd = Math.max(adjustedEnd, ph.end);
+            }
+        }
+        const length = Math.max(0, adjustedEnd - adjustedStart);
+        if (length === 0)
+            return;
+        this.buffer = this.buffer.slice(0, adjustedStart) + this.buffer.slice(adjustedEnd);
+        // Remove any placeholders that were within the deleted range
+        this.pastePlaceholders = this.pastePlaceholders.filter((ph) => {
+            return ph.end <= adjustedStart || ph.start >= adjustedEnd;
+        });
+        // Shift remaining placeholders that were after the deleted range
+        this.shiftPlaceholders(adjustedEnd, -length);
+        this.clampCursor();
+    }
+    insertPlainText(text, position) {
+        if (!text)
+            return;
+        this.shiftPlaceholders(position, text.length);
+        this.buffer = this.buffer.slice(0, position) + text + this.buffer.slice(position);
+    }
+    findPlaceholderAt(position) {
+        return this.pastePlaceholders.find((ph) => position >= ph.start && position < ph.end) ?? null;
+    }
+    buildPlaceholder(lineCount) {
+        const id = ++this.pasteCounter;
+        const plural = lineCount === 1 ? '' : 's';
+        const placeholder = `[Pasted text #${id} +${lineCount} line${plural}]`;
+        return { id, placeholder };
+    }
+    insertPastePlaceholder(content) {
+        const available = this.config.maxLength - this.getComposedLength();
+        if (available <= 0)
+            return;
+        const cleanContent = content.slice(0, available);
+        const lineCount = cleanContent.split('\n').length;
+        const { id, placeholder } = this.buildPlaceholder(lineCount);
+        const insertPos = this.cursor;
+        this.shiftPlaceholders(insertPos, placeholder.length);
+        this.pastePlaceholders.push({
+            id,
+            content: cleanContent,
+            lineCount,
+            placeholder,
+            start: insertPos,
+            end: insertPos + placeholder.length,
+        });
+        this.buffer = this.buffer.slice(0, insertPos) + placeholder + this.buffer.slice(insertPos);
+        this.cursor = insertPos + placeholder.length;
+    }
+    deletePlaceholder(placeholder) {
+        const length = placeholder.end - placeholder.start;
+        this.buffer = this.buffer.slice(0, placeholder.start) + this.buffer.slice(placeholder.end);
+        this.pastePlaceholders = this.pastePlaceholders.filter((ph) => ph.id !== placeholder.id);
+        this.shiftPlaceholders(placeholder.end, -length, placeholder.id);
+        this.cursor = placeholder.start;
+    }
+    updateContextUsage(value) {
+        if (value === null || !Number.isFinite(value)) {
+            this.contextUsage = null;
+        }
+        else {
+            const bounded = Math.max(0, Math.min(100, Math.round(value)));
+            this.contextUsage = bounded;
+        }
+        this.scheduleRender();
+    }
+    getEditMode() {
+        return this.editMode;
+    }
+    applyEditMode(mode) {
+        this.setEditMode(mode);
+    }
+    setEditMode(mode) {
+        if (this.editMode === mode)
+            return;
+        this.editMode = mode;
+        this.emit('mode-change', this.editMode);
+        this.scheduleRender();
+    }
+    toggleEditMode() {
+        const next = this.editMode === 'display-edits' ? 'ask-permission' : 'display-edits';
+        this.setEditMode(next);
+    }
+    scheduleRender() {
+        if (!this.canRender())
+            return;
+        this.renderDirty = true;
+        queueMicrotask(() => this.render());
+    }
+    canRender() {
+        return !this.disposed && this.enabled && this.isTTY();
+    }
+    isTTY() {
+        return !!this.out.isTTY && this.out.writable !== false;
+    }
+    getSize() {
+        return {
+            rows: this.out.rows ?? 24,
+            cols: this.out.columns ?? 80,
+        };
+    }
+    write(data) {
+        try {
+            if (this.out.writable) {
+                this.out.write(data);
+            }
+        }
+        catch {
+            // Ignore write errors
+        }
+    }
+    sanitize(text) {
+        if (!text)
+            return '';
+        // Remove ANSI codes and control chars (except newlines)
+        return text
+            .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, '') // OSC sequences
+            .replace(/\x1b\[[0-9;]*[A-Za-z]/g, '') // CSI sequences
+            .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, '') // Control chars except \n and \r
+            .replace(/\r\n?/g, '\n'); // Normalize line endings
+    }
+    isWhitespace(char) {
+        return char === ' ' || char === '\t' || char === '\n';
+    }
+    clampCursor() {
+        this.cursor = Math.max(0, Math.min(this.cursor, this.buffer.length));
+    }
+}
+//# sourceMappingURL=terminalInput.js.map