erosolar-cli 1.7.194 → 1.7.195

package/dist/shell/chatBox.js

@@ -1,811 +0,0 @@
-/**
- * ChatBox - Claude Code style input box at the bottom of terminal
- *
- * This is the ONLY place the cursor can ever be. Features:
- * - Multi-line text input
- * - Cursor navigation (arrows, home, end, word jump)
- * - Line wrapping for long lines
- * - Scrolling for content exceeding visible height
- * - Always visible at bottom of terminal
- * - Scroll region management for output area above
- */
-import { EventEmitter } from 'node:events';
-import * as readline from 'node:readline';
-import { theme } from '../ui/theme.js';
-/**
- * ANSI escape codes for terminal control
- */
-const ANSI = {
-    SAVE_CURSOR: '\u001b7',
-    RESTORE_CURSOR: '\u001b8',
-    CURSOR_TO: (row, col) => `\u001b[${row};${col}H`,
-    CURSOR_UP: (n) => `\u001b[${n}A`,
-    CURSOR_DOWN: (n) => `\u001b[${n}B`,
-    CURSOR_FORWARD: (n) => `\u001b[${n}C`,
-    CURSOR_BACK: (n) => `\u001b[${n}D`,
-    CLEAR_LINE: '\u001b[2K',
-    CLEAR_TO_END: '\u001b[0J',
-    CLEAR_TO_START: '\u001b[1J',
-    HIDE_CURSOR: '\u001b[?25l',
-    SHOW_CURSOR: '\u001b[?25h',
-    SET_SCROLL_REGION: (top, bottom) => `\u001b[${top};${bottom}r`,
-    RESET_SCROLL_REGION: '\u001b[r',
-};
-/**
- * ChatBox - A multi-line text input widget fixed at the bottom of the terminal
- */
-export class ChatBox extends EventEmitter {
-    config;
-    writeStream;
-    readStream;
-    state = {
-        lines: [''],
-        cursorRow: 0,
-        cursorCol: 0,
-        scrollOffset: 0,
-        isActive: false,
-    };
-    keypressHandler = null;
-    resizeHandler = null;
-    scrollRegionActive = false;
-    originalStdoutWrite = null;
-    outputIntercepted = false;
-    constructor(config = {}, writeStream = process.stdout, readStream = process.stdin) {
-        super();
-        this.writeStream = writeStream;
-        this.readStream = readStream;
-        this.config = {
-            visibleLines: config.visibleLines ?? 3,
-            maxLines: config.maxLines ?? 100,
-            prompt: config.prompt ?? '> ',
-            showLineNumbers: config.showLineNumbers ?? false,
-        };
-    }
-    /**
-     * Get terminal dimensions
-     */
-    getTerminalSize() {
-        return {
-            rows: this.writeStream.rows || 24,
-            cols: this.writeStream.columns || 80,
-        };
-    }
-    /**
-     * Safely get a line from the buffer, returning empty string if undefined
-     */
-    getLine(index) {
-        return this.state.lines[index] ?? '';
-    }
-    /**
-     * Safely set a line in the buffer
-     */
-    setLine(index, value) {
-        if (index >= 0 && index < this.state.lines.length) {
-            this.state.lines[index] = value;
-        }
-    }
-    /**
-     * Calculate the row where the chat box starts (from terminal top)
-     */
-    getChatBoxStartRow() {
-        const { rows } = this.getTerminalSize();
-        // Chat box occupies bottom N lines: separator (1) + visible lines + prompt indicator
-        const boxHeight = 1 + this.config.visibleLines;
-        return Math.max(1, rows - boxHeight);
-    }
-    /**
-     * Set up scroll region to protect the chat box area at bottom.
-     * All output written to stdout will scroll within the region above the chat box.
-     */
-    setupScrollRegion() {
-        if (this.scrollRegionActive)
-            return;
-        const chatBoxStart = this.getChatBoxStartRow();
-        // Save cursor, set scroll region (line 1 to line above chat box), restore cursor
-        this.writeStream.write(ANSI.SAVE_CURSOR);
-        this.writeStream.write(ANSI.SET_SCROLL_REGION(1, chatBoxStart - 1));
-        this.writeStream.write(ANSI.RESTORE_CURSOR);
-        this.scrollRegionActive = true;
-        // Intercept stdout to ensure output goes to scroll region
-        this.interceptOutput();
-    }
-    /**
-     * Reset scroll region to full terminal
-     */
-    resetScrollRegion() {
-        if (!this.scrollRegionActive)
-            return;
-        this.writeStream.write(ANSI.SAVE_CURSOR);
-        this.writeStream.write(ANSI.RESET_SCROLL_REGION);
-        this.writeStream.write(ANSI.RESTORE_CURSOR);
-        this.scrollRegionActive = false;
-        this.restoreOutput();
-    }
-    /**
-     * Intercept stdout to position output correctly in scroll region
-     */
-    interceptOutput() {
-        if (this.outputIntercepted)
-            return;
-        this.originalStdoutWrite = this.writeStream.write.bind(this.writeStream);
-        const self = this;
-        const chatBoxStart = this.getChatBoxStartRow();
-        // Replace stdout.write to redirect output to scroll region
-        this.writeStream.write = function (chunk, encodingOrCallback, callback) {
-            if (!self.originalStdoutWrite || !self.state.isActive) {
-                if (self.originalStdoutWrite) {
-                    if (typeof encodingOrCallback === 'function') {
-                        return self.originalStdoutWrite(chunk, encodingOrCallback);
-                    }
-                    return self.originalStdoutWrite(chunk, encodingOrCallback, callback);
-                }
-                return true;
-            }
-            // Save cursor, move to output area, write, restore cursor to chat box
-            const output = typeof chunk === 'string' ? chunk : chunk.toString();
-            // Skip if it's just cursor positioning
-            if (/^\x1b\[\d*[ABCDGHJ]/.test(output) && output.length < 10) {
-                return true;
-            }
-            // Position at end of scroll region for output
-            self.originalStdoutWrite(ANSI.SAVE_CURSOR);
-            self.originalStdoutWrite(ANSI.CURSOR_TO(chatBoxStart - 1, 1));
-            // Write the actual content
-            let result;
-            if (typeof encodingOrCallback === 'function') {
-                result = self.originalStdoutWrite(chunk, encodingOrCallback);
-            }
-            else {
-                result = self.originalStdoutWrite(chunk, encodingOrCallback, callback);
-            }
-            // Restore cursor to chat box
-            self.originalStdoutWrite(ANSI.RESTORE_CURSOR);
-            return result;
-        };
-        this.outputIntercepted = true;
-    }
-    /**
-     * Restore original stdout.write
-     */
-    restoreOutput() {
-        if (!this.outputIntercepted || !this.originalStdoutWrite)
-            return;
-        this.writeStream.write = this.originalStdoutWrite;
-        this.originalStdoutWrite = null;
-        this.outputIntercepted = false;
-    }
-    /**
-     * Write to the output area (above the chat box)
-     * This is the proper way for other code to output while chat box is active
-     */
-    writeToOutput(text) {
-        if (!this.state.isActive) {
-            this.writeStream.write(text);
-            return;
-        }
-        const chatBoxStart = this.getChatBoxStartRow();
-        // Save cursor, move to scroll region, write, restore cursor
-        this.writeStream.write(ANSI.SAVE_CURSOR);
-        this.writeStream.write(ANSI.CURSOR_TO(chatBoxStart - 1, 1));
-        // Use original write if intercepted
-        if (this.originalStdoutWrite) {
-            this.originalStdoutWrite(text);
-        }
-        else {
-            this.writeStream.write(text);
-        }
-        this.writeStream.write(ANSI.RESTORE_CURSOR);
-        this.render(); // Re-render chat box to ensure cursor position
-    }
-    /**
-     * Activate the chat box - start listening for input
-     */
-    activate() {
-        if (this.state.isActive)
-            return;
-        this.state.isActive = true;
-        // Set up raw mode for capturing all keypresses
-        if (this.readStream.isTTY) {
-            this.readStream.setRawMode(true);
-        }
-        readline.emitKeypressEvents(this.readStream);
-        // Handle keypresses
-        this.keypressHandler = (str, key) => this.handleKeypress(str, key);
-        this.readStream.on('keypress', this.keypressHandler);
-        // Handle terminal resize
-        this.resizeHandler = () => {
-            // On resize, need to reset and re-setup scroll region
-            if (this.scrollRegionActive) {
-                this.resetScrollRegion();
-                this.setupScrollRegion();
-            }
-            this.render();
-        };
-        this.writeStream.on('resize', this.resizeHandler);
-        // Clear screen and set up scroll region
-        this.clearAndSetup();
-        // Initial render
-        this.render();
-    }
-    /**
-     * Clear screen and set up the chat box at bottom
-     */
-    clearAndSetup() {
-        const chatBoxStart = this.getChatBoxStartRow();
-        // Position cursor at start of chat box area
-        this.writeStream.write(ANSI.CURSOR_TO(chatBoxStart, 1));
-        // Set up scroll region
-        this.setupScrollRegion();
-    }
-    /**
-     * Deactivate the chat box - stop listening for input
-     */
-    deactivate() {
-        if (!this.state.isActive)
-            return;
-        this.state.isActive = false;
-        // Reset scroll region
-        this.resetScrollRegion();
-        // Remove event handlers
-        if (this.keypressHandler) {
-            this.readStream.off('keypress', this.keypressHandler);
-            this.keypressHandler = null;
-        }
-        if (this.resizeHandler) {
-            this.writeStream.off('resize', this.resizeHandler);
-            this.resizeHandler = null;
-        }
-        // Restore raw mode
-        if (this.readStream.isTTY) {
-            this.readStream.setRawMode(false);
-        }
-    }
-    /**
-     * Handle keypress events
-     */
-    handleKeypress(str, key) {
-        if (!key)
-            return;
-        // Handle special keys
-        if (key.ctrl) {
-            switch (key.name) {
-                case 'c':
-                    this.emit('interrupt');
-                    return;
-                case 'd':
-                    if (this.getText().length === 0) {
-                        this.emit('cancel');
-                    }
-                    return;
-                case 'a': // Home
-                    this.cursorToLineStart();
-                    break;
-                case 'e': // End
-                    this.cursorToLineEnd();
-                    break;
-                case 'k': // Kill to end of line
-                    this.killToEndOfLine();
-                    break;
-                case 'u': // Kill to start of line
-                    this.killToStartOfLine();
-                    break;
-                case 'w': // Delete word backward
-                    this.deleteWordBackward();
-                    break;
-                case 'left': // Word left
-                    this.cursorWordLeft();
-                    break;
-                case 'right': // Word right
-                    this.cursorWordRight();
-                    break;
-                case 'up': // Scroll up
-                    this.scrollUp();
-                    break;
-                case 'down': // Scroll down
-                    this.scrollDown();
-                    break;
-            }
-            this.render();
-            return;
-        }
-        if (key.meta) {
-            switch (key.name) {
-                case 'left': // Word left (alt+left)
-                    this.cursorWordLeft();
-                    break;
-                case 'right': // Word right (alt+right)
-                    this.cursorWordRight();
-                    break;
-                case 'backspace': // Delete word backward (alt+backspace)
-                    this.deleteWordBackward();
-                    break;
-            }
-            this.render();
-            return;
-        }
-        switch (key.name) {
-            case 'return':
-                if (key.shift) {
-                    // Shift+Enter: insert newline
-                    this.insertNewline();
-                }
-                else {
-                    // Enter: submit
-                    this.submit();
-                    return;
-                }
-                break;
-            case 'backspace':
-                this.deleteBackward();
-                break;
-            case 'delete':
-                this.deleteForward();
-                break;
-            case 'up':
-                this.cursorUp();
-                break;
-            case 'down':
-                this.cursorDown();
-                break;
-            case 'left':
-                this.cursorLeft();
-                break;
-            case 'right':
-                this.cursorRight();
-                break;
-            case 'home':
-                this.cursorToLineStart();
-                break;
-            case 'end':
-                this.cursorToLineEnd();
-                break;
-            case 'pageup':
-                this.pageUp();
-                break;
-            case 'pagedown':
-                this.pageDown();
-                break;
-            case 'tab':
-                // Insert 2 spaces for tab
-                this.insertText('  ');
-                break;
-            case 'escape':
-                this.emit('cancel');
-                return;
-            default:
-                // Insert printable characters
-                if (str && str.length > 0 && !key.ctrl && !key.meta) {
-                    this.insertText(str);
-                }
-                break;
-        }
-        this.render();
-        this.emit('change', this.getText());
-    }
-    /**
-     * Insert text at cursor position
-     */
-    insertText(text) {
-        const { cursorRow, cursorCol, lines } = this.state;
-        const line = this.getLine(cursorRow);
-        // Handle multi-character paste (may contain newlines)
-        const parts = text.split('\n');
-        if (parts.length === 1) {
-            // Single line insert
-            this.setLine(cursorRow, line.slice(0, cursorCol) + text + line.slice(cursorCol));
-            this.state.cursorCol += text.length;
-        }
-        else {
-            // Multi-line paste
-            const before = line.slice(0, cursorCol);
-            const after = line.slice(cursorCol);
-            const firstPart = parts[0] ?? '';
-            this.setLine(cursorRow, before + firstPart);
-            for (let i = 1; i < parts.length; i++) {
-                lines.splice(cursorRow + i, 0, parts[i] ?? '');
-            }
-            const lastIdx = cursorRow + parts.length - 1;
-            this.setLine(lastIdx, this.getLine(lastIdx) + after);
-            this.state.cursorRow += parts.length - 1;
-            const lastPart = parts[parts.length - 1];
-            this.state.cursorCol = lastPart?.length ?? 0;
-        }
-        // Enforce max lines
-        while (lines.length > this.config.maxLines) {
-            lines.shift();
-            if (this.state.cursorRow > 0)
-                this.state.cursorRow--;
-        }
-        this.ensureCursorVisible();
-    }
-    /**
-     * Insert a newline at cursor position
-     */
-    insertNewline() {
-        const { cursorRow, cursorCol, lines } = this.state;
-        const line = this.getLine(cursorRow);
-        const before = line.slice(0, cursorCol);
-        const after = line.slice(cursorCol);
-        this.setLine(cursorRow, before);
-        lines.splice(cursorRow + 1, 0, after);
-        this.state.cursorRow++;
-        this.state.cursorCol = 0;
-        // Enforce max lines
-        if (lines.length > this.config.maxLines) {
-            lines.shift();
-            this.state.cursorRow--;
-        }
-        this.ensureCursorVisible();
-    }
-    /**
-     * Delete character before cursor
-     */
-    deleteBackward() {
-        const { cursorRow, cursorCol, lines } = this.state;
-        const currentLine = this.getLine(cursorRow);
-        if (cursorCol > 0) {
-            // Delete within line
-            this.setLine(cursorRow, currentLine.slice(0, cursorCol - 1) + currentLine.slice(cursorCol));
-            this.state.cursorCol--;
-        }
-        else if (cursorRow > 0) {
-            // Join with previous line
-            const prevLine = this.getLine(cursorRow - 1);
-            this.setLine(cursorRow - 1, prevLine + currentLine);
-            lines.splice(cursorRow, 1);
-            this.state.cursorRow--;
-            this.state.cursorCol = prevLine.length;
-        }
-        this.ensureCursorVisible();
-    }
-    /**
-     * Delete character after cursor
-     */
-    deleteForward() {
-        const { cursorRow, cursorCol, lines } = this.state;
-        const line = this.getLine(cursorRow);
-        if (cursorCol < line.length) {
-            // Delete within line
-            this.setLine(cursorRow, line.slice(0, cursorCol) + line.slice(cursorCol + 1));
-        }
-        else if (cursorRow < lines.length - 1) {
-            // Join with next line
-            this.setLine(cursorRow, line + this.getLine(cursorRow + 1));
-            lines.splice(cursorRow + 1, 1);
-        }
-    }
-    /**
-     * Delete word backward
-     */
-    deleteWordBackward() {
-        const { cursorRow, cursorCol } = this.state;
-        const line = this.getLine(cursorRow);
-        if (cursorCol === 0) {
-            if (cursorRow > 0) {
-                this.deleteBackward();
-            }
-            return;
-        }
-        // Find word boundary
-        let pos = cursorCol;
-        // Skip spaces
-        while (pos > 0 && line.charAt(pos - 1) === ' ')
-            pos--;
-        // Skip word
-        while (pos > 0 && line.charAt(pos - 1) !== ' ')
-            pos--;
-        this.setLine(cursorRow, line.slice(0, pos) + line.slice(cursorCol));
-        this.state.cursorCol = pos;
-    }
-    /**
-     * Kill (delete) to end of line
-     */
-    killToEndOfLine() {
-        const { cursorRow, cursorCol } = this.state;
-        this.setLine(cursorRow, this.getLine(cursorRow).slice(0, cursorCol));
-    }
-    /**
-     * Kill (delete) to start of line
-     */
-    killToStartOfLine() {
-        const { cursorRow, cursorCol } = this.state;
-        this.setLine(cursorRow, this.getLine(cursorRow).slice(cursorCol));
-        this.state.cursorCol = 0;
-    }
-    /**
-     * Move cursor left
-     */
-    cursorLeft() {
-        if (this.state.cursorCol > 0) {
-            this.state.cursorCol--;
-        }
-        else if (this.state.cursorRow > 0) {
-            this.state.cursorRow--;
-            this.state.cursorCol = this.getLine(this.state.cursorRow).length;
-        }
-        this.ensureCursorVisible();
-    }
-    /**
-     * Move cursor right
-     */
-    cursorRight() {
-        const line = this.getLine(this.state.cursorRow);
-        if (this.state.cursorCol < line.length) {
-            this.state.cursorCol++;
-        }
-        else if (this.state.cursorRow < this.state.lines.length - 1) {
-            this.state.cursorRow++;
-            this.state.cursorCol = 0;
-        }
-        this.ensureCursorVisible();
-    }
-    /**
-     * Move cursor up
-     */
-    cursorUp() {
-        if (this.state.cursorRow > 0) {
-            this.state.cursorRow--;
-            // Clamp column to line length
-            this.state.cursorCol = Math.min(this.state.cursorCol, this.getLine(this.state.cursorRow).length);
-        }
-        this.ensureCursorVisible();
-    }
-    /**
-     * Move cursor down
-     */
-    cursorDown() {
-        if (this.state.cursorRow < this.state.lines.length - 1) {
-            this.state.cursorRow++;
-            // Clamp column to line length
-            this.state.cursorCol = Math.min(this.state.cursorCol, this.getLine(this.state.cursorRow).length);
-        }
-        this.ensureCursorVisible();
-    }
-    /**
-     * Move cursor to start of line
-     */
-    cursorToLineStart() {
-        this.state.cursorCol = 0;
-    }
-    /**
-     * Move cursor to end of line
-     */
-    cursorToLineEnd() {
-        this.state.cursorCol = this.getLine(this.state.cursorRow).length;
-    }
-    /**
-     * Move cursor one word left
-     */
-    cursorWordLeft() {
-        const { cursorRow, cursorCol } = this.state;
-        const line = this.getLine(cursorRow);
-        if (cursorCol === 0) {
-            if (cursorRow > 0) {
-                this.state.cursorRow--;
-                this.state.cursorCol = this.getLine(this.state.cursorRow).length;
-            }
-            return;
-        }
-        let pos = cursorCol;
-        // Skip spaces
-        while (pos > 0 && line.charAt(pos - 1) === ' ')
-            pos--;
-        // Skip word
-        while (pos > 0 && line.charAt(pos - 1) !== ' ')
-            pos--;
-        this.state.cursorCol = pos;
-        this.ensureCursorVisible();
-    }
-    /**
-     * Move cursor one word right
-     */
-    cursorWordRight() {
-        const { cursorRow, cursorCol, lines } = this.state;
-        const line = this.getLine(cursorRow);
-        if (cursorCol >= line.length) {
-            if (cursorRow < lines.length - 1) {
-                this.state.cursorRow++;
-                this.state.cursorCol = 0;
-            }
-            return;
-        }
-        let pos = cursorCol;
-        // Skip word
-        while (pos < line.length && line.charAt(pos) !== ' ')
-            pos++;
-        // Skip spaces
-        while (pos < line.length && line.charAt(pos) === ' ')
-            pos++;
-        this.state.cursorCol = pos;
-        this.ensureCursorVisible();
-    }
-    /**
-     * Page up
-     */
-    pageUp() {
-        const linesToMove = this.config.visibleLines;
-        this.state.cursorRow = Math.max(0, this.state.cursorRow - linesToMove);
-        this.state.cursorCol = Math.min(this.state.cursorCol, this.getLine(this.state.cursorRow).length);
-        this.ensureCursorVisible();
-    }
-    /**
-     * Page down
-     */
-    pageDown() {
-        const linesToMove = this.config.visibleLines;
-        this.state.cursorRow = Math.min(this.state.lines.length - 1, this.state.cursorRow + linesToMove);
-        this.state.cursorCol = Math.min(this.state.cursorCol, this.getLine(this.state.cursorRow).length);
-        this.ensureCursorVisible();
-    }
-    /**
-     * Scroll up (without moving cursor)
-     */
-    scrollUp() {
-        if (this.state.scrollOffset > 0) {
-            this.state.scrollOffset--;
-        }
-    }
-    /**
-     * Scroll down (without moving cursor)
-     */
-    scrollDown() {
-        const maxScroll = Math.max(0, this.state.lines.length - this.config.visibleLines);
-        if (this.state.scrollOffset < maxScroll) {
-            this.state.scrollOffset++;
-        }
-    }
-    /**
-     * Ensure cursor is visible (adjust scroll if needed)
-     */
-    ensureCursorVisible() {
-        const { cursorRow, scrollOffset } = this.state;
-        const { visibleLines } = this.config;
-        // Scroll up if cursor is above visible area
-        if (cursorRow < scrollOffset) {
-            this.state.scrollOffset = cursorRow;
-        }
-        // Scroll down if cursor is below visible area
-        if (cursorRow >= scrollOffset + visibleLines) {
-            this.state.scrollOffset = cursorRow - visibleLines + 1;
-        }
-    }
-    /**
-     * Submit the current content
-     */
-    submit() {
-        const text = this.getText();
-        this.clear();
-        this.emit('submit', text);
-    }
-    /**
-     * Get the full text content
-     */
-    getText() {
-        return this.state.lines.join('\n');
-    }
-    /**
-     * Set the text content
-     */
-    setText(text) {
-        this.state.lines = text.split('\n');
-        if (this.state.lines.length === 0) {
-            this.state.lines = [''];
-        }
-        this.state.cursorRow = this.state.lines.length - 1;
-        this.state.cursorCol = this.getLine(this.state.cursorRow).length;
-        this.state.scrollOffset = 0;
-        this.ensureCursorVisible();
-        this.render();
-    }
-    /**
-     * Clear the content
-     */
-    clear() {
-        this.state.lines = [''];
-        this.state.cursorRow = 0;
-        this.state.cursorCol = 0;
-        this.state.scrollOffset = 0;
-        this.render();
-    }
-    /**
-     * Render the chat box
-     */
-    render() {
-        if (!this.state.isActive)
-            return;
-        const { cols } = this.getTerminalSize();
-        const startRow = this.getChatBoxStartRow();
-        const { lines, cursorRow, cursorCol, scrollOffset } = this.state;
-        const { visibleLines, prompt } = this.config;
-        // Hide cursor during render
-        this.writeStream.write(ANSI.HIDE_CURSOR);
-        // Move to start of chat box area
-        this.writeStream.write(ANSI.CURSOR_TO(startRow, 1));
-        // Draw separator line
-        const separatorWidth = Math.min(cols - 2, 55);
-        this.writeStream.write(ANSI.CLEAR_LINE);
-        this.writeStream.write(theme.ui.border('─'.repeat(separatorWidth)));
-        // Draw visible lines
-        const promptWidth = prompt.length;
-        const contentWidth = cols - promptWidth - 1;
-        for (let i = 0; i < visibleLines; i++) {
-            const lineIndex = scrollOffset + i;
-            const lineContent = lineIndex < lines.length ? (lines[lineIndex] ?? '') : '';
-            this.writeStream.write(ANSI.CURSOR_TO(startRow + 1 + i, 1));
-            this.writeStream.write(ANSI.CLEAR_LINE);
-            // Draw prompt for first visible line or continuation indicator
-            if (i === 0 && scrollOffset === 0) {
-                this.writeStream.write(theme.user(prompt));
-            }
-            else if (lineIndex < lines.length) {
-                // Continuation line
-                this.writeStream.write(theme.ui.muted('  '));
-            }
-            else {
-                // Empty line
-                this.writeStream.write('  ');
-            }
-            // Draw line content (truncate if needed)
-            let displayContent = lineContent;
-            if (displayContent.length > contentWidth) {
-                displayContent = displayContent.slice(0, contentWidth - 1) + '…';
-            }
-            this.writeStream.write(displayContent);
-        }
-        // Calculate actual cursor position on screen
-        const cursorScreenRow = startRow + 1 + (cursorRow - scrollOffset);
-        const cursorScreenCol = promptWidth + cursorCol + 1;
-        // Position cursor
-        this.writeStream.write(ANSI.CURSOR_TO(cursorScreenRow, Math.min(cursorScreenCol, cols)));
-        // Show cursor
-        this.writeStream.write(ANSI.SHOW_CURSOR);
-    }
-    /**
-     * Clear the chat box area from screen
-     */
-    clearScreen() {
-        const startRow = this.getChatBoxStartRow();
-        const { visibleLines } = this.config;
-        for (let i = 0; i <= visibleLines; i++) {
-            this.writeStream.write(ANSI.CURSOR_TO(startRow + i, 1));
-            this.writeStream.write(ANSI.CLEAR_LINE);
-        }
-    }
-    /**
-     * Dispose and cleanup
-     */
-    dispose() {
-        this.deactivate();
-        this.clearScreen();
-        this.restoreOutput();
-    }
-    /**
-     * Check if the chat box is currently active
-     */
-    isActive() {
-        return this.state.isActive;
-    }
-    /**
-     * Get current line count
-     */
-    getLineCount() {
-        return this.state.lines.length;
-    }
-}
-/**
- * Singleton instance
- */
-let globalChatBox = null;
-export function getChatBox(config) {
-    if (!globalChatBox) {
-        globalChatBox = new ChatBox(config);
-    }
-    return globalChatBox;
-}
-export function resetChatBox() {
-    if (globalChatBox) {
-        globalChatBox.dispose();
-        globalChatBox = null;
-    }
-}
-//# sourceMappingURL=chatBox.js.map