erosolar-cli 1.7.190 → 1.7.192

package/dist/shell/terminalInput.js

@@ -0,0 +1,855 @@
+/**
+ * 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';
+// 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;
+    // 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;
+    constructor(writeStream = process.stdout, config = {}) {
+        super();
+        this.out = writeStream;
+        this.config = {
+            maxLines: config.maxLines ?? 15,
+            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
+     */
+    getBuffer() {
+        return this.buffer;
+    }
+    /**
+     * Set buffer content
+     */
+    setBuffer(text, cursorPos) {
+        this.buffer = this.sanitize(text).slice(0, this.config.maxLength);
+        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.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 displayLines = Math.min(lines.length, this.config.maxLines);
+            // 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 (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();
+    }
+    /**
+     * Dispose and clean up
+     */
+    dispose() {
+        if (this.disposed)
+            return;
+        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();
+                    this.write('^C\n');
+                }
+                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':
+                this.insertText('  ');
+                return true;
+        }
+        return false;
+    }
+    insertText(text) {
+        const clean = this.sanitize(text);
+        if (!clean)
+            return;
+        const available = this.config.maxLength - this.buffer.length;
+        if (available <= 0)
+            return;
+        const chunk = clean.slice(0, available);
+        this.buffer = this.buffer.slice(0, this.cursor) + chunk + this.buffer.slice(this.cursor);
+        this.cursor += chunk.length;
+        this.emit('change', this.buffer);
+        this.scheduleRender();
+    }
+    insertNewline() {
+        if (this.buffer.length >= this.config.maxLength)
+            return;
+        this.buffer = this.buffer.slice(0, this.cursor) + '\n' + this.buffer.slice(this.cursor);
+        this.cursor++;
+        this.emit('change', this.buffer);
+        this.scheduleRender();
+    }
+    deleteBackward() {
+        if (this.cursor === 0)
+            return;
+        this.buffer = this.buffer.slice(0, this.cursor - 1) + this.buffer.slice(this.cursor);
+        this.cursor--;
+        this.emit('change', this.buffer);
+        this.scheduleRender();
+    }
+    deleteForward() {
+        if (this.cursor >= this.buffer.length)
+            return;
+        this.buffer = this.buffer.slice(0, this.cursor) + this.buffer.slice(this.cursor + 1);
+        this.emit('change', this.buffer);
+        this.scheduleRender();
+    }
+    deleteToStart() {
+        if (this.cursor === 0)
+            return;
+        this.buffer = this.buffer.slice(this.cursor);
+        this.cursor = 0;
+        this.emit('change', this.buffer);
+        this.scheduleRender();
+    }
+    deleteToEnd() {
+        if (this.cursor >= this.buffer.length)
+            return;
+        this.buffer = this.buffer.slice(0, this.cursor);
+        this.emit('change', this.buffer);
+        this.scheduleRender();
+    }
+    deleteWord() {
+        if (this.cursor === 0)
+            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.buffer.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;
+        // Insert paste content at cursor
+        const clean = this.sanitize(content);
+        const available = this.config.maxLength - this.buffer.length;
+        const chunk = clean.slice(0, available);
+        this.buffer = this.buffer.slice(0, this.cursor) + chunk + this.buffer.slice(this.cursor);
+        this.cursor += 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
+    // ===========================================================================
+    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