@compilr-dev/cli 0.4.0

package/dist/ui/input-prompt-v2.js

@@ -0,0 +1,991 @@
+/**
+ * Input Prompt v2 (Event-Driven)
+ *
+ * Refactored input handling with event-driven architecture.
+ * - Emits events instead of blocking with getInput()
+ * - Supports queue mode for capturing input during agent execution
+ * - Always captures keystrokes (no blocking)
+ *
+ * Events:
+ * - 'submit' - User pressed Enter with input
+ * - 'command' - User submitted a slash command
+ * - 'cancel' - User pressed Ctrl+C
+ * - 'escape' - User pressed Esc (for aborting agent)
+ * - 'change' - Input text changed
+ */
+import { EventEmitter } from 'events';
+import chalk from 'chalk';
+import { getStyles } from '../themes/index.js';
+import * as terminal from './terminal.js';
+import { getAutocompleteCommands } from '../commands.js';
+import { getFileMatches, extractAtMention, replaceAtMention, } from './file-autocomplete.js';
+// =============================================================================
+// Constants
+// =============================================================================
+const MAX_VISIBLE_COMMANDS = 10;
+// =============================================================================
+// Default Commands (from central registry)
+// =============================================================================
+export const DEFAULT_COMMANDS = getAutocompleteCommands();
+// =============================================================================
+// Helper Functions
+// =============================================================================
+/**
+ * Strip ANSI codes from string
+ */
+export function stripAnsi(str) {
+    // eslint-disable-next-line no-control-regex
+    return str.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '');
+}
+/**
+ * Calculate physical lines for wrapped text
+ */
+function calcPhysicalLines(text, startCol, termWidth) {
+    if (text.length === 0)
+        return 1;
+    const totalLen = startCol + text.length;
+    return Math.ceil(totalLen / termWidth) || 1;
+}
+/**
+ * Calculate fuzzy match score for a query against a target string.
+ * Higher score = better match.
+ * Returns -1 if no match.
+ */
+function fuzzyMatchScore(query, target) {
+    const queryLower = query.toLowerCase();
+    const targetLower = target.toLowerCase();
+    // Exact prefix match - highest priority (score 1000+)
+    if (targetLower.startsWith(queryLower)) {
+        return 1000 + (100 - target.length); // Shorter commands rank higher
+    }
+    // Contiguous substring match - high priority (score 500+)
+    if (targetLower.includes(queryLower)) {
+        const index = targetLower.indexOf(queryLower);
+        return 500 + (100 - index); // Earlier matches rank higher
+    }
+    // Fuzzy match - characters appear in order (score 100+)
+    let queryIdx = 0;
+    let consecutiveBonus = 0;
+    let lastMatchIdx = -1;
+    for (let i = 0; i < targetLower.length && queryIdx < queryLower.length; i++) {
+        if (targetLower[i] === queryLower[queryIdx]) {
+            // Bonus for consecutive matches
+            if (lastMatchIdx === i - 1) {
+                consecutiveBonus += 10;
+            }
+            lastMatchIdx = i;
+            queryIdx++;
+        }
+    }
+    // All query characters found in order
+    if (queryIdx === queryLower.length) {
+        return 100 + consecutiveBonus + (100 - target.length);
+    }
+    // No match
+    return -1;
+}
+/**
+ * Filter and rank commands matching input using fuzzy matching
+ */
+function filterCommands(input, commands) {
+    // Score all commands
+    const scored = commands
+        .map((cmd) => ({
+        cmd,
+        score: fuzzyMatchScore(input, cmd.command),
+    }))
+        .filter((item) => item.score >= 0);
+    // Sort by score (highest first)
+    scored.sort((a, b) => b.score - a.score);
+    return scored.map((item) => item.cmd);
+}
+// =============================================================================
+// Input Prompt Class
+// =============================================================================
+export class InputPrompt extends EventEmitter {
+    // Configuration
+    prompt;
+    promptLen;
+    showSeparators;
+    commands;
+    // Input state
+    state = {
+        lines: [''],
+        currentLine: 0,
+        cursorPos: 0,
+    };
+    // Command autocomplete (for /commands)
+    autocomplete = {
+        active: false,
+        matches: [],
+        selectedIndex: 0,
+        scrollOffset: 0,
+    };
+    // File autocomplete (for @paths)
+    fileAutocomplete = {
+        active: false,
+        matches: [],
+        selectedIndex: 0,
+        scrollOffset: 0,
+        partial: '',
+    };
+    // History
+    history = [];
+    historyIndex = -1;
+    savedInput = '';
+    // Queue mode
+    queueMode = false;
+    queuedInputs = [];
+    // Rendering tracking
+    renderedLines = 0;
+    dropdownLines = 0;
+    linesAboveCursor = 0;
+    hasSeparators = false;
+    // Control
+    isRunning = false;
+    // Double Esc detection
+    lastEscTime = 0;
+    DOUBLE_ESC_THRESHOLD_MS = 500; // 500ms window for double Esc
+    // Suggestion (ghost text for next action)
+    suggestion = null;
+    constructor(options = {}) {
+        super();
+        this.prompt = options.prompt ?? getStyles().primary('❯ ');
+        this.promptLen = stripAnsi(this.prompt).length;
+        this.showSeparators = options.showSeparators ?? true;
+        this.commands = options.commands ?? DEFAULT_COMMANDS;
+    }
+    // ===========================================================================
+    // Public API
+    // ===========================================================================
+    /**
+     * Update the prompt string (for dynamic theme changes)
+     */
+    setPrompt(prompt) {
+        this.prompt = prompt;
+        this.promptLen = stripAnsi(prompt).length;
+    }
+    /**
+     * Set a suggestion for the next action (ghost text)
+     */
+    setSuggestion(action) {
+        this.suggestion = action;
+    }
+    /**
+     * Get the current suggestion
+     */
+    getSuggestion() {
+        return this.suggestion;
+    }
+    /**
+     * Clear the current suggestion
+     */
+    clearSuggestion() {
+        this.suggestion = null;
+    }
+    /**
+     * Start input capture (non-blocking, event-driven)
+     */
+    start() {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        terminal.enableRawMode();
+        this.resetState();
+        process.stdin.on('data', this.handleData);
+    }
+    /**
+     * Stop input capture
+     */
+    stop() {
+        if (!this.isRunning)
+            return;
+        this.isRunning = false;
+        terminal.disableRawMode();
+        process.stdin.removeListener('data', this.handleData);
+    }
+    /**
+     * Check if running
+     */
+    isActive() {
+        return this.isRunning;
+    }
+    /**
+     * Enable/disable queue mode
+     * In queue mode, Enter adds to queue instead of emitting 'submit'
+     */
+    setQueueMode(enabled) {
+        this.queueMode = enabled;
+    }
+    /**
+     * Check if in queue mode
+     */
+    isQueueMode() {
+        return this.queueMode;
+    }
+    /**
+     * Get all queued inputs (FIFO order)
+     */
+    getQueuedInputs() {
+        return [...this.queuedInputs];
+    }
+    /**
+     * Pop the first queued input
+     */
+    popQueuedInput() {
+        return this.queuedInputs.shift() ?? null;
+    }
+    /**
+     * Check if there are queued inputs
+     */
+    hasQueuedInput() {
+        return this.queuedInputs.length > 0;
+    }
+    /**
+     * Get number of queued inputs
+     */
+    getQueueLength() {
+        return this.queuedInputs.length;
+    }
+    /**
+     * Clear the queue
+     */
+    clearQueue() {
+        this.queuedInputs = [];
+    }
+    /**
+     * Get current buffer value
+     */
+    getValue() {
+        return this.state.lines.join('\n');
+    }
+    /**
+     * Set buffer value
+     */
+    setValue(value) {
+        this.state.lines = value.split('\n');
+        this.state.currentLine = this.state.lines.length - 1;
+        this.state.cursorPos = this.state.lines[this.state.currentLine].length;
+        this.updateAutocomplete();
+    }
+    /**
+     * Clear input buffer
+     */
+    clearInput() {
+        this.state = {
+            lines: [''],
+            currentLine: 0,
+            cursorPos: 0,
+        };
+        this.autocomplete = {
+            active: false,
+            matches: [],
+            selectedIndex: 0,
+            scrollOffset: 0,
+        };
+        this.fileAutocomplete = {
+            active: false,
+            matches: [],
+            selectedIndex: 0,
+            scrollOffset: 0,
+            partial: '',
+        };
+    }
+    /**
+     * Add command to history
+     */
+    addToHistory(input) {
+        if (input.trim() && (this.history.length === 0 || this.history[this.history.length - 1] !== input)) {
+            this.history.push(input);
+        }
+    }
+    /**
+     * Render the input prompt - returns array of lines
+     * Does NOT write to terminal (Footer handles that)
+     */
+    render() {
+        const lines = [];
+        // Top separator
+        if (this.showSeparators) {
+            lines.push(this.getSeparatorLine());
+        }
+        // Input lines
+        const s = getStyles();
+        for (let i = 0; i < this.state.lines.length; i++) {
+            const linePrompt = i === 0 ? this.prompt : s.muted('   \\ ');
+            const lineContent = this.state.lines[i];
+            // Show suggestion as ghost text on first line when input is empty
+            if (i === 0 && lineContent === '' && this.suggestion && !this.autocomplete.active && !this.fileAutocomplete.active) {
+                const hint = s.muted(' (tab to accept)');
+                lines.push(linePrompt + s.muted(this.suggestion) + hint);
+            }
+            else {
+                lines.push(linePrompt + lineContent);
+            }
+        }
+        // Bottom separator
+        if (this.showSeparators) {
+            lines.push(this.getSeparatorLine());
+        }
+        return lines;
+    }
+    /**
+     * Get the cursor position info for rendering
+     */
+    getCursorInfo() {
+        const termWidth = terminal.getTerminalWidth();
+        const currentLinePromptLen = this.state.currentLine === 0 ? this.promptLen : 5;
+        const cursorAbsPos = currentLinePromptLen + this.state.cursorPos;
+        // Calculate which row within input (accounting for separators)
+        let row = this.showSeparators ? 1 : 0; // Start after top separator
+        for (let i = 0; i < this.state.currentLine; i++) {
+            const lp = i === 0 ? this.promptLen : 5;
+            row += calcPhysicalLines(this.state.lines[i], lp, termWidth);
+        }
+        row += Math.floor(cursorAbsPos / termWidth);
+        const col = cursorAbsPos % termWidth;
+        return { row, col };
+    }
+    /**
+     * Get autocomplete dropdown lines (if active)
+     */
+    getAutocompleteLines() {
+        const s = getStyles();
+        // File autocomplete takes priority
+        if (this.fileAutocomplete.active && this.fileAutocomplete.matches.length > 0) {
+            const lines = [];
+            const offset = this.fileAutocomplete.scrollOffset;
+            const visible = this.fileAutocomplete.matches.slice(offset, offset + MAX_VISIBLE_COMMANDS);
+            const total = this.fileAutocomplete.matches.length;
+            // Show scroll indicator if there are more items above
+            if (offset > 0) {
+                lines.push(s.muted(`  ↑ ${String(offset)} more above`));
+            }
+            for (let i = 0; i < visible.length; i++) {
+                const file = visible[i];
+                const actualIndex = offset + i;
+                const isSelected = actualIndex === this.fileAutocomplete.selectedIndex;
+                const prefix = isSelected ? s.primary('❯ ') : '  ';
+                const icon = file.isDirectory ? s.warning('📁 ') : s.info('📄 ');
+                const name = isSelected ? s.primary(chalk.bold(file.path)) : file.path;
+                lines.push(`${prefix}${icon}${name}`);
+            }
+            // Show scroll indicator if there are more items below
+            const remaining = total - offset - visible.length;
+            if (remaining > 0) {
+                lines.push(s.muted(`  ↓ ${String(remaining)} more below`));
+            }
+            return lines;
+        }
+        // Command autocomplete
+        if (!this.autocomplete.active || this.autocomplete.matches.length === 0) {
+            return [];
+        }
+        const lines = [];
+        const offset = this.autocomplete.scrollOffset;
+        const visible = this.autocomplete.matches.slice(offset, offset + MAX_VISIBLE_COMMANDS);
+        const total = this.autocomplete.matches.length;
+        // Show scroll indicator if there are more items above
+        if (offset > 0) {
+            lines.push(s.muted(`  ↑ ${String(offset)} more above`));
+        }
+        for (let i = 0; i < visible.length; i++) {
+            const cmd = visible[i];
+            const actualIndex = offset + i;
+            const isSelected = actualIndex === this.autocomplete.selectedIndex;
+            const prefix = isSelected ? s.primary('❯ ') : '  ';
+            const name = isSelected ? s.primary(chalk.bold(cmd.command)) : cmd.command;
+            const desc = s.muted(` - ${cmd.description}`);
+            lines.push(`${prefix}${name}${desc}`);
+        }
+        // Show scroll indicator if there are more items below
+        const remaining = total - offset - visible.length;
+        if (remaining > 0) {
+            lines.push(s.muted(`  ↓ ${String(remaining)} more below`));
+        }
+        return lines;
+    }
+    /**
+     * Check if autocomplete is showing
+     */
+    isAutocompleteActive() {
+        return ((this.autocomplete.active && this.autocomplete.matches.length > 0) ||
+            (this.fileAutocomplete.active && this.fileAutocomplete.matches.length > 0));
+    }
+    /**
+     * Get height of rendered content
+     */
+    getHeight() {
+        let height = this.state.lines.length;
+        if (this.showSeparators)
+            height += 2;
+        return height;
+    }
+    // ===========================================================================
+    // Legacy API (for backwards compatibility during migration)
+    // ===========================================================================
+    /**
+     * @deprecated Use event-driven start() instead
+     * Kept for backwards compatibility during migration
+     */
+    async getInput() {
+        return new Promise((resolve) => {
+            const onSubmit = (input) => {
+                cleanup();
+                resolve({ action: 'submit', value: input });
+            };
+            const onCommand = (command, args) => {
+                cleanup();
+                resolve({ action: 'command', command, args });
+            };
+            const onCancel = () => {
+                cleanup();
+                resolve({ action: 'cancel' });
+            };
+            const cleanup = () => {
+                this.removeListener('submit', onSubmit);
+                this.removeListener('command', onCommand);
+                this.removeListener('cancel', onCancel);
+            };
+            this.on('submit', onSubmit);
+            this.on('command', onCommand);
+            this.on('cancel', onCancel);
+            if (!this.isRunning) {
+                this.start();
+            }
+        });
+    }
+    // ===========================================================================
+    // Private: State Management
+    // ===========================================================================
+    resetState() {
+        this.state = {
+            lines: [''],
+            currentLine: 0,
+            cursorPos: 0,
+        };
+        this.autocomplete = {
+            active: false,
+            matches: [],
+            selectedIndex: 0,
+            scrollOffset: 0,
+        };
+        this.fileAutocomplete = {
+            active: false,
+            matches: [],
+            selectedIndex: 0,
+            scrollOffset: 0,
+            partial: '',
+        };
+        this.historyIndex = -1;
+        this.savedInput = '';
+        this.renderedLines = 0;
+        this.dropdownLines = 0;
+        this.linesAboveCursor = 0;
+        this.hasSeparators = false;
+    }
+    updateAutocomplete() {
+        const fullInput = this.getValue();
+        const currentLine = this.state.lines[this.state.currentLine];
+        const cursorPos = this.state.cursorPos;
+        // Check for @ file path autocomplete first
+        const atMention = extractAtMention(currentLine, cursorPos);
+        if (atMention !== null) {
+            // File autocomplete mode
+            this.autocomplete.active = false;
+            this.autocomplete.matches = [];
+            this.autocomplete.selectedIndex = 0;
+            this.autocomplete.scrollOffset = 0;
+            this.fileAutocomplete.active = true;
+            this.fileAutocomplete.partial = atMention;
+            this.fileAutocomplete.matches = getFileMatches(atMention);
+            if (this.fileAutocomplete.selectedIndex >= this.fileAutocomplete.matches.length) {
+                this.fileAutocomplete.selectedIndex = Math.max(0, this.fileAutocomplete.matches.length - 1);
+                this.fileAutocomplete.scrollOffset = 0;
+            }
+            return;
+        }
+        // Reset file autocomplete
+        this.fileAutocomplete.active = false;
+        this.fileAutocomplete.matches = [];
+        this.fileAutocomplete.selectedIndex = 0;
+        this.fileAutocomplete.scrollOffset = 0;
+        this.fileAutocomplete.partial = '';
+        // Check for / command autocomplete
+        if (fullInput.startsWith('/') && this.state.lines.length === 1) {
+            this.autocomplete.active = true;
+            // Refresh commands dynamically to include newly created custom commands
+            const freshCommands = getAutocompleteCommands();
+            this.autocomplete.matches = filterCommands(fullInput, freshCommands);
+            if (this.autocomplete.selectedIndex >= this.autocomplete.matches.length) {
+                this.autocomplete.selectedIndex = Math.max(0, this.autocomplete.matches.length - 1);
+                this.autocomplete.scrollOffset = 0;
+            }
+        }
+        else {
+            this.autocomplete.active = false;
+            this.autocomplete.matches = [];
+            this.autocomplete.selectedIndex = 0;
+            this.autocomplete.scrollOffset = 0;
+        }
+    }
+    getSeparatorLine() {
+        const s = getStyles();
+        return s.muted('─'.repeat(terminal.getTerminalWidth()));
+    }
+    // ===========================================================================
+    // Private: Input Handling
+    // ===========================================================================
+    handleData = (data) => {
+        if (!this.isRunning)
+            return;
+        const key = data.toString();
+        this.handleKey(key, data);
+    };
+    handleKey(key, data) {
+        // Detect special keys
+        const isEscape = data.length === 1 && data[0] === 0x1b;
+        const isEnter = key === '\r' || key === '\n';
+        const isBackspace = key === '\x7f' || key === '\b';
+        const isTab = key === '\t';
+        const isShiftTab = data.length === 3 && data[0] === 0x1b && data[1] === 0x5b && data[2] === 0x5a;
+        const isCtrlC = key === '\x03';
+        const isUpArrow = data.length === 3 && data[0] === 0x1b && data[1] === 0x5b && data[2] === 0x41;
+        const isDownArrow = data.length === 3 && data[0] === 0x1b && data[1] === 0x5b && data[2] === 0x42;
+        const isLeftArrow = data.length === 3 && data[0] === 0x1b && data[1] === 0x5b && data[2] === 0x44;
+        const isRightArrow = data.length === 3 && data[0] === 0x1b && data[1] === 0x5b && data[2] === 0x43;
+        // Mac Option + Arrow (word navigation)
+        const isOptionLeft = (data.length === 6 &&
+            data[0] === 0x1b &&
+            data[1] === 0x5b &&
+            data[2] === 0x31 &&
+            data[3] === 0x3b &&
+            data[4] === 0x33 &&
+            data[5] === 0x44) ||
+            (data.length === 2 && data[0] === 0x1b && data[1] === 0x62);
+        const isOptionRight = (data.length === 6 &&
+            data[0] === 0x1b &&
+            data[1] === 0x5b &&
+            data[2] === 0x31 &&
+            data[3] === 0x3b &&
+            data[4] === 0x33 &&
+            data[5] === 0x43) ||
+            (data.length === 2 && data[0] === 0x1b && data[1] === 0x66);
+        // Home/End (Cmd+Left/Right on Mac, or Home/End keys)
+        const isHome = key === '\x01' || (data.length === 3 && data[0] === 0x1b && data[1] === 0x5b && data[2] === 0x48);
+        const isEnd = key === '\x05' || (data.length === 3 && data[0] === 0x1b && data[1] === 0x5b && data[2] === 0x46);
+        // Ctrl+C - cancel
+        if (isCtrlC) {
+            this.emit('cancel');
+            return;
+        }
+        // Escape - close autocomplete, double Esc clears input, or emit escape for agent abort
+        if (isEscape) {
+            const now = Date.now();
+            const isDoubleEsc = now - this.lastEscTime < this.DOUBLE_ESC_THRESHOLD_MS;
+            this.lastEscTime = now;
+            if (this.fileAutocomplete.active) {
+                // First priority: close file autocomplete
+                this.fileAutocomplete.active = false;
+                this.fileAutocomplete.matches = [];
+                this.emit('change', this.getValue());
+            }
+            else if (this.autocomplete.active) {
+                // Second priority: close command autocomplete
+                this.autocomplete.active = false;
+                this.autocomplete.matches = [];
+                this.emit('change', this.getValue());
+            }
+            else if (isDoubleEsc && this.getValue().length > 0) {
+                // Third priority: double Esc clears input (if there's content)
+                this.clearInput();
+                this.emit('change', this.getValue());
+            }
+            else {
+                // Fourth priority: emit escape for agent abort
+                this.emit('escape');
+            }
+            return;
+        }
+        // Enter
+        if (isEnter) {
+            this.handleEnter();
+            return;
+        }
+        // Shift+Tab - cycle modes
+        if (isShiftTab) {
+            this.emit('modeChange');
+            return;
+        }
+        // Tab - accept autocomplete or insert spaces
+        if (isTab) {
+            this.handleTab();
+            return;
+        }
+        // Arrow keys
+        if (isUpArrow) {
+            this.handleArrowUp();
+            return;
+        }
+        if (isDownArrow) {
+            this.handleArrowDown();
+            return;
+        }
+        if (isLeftArrow) {
+            this.handleArrowLeft();
+            return;
+        }
+        if (isRightArrow) {
+            this.handleArrowRight();
+            return;
+        }
+        // Word navigation
+        if (isOptionLeft) {
+            this.handleWordLeft();
+            return;
+        }
+        if (isOptionRight) {
+            this.handleWordRight();
+            return;
+        }
+        // Home/End
+        if (isHome) {
+            this.state.cursorPos = 0;
+            this.emit('change', this.getValue());
+            return;
+        }
+        if (isEnd) {
+            this.state.cursorPos = this.state.lines[this.state.currentLine].length;
+            this.emit('change', this.getValue());
+            return;
+        }
+        // Backspace
+        if (isBackspace) {
+            this.handleBackspace();
+            return;
+        }
+        // Regular character(s) - handles typing and paste
+        if (key.length >= 1) {
+            const printable = key
+                .split('')
+                .filter((c) => c.charCodeAt(0) >= 32)
+                .join('');
+            if (printable.length > 0) {
+                // Clear suggestion when user starts typing
+                if (this.suggestion) {
+                    this.suggestion = null;
+                }
+                const line = this.state.lines[this.state.currentLine];
+                this.state.lines[this.state.currentLine] =
+                    line.slice(0, this.state.cursorPos) + printable + line.slice(this.state.cursorPos);
+                this.state.cursorPos += printable.length;
+                this.historyIndex = -1;
+                this.updateAutocomplete();
+                this.emit('change', this.getValue());
+            }
+        }
+    }
+    handleEnter() {
+        const currentLine = this.state.lines[this.state.currentLine];
+        // Continuation with backslash
+        if (currentLine.endsWith('\\')) {
+            this.state.lines[this.state.currentLine] = currentLine.slice(0, -1);
+            this.state.lines.push('');
+            this.state.currentLine++;
+            this.state.cursorPos = 0;
+            this.autocomplete.active = false;
+            this.emit('change', this.getValue());
+            return;
+        }
+        // File autocomplete selection - accept the path and continue
+        if (this.fileAutocomplete.active && this.fileAutocomplete.matches.length > 0) {
+            const selectedFile = this.fileAutocomplete.matches[this.fileAutocomplete.selectedIndex];
+            const result = replaceAtMention(currentLine, this.state.cursorPos, selectedFile.path);
+            this.state.lines[this.state.currentLine] = result.input;
+            this.state.cursorPos = result.cursorPos;
+            this.fileAutocomplete.active = false;
+            this.fileAutocomplete.matches = [];
+            // Don't return - fall through to submit
+        }
+        // Command autocomplete selection - accept the command and continue to execute it
+        if (this.autocomplete.active && this.autocomplete.matches.length > 0) {
+            this.state.lines[0] = this.autocomplete.matches[this.autocomplete.selectedIndex].command;
+            this.state.cursorPos = this.state.lines[0].length;
+            this.autocomplete.active = false;
+            // Don't return - fall through to execute the command
+        }
+        const input = this.getValue();
+        // Empty input - ignore
+        if (!input.trim()) {
+            return;
+        }
+        // Add to history
+        this.addToHistory(input);
+        // Queue mode - add to queue instead of emitting
+        if (this.queueMode) {
+            this.queuedInputs.push(input);
+            this.clearInput();
+            this.emit('change', this.getValue());
+            return;
+        }
+        // Check if it's a command
+        if (input.startsWith('/')) {
+            const parts = input.slice(1).split(/\s+/);
+            const command = parts[0];
+            const args = parts.slice(1).join(' ');
+            this.clearInput();
+            this.emit('command', command, args);
+        }
+        else {
+            this.clearInput();
+            this.emit('submit', input);
+        }
+    }
+    handleTab() {
+        // Accept suggestion if present and input is empty
+        if (this.suggestion && this.getValue() === '') {
+            this.state.lines[0] = this.suggestion;
+            this.state.cursorPos = this.suggestion.length;
+            this.suggestion = null;
+            this.emit('change', this.getValue());
+            return;
+        }
+        // File autocomplete completion
+        if (this.fileAutocomplete.active && this.fileAutocomplete.matches.length > 0) {
+            const selectedFile = this.fileAutocomplete.matches[this.fileAutocomplete.selectedIndex];
+            const currentLine = this.state.lines[this.state.currentLine];
+            const result = replaceAtMention(currentLine, this.state.cursorPos, selectedFile.path);
+            this.state.lines[this.state.currentLine] = result.input;
+            this.state.cursorPos = result.cursorPos;
+            this.fileAutocomplete.active = false;
+            this.fileAutocomplete.matches = [];
+            this.updateAutocomplete(); // Check if still in @ context (e.g., directory selected)
+            this.emit('change', this.getValue());
+            return;
+        }
+        // Command autocomplete completion
+        if (this.autocomplete.active && this.autocomplete.matches.length > 0) {
+            this.state.lines[this.state.currentLine] =
+                this.autocomplete.matches[this.autocomplete.selectedIndex].command;
+            this.state.cursorPos = this.state.lines[this.state.currentLine].length;
+            this.autocomplete.active = false;
+            this.autocomplete.matches = [];
+        }
+        else {
+            // Insert 2 spaces
+            const line = this.state.lines[this.state.currentLine];
+            this.state.lines[this.state.currentLine] =
+                line.slice(0, this.state.cursorPos) + '  ' + line.slice(this.state.cursorPos);
+            this.state.cursorPos += 2;
+            this.historyIndex = -1;
+            this.updateAutocomplete();
+        }
+        this.emit('change', this.getValue());
+    }
+    handleArrowUp() {
+        // File autocomplete navigation
+        if (this.fileAutocomplete.active && this.fileAutocomplete.selectedIndex > 0) {
+            this.fileAutocomplete.selectedIndex--;
+            // Adjust scroll offset if selection goes above visible area
+            if (this.fileAutocomplete.selectedIndex < this.fileAutocomplete.scrollOffset) {
+                this.fileAutocomplete.scrollOffset = this.fileAutocomplete.selectedIndex;
+            }
+            this.emit('change', this.getValue());
+            return;
+        }
+        // Command autocomplete navigation
+        if (this.autocomplete.active && this.autocomplete.selectedIndex > 0) {
+            this.autocomplete.selectedIndex--;
+            // Adjust scroll offset if selection goes above visible area
+            if (this.autocomplete.selectedIndex < this.autocomplete.scrollOffset) {
+                this.autocomplete.scrollOffset = this.autocomplete.selectedIndex;
+            }
+            this.emit('change', this.getValue());
+            return;
+        }
+        const termWidth = terminal.getTerminalWidth();
+        const currentLinePromptLen = this.state.currentLine === 0 ? this.promptLen : 5;
+        const cursorAbsPos = currentLinePromptLen + this.state.cursorPos;
+        const currentPhysicalRow = Math.floor(cursorAbsPos / termWidth);
+        const cursorColInRow = cursorAbsPos % termWidth;
+        // Navigate within wrapped line
+        if (currentPhysicalRow > 0) {
+            const newAbsPos = (currentPhysicalRow - 1) * termWidth + cursorColInRow;
+            this.state.cursorPos = Math.max(0, newAbsPos - currentLinePromptLen);
+            this.state.cursorPos = Math.min(this.state.cursorPos, this.state.lines[this.state.currentLine].length);
+            this.emit('change', this.getValue());
+            return;
+        }
+        // Navigate to previous logical line
+        if (this.state.currentLine > 0) {
+            this.state.currentLine--;
+            const prevLinePromptLen = this.state.currentLine === 0 ? this.promptLen : 5;
+            const prevLineLen = this.state.lines[this.state.currentLine].length;
+            const prevLinePhysical = calcPhysicalLines(this.state.lines[this.state.currentLine], prevLinePromptLen, termWidth);
+            const lastRowStart = (prevLinePhysical - 1) * termWidth;
+            const targetAbsPos = lastRowStart + cursorColInRow;
+            this.state.cursorPos = Math.max(0, targetAbsPos - prevLinePromptLen);
+            this.state.cursorPos = Math.min(this.state.cursorPos, prevLineLen);
+            this.emit('change', this.getValue());
+            return;
+        }
+        // History navigation (at top of input)
+        if (!this.autocomplete.active && this.history.length > 0) {
+            if (this.historyIndex === -1) {
+                this.savedInput = this.getValue();
+            }
+            if (this.historyIndex < this.history.length - 1) {
+                this.historyIndex++;
+                const historyEntry = this.history[this.history.length - 1 - this.historyIndex];
+                this.state.lines = [historyEntry];
+                this.state.currentLine = 0;
+                this.state.cursorPos = historyEntry.length;
+                this.emit('change', this.getValue());
+            }
+        }
+    }
+    handleArrowDown() {
+        // File autocomplete navigation
+        if (this.fileAutocomplete.active &&
+            this.fileAutocomplete.selectedIndex < this.fileAutocomplete.matches.length - 1) {
+            this.fileAutocomplete.selectedIndex++;
+            // Adjust scroll offset if selection goes below visible area
+            const maxVisibleIndex = this.fileAutocomplete.scrollOffset + MAX_VISIBLE_COMMANDS - 1;
+            if (this.fileAutocomplete.selectedIndex > maxVisibleIndex) {
+                this.fileAutocomplete.scrollOffset = this.fileAutocomplete.selectedIndex - MAX_VISIBLE_COMMANDS + 1;
+            }
+            this.emit('change', this.getValue());
+            return;
+        }
+        // Command autocomplete navigation
+        if (this.autocomplete.active &&
+            this.autocomplete.selectedIndex < this.autocomplete.matches.length - 1) {
+            this.autocomplete.selectedIndex++;
+            // Adjust scroll offset if selection goes below visible area
+            const maxVisibleIndex = this.autocomplete.scrollOffset + MAX_VISIBLE_COMMANDS - 1;
+            if (this.autocomplete.selectedIndex > maxVisibleIndex) {
+                this.autocomplete.scrollOffset = this.autocomplete.selectedIndex - MAX_VISIBLE_COMMANDS + 1;
+            }
+            this.emit('change', this.getValue());
+            return;
+        }
+        const termWidth = terminal.getTerminalWidth();
+        const currentLinePromptLen = this.state.currentLine === 0 ? this.promptLen : 5;
+        const cursorAbsPos = currentLinePromptLen + this.state.cursorPos;
+        const currentPhysicalRow = Math.floor(cursorAbsPos / termWidth);
+        const cursorColInRow = cursorAbsPos % termWidth;
+        const currentLinePhysical = calcPhysicalLines(this.state.lines[this.state.currentLine], currentLinePromptLen, termWidth);
+        // Navigate within wrapped line
+        if (currentPhysicalRow < currentLinePhysical - 1) {
+            const newAbsPos = (currentPhysicalRow + 1) * termWidth + cursorColInRow;
+            this.state.cursorPos = Math.max(0, newAbsPos - currentLinePromptLen);
+            this.state.cursorPos = Math.min(this.state.cursorPos, this.state.lines[this.state.currentLine].length);
+            this.emit('change', this.getValue());
+            return;
+        }
+        // Navigate to next logical line
+        if (this.state.currentLine < this.state.lines.length - 1) {
+            this.state.currentLine++;
+            const nextLinePromptLen = this.state.currentLine === 0 ? this.promptLen : 5;
+            const nextLineLen = this.state.lines[this.state.currentLine].length;
+            this.state.cursorPos = Math.max(0, cursorColInRow - nextLinePromptLen);
+            this.state.cursorPos = Math.min(this.state.cursorPos, nextLineLen);
+            this.emit('change', this.getValue());
+            return;
+        }
+        // History forward
+        if (this.historyIndex >= 0) {
+            this.historyIndex--;
+            if (this.historyIndex === -1) {
+                this.state.lines = this.savedInput.split('\n');
+                this.state.currentLine = this.state.lines.length - 1;
+                this.state.cursorPos = this.state.lines[this.state.currentLine].length;
+            }
+            else {
+                const historyEntry = this.history[this.history.length - 1 - this.historyIndex];
+                this.state.lines = [historyEntry];
+                this.state.currentLine = 0;
+                this.state.cursorPos = historyEntry.length;
+            }
+            this.updateAutocomplete();
+            this.emit('change', this.getValue());
+        }
+    }
+    handleArrowLeft() {
+        if (this.state.cursorPos > 0) {
+            this.state.cursorPos--;
+            this.emit('change', this.getValue());
+        }
+        else if (this.state.currentLine > 0) {
+            this.state.currentLine--;
+            this.state.cursorPos = this.state.lines[this.state.currentLine].length;
+            this.emit('change', this.getValue());
+        }
+    }
+    handleArrowRight() {
+        if (this.state.cursorPos < this.state.lines[this.state.currentLine].length) {
+            this.state.cursorPos++;
+            this.emit('change', this.getValue());
+        }
+        else if (this.state.currentLine < this.state.lines.length - 1) {
+            this.state.currentLine++;
+            this.state.cursorPos = 0;
+            this.emit('change', this.getValue());
+        }
+    }
+    handleWordLeft() {
+        const line = this.state.lines[this.state.currentLine];
+        if (this.state.cursorPos > 0) {
+            let pos = this.state.cursorPos;
+            while (pos > 0 && line[pos - 1] === ' ')
+                pos--;
+            while (pos > 0 && line[pos - 1] !== ' ')
+                pos--;
+            this.state.cursorPos = pos;
+            this.emit('change', this.getValue());
+        }
+        else if (this.state.currentLine > 0) {
+            this.state.currentLine--;
+            this.state.cursorPos = this.state.lines[this.state.currentLine].length;
+            this.emit('change', this.getValue());
+        }
+    }
+    handleWordRight() {
+        const line = this.state.lines[this.state.currentLine];
+        if (this.state.cursorPos < line.length) {
+            let pos = this.state.cursorPos;
+            while (pos < line.length && line[pos] !== ' ')
+                pos++;
+            while (pos < line.length && line[pos] === ' ')
+                pos++;
+            this.state.cursorPos = pos;
+            this.emit('change', this.getValue());
+        }
+        else if (this.state.currentLine < this.state.lines.length - 1) {
+            this.state.currentLine++;
+            this.state.cursorPos = 0;
+            this.emit('change', this.getValue());
+        }
+    }
+    handleBackspace() {
+        this.historyIndex = -1;
+        if (this.state.cursorPos > 0) {
+            const line = this.state.lines[this.state.currentLine];
+            this.state.lines[this.state.currentLine] =
+                line.slice(0, this.state.cursorPos - 1) + line.slice(this.state.cursorPos);
+            this.state.cursorPos--;
+            this.updateAutocomplete();
+            this.emit('change', this.getValue());
+        }
+        else if (this.state.currentLine > 0) {
+            const currentLine = this.state.lines[this.state.currentLine];
+            const prevLine = this.state.lines[this.state.currentLine - 1];
+            this.state.lines[this.state.currentLine - 1] = prevLine + currentLine;
+            this.state.lines.splice(this.state.currentLine, 1);
+            this.state.currentLine--;
+            this.state.cursorPos = prevLine.length;
+            this.updateAutocomplete();
+            this.emit('change', this.getValue());
+        }
+    }
+}