erosolar-cli 1.7.194 → 1.7.195

package/dist/shell/terminalInput.js

@@ -1,1082 +0,0 @@
-/**
- * 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;
-    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;
-        // Skip if nothing changed
-        if (this.buffer === this.lastRenderContent && this.cursor === this.lastRenderCursor) {
-            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.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;
-        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