wave-code 0.0.4 → 0.0.5

package/dist/managers/InputManager.js

@@ -0,0 +1,806 @@
+import { searchFiles as searchFilesUtil } from "../utils/fileSearch.js";
+import { readClipboardImage } from "../utils/clipboard.js";
+export class InputManager {
+    constructor(callbacks = {}) {
+        // Core input state
+        this.inputText = "";
+        this.cursorPosition = 0;
+        // File selector state
+        this.showFileSelector = false;
+        this.atPosition = -1;
+        this.fileSearchQuery = "";
+        this.filteredFiles = [];
+        this.fileSearchDebounceTimer = null;
+        // Command selector state
+        this.showCommandSelector = false;
+        this.slashPosition = -1;
+        this.commandSearchQuery = "";
+        // Bash history selector state
+        this.showBashHistorySelector = false;
+        this.exclamationPosition = -1;
+        this.bashHistorySearchQuery = "";
+        // Memory type selector state
+        this.showMemoryTypeSelector = false;
+        this.memoryMessage = "";
+        // Input history state
+        this.userInputHistory = [];
+        this.historyIndex = -1;
+        this.historyBuffer = "";
+        // Paste debounce state
+        this.pasteDebounceTimer = null;
+        this.pasteBuffer = "";
+        this.initialPasteCursorPosition = 0;
+        this.isPasting = false;
+        // Long text compression state
+        this.longTextCounter = 0;
+        this.longTextMap = new Map();
+        // Image management state
+        this.attachedImages = [];
+        this.imageIdCounter = 1;
+        // Additional UI state
+        this.showBashManager = false;
+        this.showMcpManager = false;
+        // Flag to prevent handleInput conflicts when selector selection occurs
+        this.selectorJustUsed = false;
+        this.callbacks = callbacks;
+    }
+    // Update callbacks
+    updateCallbacks(callbacks) {
+        this.callbacks = { ...this.callbacks, ...callbacks };
+    }
+    // Core input methods
+    getInputText() {
+        return this.inputText;
+    }
+    setInputText(text) {
+        this.inputText = text;
+        this.callbacks.onInputTextChange?.(text);
+    }
+    getCursorPosition() {
+        return this.cursorPosition;
+    }
+    setCursorPosition(position) {
+        this.cursorPosition = Math.max(0, Math.min(this.inputText.length, position));
+        this.callbacks.onCursorPositionChange?.(this.cursorPosition);
+    }
+    insertTextAtCursor(text, callback) {
+        const beforeCursor = this.inputText.substring(0, this.cursorPosition);
+        const afterCursor = this.inputText.substring(this.cursorPosition);
+        const newText = beforeCursor + text + afterCursor;
+        const newCursorPosition = this.cursorPosition + text.length;
+        this.inputText = newText;
+        this.cursorPosition = newCursorPosition;
+        this.callbacks.onInputTextChange?.(newText);
+        this.callbacks.onCursorPositionChange?.(newCursorPosition);
+        callback?.(newText, newCursorPosition);
+    }
+    deleteCharAtCursor(callback) {
+        if (this.cursorPosition > 0) {
+            const beforeCursor = this.inputText.substring(0, this.cursorPosition - 1);
+            const afterCursor = this.inputText.substring(this.cursorPosition);
+            const newText = beforeCursor + afterCursor;
+            const newCursorPosition = this.cursorPosition - 1;
+            this.inputText = newText;
+            this.cursorPosition = newCursorPosition;
+            this.callbacks.onInputTextChange?.(newText);
+            this.callbacks.onCursorPositionChange?.(newCursorPosition);
+            callback?.(newText, newCursorPosition);
+        }
+    }
+    clearInput() {
+        this.inputText = "";
+        this.cursorPosition = 0;
+        this.callbacks.onInputTextChange?.("");
+        this.callbacks.onCursorPositionChange?.(0);
+    }
+    moveCursorLeft() {
+        this.setCursorPosition(this.cursorPosition - 1);
+    }
+    moveCursorRight() {
+        this.setCursorPosition(this.cursorPosition + 1);
+    }
+    moveCursorToStart() {
+        this.setCursorPosition(0);
+    }
+    moveCursorToEnd() {
+        this.setCursorPosition(this.inputText.length);
+    }
+    // File selector methods
+    async searchFiles(query) {
+        try {
+            const fileItems = await searchFilesUtil(query);
+            this.filteredFiles = fileItems;
+            this.callbacks.onFileSelectorStateChange?.(this.showFileSelector, this.filteredFiles, this.fileSearchQuery, this.atPosition);
+        }
+        catch (error) {
+            console.error("File search error:", error);
+            this.filteredFiles = [];
+            this.callbacks.onFileSelectorStateChange?.(this.showFileSelector, [], this.fileSearchQuery, this.atPosition);
+        }
+    }
+    debouncedSearchFiles(query) {
+        if (this.fileSearchDebounceTimer) {
+            clearTimeout(this.fileSearchDebounceTimer);
+        }
+        const debounceDelay = parseInt(process.env.FILE_SELECTOR_DEBOUNCE_MS || "300", 10);
+        this.fileSearchDebounceTimer = setTimeout(() => {
+            this.searchFiles(query);
+        }, debounceDelay);
+    }
+    activateFileSelector(position) {
+        this.showFileSelector = true;
+        this.atPosition = position;
+        this.fileSearchQuery = "";
+        this.filteredFiles = [];
+        // Immediately trigger search to display initial file list
+        this.searchFiles("");
+        this.callbacks.onFileSelectorStateChange?.(true, this.filteredFiles, "", position);
+    }
+    updateFileSearchQuery(query) {
+        this.fileSearchQuery = query;
+        this.debouncedSearchFiles(query);
+    }
+    handleFileSelect(filePath) {
+        if (this.atPosition >= 0) {
+            const beforeAt = this.inputText.substring(0, this.atPosition);
+            const afterQuery = this.inputText.substring(this.cursorPosition);
+            const newInput = beforeAt + `${filePath} ` + afterQuery;
+            const newCursorPosition = beforeAt.length + filePath.length + 1;
+            this.inputText = newInput;
+            this.cursorPosition = newCursorPosition;
+            this.callbacks.onInputTextChange?.(newInput);
+            this.callbacks.onCursorPositionChange?.(newCursorPosition);
+            // Cancel file selector AFTER updating the input
+            this.handleCancelFileSelect();
+            // Set flag to prevent handleInput from processing the same Enter key
+            this.selectorJustUsed = true;
+            // Reset flag after a short delay
+            setTimeout(() => {
+                this.selectorJustUsed = false;
+            }, 0);
+            return { newInput, newCursorPosition };
+        }
+        return { newInput: this.inputText, newCursorPosition: this.cursorPosition };
+    }
+    handleCancelFileSelect() {
+        this.showFileSelector = false;
+        this.atPosition = -1;
+        this.fileSearchQuery = "";
+        this.filteredFiles = [];
+        this.callbacks.onFileSelectorStateChange?.(false, [], "", -1);
+    }
+    checkForAtDeletion(cursorPosition) {
+        if (this.showFileSelector && cursorPosition <= this.atPosition) {
+            this.handleCancelFileSelect();
+            return true;
+        }
+        return false;
+    }
+    // Command selector methods
+    activateCommandSelector(position) {
+        this.showCommandSelector = true;
+        this.slashPosition = position;
+        this.commandSearchQuery = "";
+        this.callbacks.onCommandSelectorStateChange?.(true, "", position);
+    }
+    updateCommandSearchQuery(query) {
+        this.commandSearchQuery = query;
+        this.callbacks.onCommandSelectorStateChange?.(this.showCommandSelector, query, this.slashPosition);
+    }
+    handleCommandSelect(command) {
+        if (this.slashPosition >= 0) {
+            // Replace command part, keep other content
+            const beforeSlash = this.inputText.substring(0, this.slashPosition);
+            const afterQuery = this.inputText.substring(this.cursorPosition);
+            const newInput = beforeSlash + afterQuery;
+            const newCursorPosition = beforeSlash.length;
+            this.inputText = newInput;
+            this.cursorPosition = newCursorPosition;
+            // Execute command asynchronously
+            (async () => {
+                // First check if it's an agent command
+                let commandExecuted = false;
+                if (this.callbacks.onSendMessage &&
+                    this.callbacks.onHasSlashCommand?.(command)) {
+                    // Execute complete command (replace partial input with complete command name)
+                    const fullCommand = `/${command}`;
+                    try {
+                        await this.callbacks.onSendMessage(fullCommand);
+                        commandExecuted = true;
+                    }
+                    catch (error) {
+                        console.error("Failed to execute slash command:", error);
+                    }
+                }
+                // If not an agent command or execution failed, check local commands
+                if (!commandExecuted) {
+                    if (command === "bashes" && this.callbacks.onShowBashManager) {
+                        this.callbacks.onShowBashManager();
+                        commandExecuted = true;
+                    }
+                    else if (command === "mcp" && this.callbacks.onShowMcpManager) {
+                        this.callbacks.onShowMcpManager();
+                        commandExecuted = true;
+                    }
+                }
+            })();
+            this.handleCancelCommandSelect();
+            // Set flag to prevent handleInput from processing the same Enter key
+            this.selectorJustUsed = true;
+            setTimeout(() => {
+                this.selectorJustUsed = false;
+            }, 0);
+            this.callbacks.onInputTextChange?.(newInput);
+            this.callbacks.onCursorPositionChange?.(newCursorPosition);
+            return { newInput, newCursorPosition };
+        }
+        return { newInput: this.inputText, newCursorPosition: this.cursorPosition };
+    }
+    handleCommandInsert(command) {
+        if (this.slashPosition >= 0) {
+            const beforeSlash = this.inputText.substring(0, this.slashPosition);
+            const afterQuery = this.inputText.substring(this.cursorPosition);
+            const newInput = beforeSlash + `/${command} ` + afterQuery;
+            const newCursorPosition = beforeSlash.length + command.length + 2;
+            this.inputText = newInput;
+            this.cursorPosition = newCursorPosition;
+            this.handleCancelCommandSelect();
+            // Set flag to prevent handleInput from processing the same Enter key
+            this.selectorJustUsed = true;
+            setTimeout(() => {
+                this.selectorJustUsed = false;
+            }, 0);
+            this.callbacks.onInputTextChange?.(newInput);
+            this.callbacks.onCursorPositionChange?.(newCursorPosition);
+            return { newInput, newCursorPosition };
+        }
+        return { newInput: this.inputText, newCursorPosition: this.cursorPosition };
+    }
+    handleCancelCommandSelect() {
+        this.showCommandSelector = false;
+        this.slashPosition = -1;
+        this.commandSearchQuery = "";
+        this.callbacks.onCommandSelectorStateChange?.(false, "", -1);
+    }
+    checkForSlashDeletion(cursorPosition) {
+        if (this.showCommandSelector && cursorPosition <= this.slashPosition) {
+            this.handleCancelCommandSelect();
+            return true;
+        }
+        return false;
+    }
+    // Bash history selector methods
+    activateBashHistorySelector(position) {
+        this.showBashHistorySelector = true;
+        this.exclamationPosition = position;
+        this.bashHistorySearchQuery = "";
+        this.callbacks.onBashHistorySelectorStateChange?.(true, "", position);
+    }
+    updateBashHistorySearchQuery(query) {
+        this.bashHistorySearchQuery = query;
+        this.callbacks.onBashHistorySelectorStateChange?.(this.showBashHistorySelector, query, this.exclamationPosition);
+    }
+    handleBashHistorySelect(command) {
+        if (this.exclamationPosition >= 0) {
+            const beforeExclamation = this.inputText.substring(0, this.exclamationPosition);
+            const afterQuery = this.inputText.substring(this.cursorPosition);
+            const newInput = beforeExclamation + `!${command}` + afterQuery;
+            const newCursorPosition = beforeExclamation.length + command.length + 1;
+            this.inputText = newInput;
+            this.cursorPosition = newCursorPosition;
+            this.handleCancelBashHistorySelect();
+            // Set flag to prevent handleInput from processing the same Enter key
+            this.selectorJustUsed = true;
+            setTimeout(() => {
+                this.selectorJustUsed = false;
+            }, 0);
+            this.callbacks.onInputTextChange?.(newInput);
+            this.callbacks.onCursorPositionChange?.(newCursorPosition);
+            return { newInput, newCursorPosition };
+        }
+        return { newInput: this.inputText, newCursorPosition: this.cursorPosition };
+    }
+    handleCancelBashHistorySelect() {
+        this.showBashHistorySelector = false;
+        this.exclamationPosition = -1;
+        this.bashHistorySearchQuery = "";
+        this.callbacks.onBashHistorySelectorStateChange?.(false, "", -1);
+    }
+    handleBashHistoryExecute(command) {
+        this.showBashHistorySelector = false;
+        this.exclamationPosition = -1;
+        this.bashHistorySearchQuery = "";
+        this.callbacks.onBashHistorySelectorStateChange?.(false, "", -1);
+        return command; // Return command to execute
+    }
+    checkForExclamationDeletion(cursorPosition) {
+        if (this.showBashHistorySelector &&
+            cursorPosition <= this.exclamationPosition) {
+            this.handleCancelBashHistorySelect();
+            return true;
+        }
+        return false;
+    }
+    // Memory type selector methods
+    activateMemoryTypeSelector(message) {
+        this.showMemoryTypeSelector = true;
+        this.memoryMessage = message;
+        this.callbacks.onMemoryTypeSelectorStateChange?.(true, message);
+    }
+    handleMemoryTypeSelect(type) {
+        // Note: type parameter will be used in future for different handling logic
+        console.debug(`Memory type selected: ${type}`);
+        this.showMemoryTypeSelector = false;
+        this.memoryMessage = "";
+        this.callbacks.onMemoryTypeSelectorStateChange?.(false, "");
+    }
+    handleCancelMemoryTypeSelect() {
+        this.showMemoryTypeSelector = false;
+        this.memoryMessage = "";
+        this.callbacks.onMemoryTypeSelectorStateChange?.(false, "");
+    }
+    // Input history methods
+    setUserInputHistory(history) {
+        this.userInputHistory = history;
+    }
+    navigateHistory(direction, currentInput) {
+        if (this.historyIndex === -1) {
+            this.historyBuffer = currentInput;
+        }
+        if (direction === "up") {
+            if (this.historyIndex < this.userInputHistory.length - 1) {
+                this.historyIndex++;
+            }
+        }
+        else {
+            // Down direction
+            if (this.historyIndex > 0) {
+                this.historyIndex--;
+            }
+            else if (this.historyIndex === 0) {
+                // Go from first history item to draft
+                this.historyIndex = -1;
+            }
+            else if (this.historyIndex === -1) {
+                // Go from draft to empty (beyond history bottom)
+                this.historyIndex = -2;
+            }
+        }
+        let newInput;
+        if (this.historyIndex === -1) {
+            newInput = this.historyBuffer;
+        }
+        else if (this.historyIndex === -2) {
+            // Beyond history bottom, clear input
+            newInput = "";
+        }
+        else {
+            const historyItem = this.userInputHistory[this.userInputHistory.length - 1 - this.historyIndex];
+            newInput = historyItem || "";
+        }
+        const newCursorPosition = newInput.length;
+        this.inputText = newInput;
+        this.cursorPosition = newCursorPosition;
+        this.callbacks.onInputTextChange?.(newInput);
+        this.callbacks.onCursorPositionChange?.(newCursorPosition);
+        return { newInput, newCursorPosition };
+    }
+    resetHistoryNavigation() {
+        this.historyIndex = -1;
+        this.historyBuffer = "";
+    }
+    // Getter methods for state
+    isFileSelectorActive() {
+        return this.showFileSelector;
+    }
+    isCommandSelectorActive() {
+        return this.showCommandSelector;
+    }
+    isBashHistorySelectorActive() {
+        return this.showBashHistorySelector;
+    }
+    isMemoryTypeSelectorActive() {
+        return this.showMemoryTypeSelector;
+    }
+    getFileSelectorState() {
+        return {
+            show: this.showFileSelector,
+            files: this.filteredFiles,
+            query: this.fileSearchQuery,
+            position: this.atPosition,
+        };
+    }
+    getCommandSelectorState() {
+        return {
+            show: this.showCommandSelector,
+            query: this.commandSearchQuery,
+            position: this.slashPosition,
+        };
+    }
+    getBashHistorySelectorState() {
+        return {
+            show: this.showBashHistorySelector,
+            query: this.bashHistorySearchQuery,
+            position: this.exclamationPosition,
+        };
+    }
+    getMemoryTypeSelectorState() {
+        return {
+            show: this.showMemoryTypeSelector,
+            message: this.memoryMessage,
+        };
+    }
+    // Handle special character input that might trigger selectors
+    handleSpecialCharInput(char) {
+        if (char === "@") {
+            this.activateFileSelector(this.cursorPosition - 1);
+        }
+        else if (char === "/" && !this.showFileSelector) {
+            // Don't activate command selector when file selector is active
+            this.activateCommandSelector(this.cursorPosition - 1);
+        }
+        else if (char === "!" && this.cursorPosition === 1) {
+            this.activateBashHistorySelector(0);
+        }
+        else if (char === "#" && this.cursorPosition === 1) {
+            // Memory message detection will be handled in submit
+        }
+        else {
+            // Update search queries for active selectors
+            if (this.showFileSelector && this.atPosition >= 0) {
+                const queryStart = this.atPosition + 1;
+                const queryEnd = this.cursorPosition;
+                const newQuery = this.inputText.substring(queryStart, queryEnd);
+                this.updateFileSearchQuery(newQuery);
+            }
+            else if (this.showCommandSelector && this.slashPosition >= 0) {
+                const queryStart = this.slashPosition + 1;
+                const queryEnd = this.cursorPosition;
+                const newQuery = this.inputText.substring(queryStart, queryEnd);
+                this.updateCommandSearchQuery(newQuery);
+            }
+            else if (this.showBashHistorySelector &&
+                this.exclamationPosition >= 0) {
+                const queryStart = this.exclamationPosition + 1;
+                const queryEnd = this.cursorPosition;
+                const newQuery = this.inputText.substring(queryStart, queryEnd);
+                this.updateBashHistorySearchQuery(newQuery);
+            }
+        }
+    }
+    // Long text compression methods
+    generateCompressedText(originalText) {
+        this.longTextCounter += 1;
+        const compressedLabel = `[LongText#${this.longTextCounter}]`;
+        this.longTextMap.set(compressedLabel, originalText);
+        return compressedLabel;
+    }
+    expandLongTextPlaceholders(text) {
+        let expandedText = text;
+        const longTextRegex = /\[LongText#(\d+)\]/g;
+        const matches = [...text.matchAll(longTextRegex)];
+        for (const match of matches) {
+            const placeholder = match[0];
+            const originalText = this.longTextMap.get(placeholder);
+            if (originalText) {
+                expandedText = expandedText.replace(placeholder, originalText);
+            }
+        }
+        return expandedText;
+    }
+    clearLongTextMap() {
+        this.longTextMap.clear();
+    }
+    // Paste handling methods
+    handlePasteInput(input) {
+        const inputString = input;
+        // Detect if it's a paste operation (input contains multiple characters or newlines)
+        const isPasteOperation = inputString.length > 1 ||
+            inputString.includes("\n") ||
+            inputString.includes("\r");
+        if (isPasteOperation) {
+            // Start or continue the debounce handling for paste operation
+            if (!this.isPasting) {
+                // Start new paste operation
+                this.isPasting = true;
+                this.pasteBuffer = inputString;
+                this.initialPasteCursorPosition = this.cursorPosition;
+            }
+            else {
+                // Continue paste operation, add new input to buffer
+                this.pasteBuffer += inputString;
+            }
+            // Clear previous timer
+            if (this.pasteDebounceTimer) {
+                clearTimeout(this.pasteDebounceTimer);
+            }
+            // Set new timer, support environment variable configuration
+            const pasteDebounceDelay = parseInt(process.env.PASTE_DEBOUNCE_MS || "30", 10);
+            this.pasteDebounceTimer = setTimeout(() => {
+                // Process all paste content in buffer
+                let processedInput = this.pasteBuffer.replace(/\r/g, "\n");
+                // Check if long text compression is needed (over 200 characters)
+                if (processedInput.length > 200) {
+                    const originalText = processedInput;
+                    const compressedLabel = this.generateCompressedText(originalText);
+                    processedInput = compressedLabel;
+                }
+                this.insertTextAtCursor(processedInput);
+                this.callbacks.onResetHistoryNavigation?.();
+                // Reset paste state
+                this.isPasting = false;
+                this.pasteBuffer = "";
+                this.pasteDebounceTimer = null;
+            }, pasteDebounceDelay);
+        }
+        else {
+            // Handle single character input
+            let char = inputString;
+            // Check if it's Chinese exclamation mark, convert to English if at beginning
+            if (char === "！" && this.cursorPosition === 0) {
+                char = "!";
+            }
+            this.callbacks.onResetHistoryNavigation?.();
+            this.insertTextAtCursor(char, () => {
+                // Handle special character input - this will manage all selectors
+                this.handleSpecialCharInput(char);
+            });
+        }
+    }
+    // Image management methods
+    addImage(imagePath, mimeType) {
+        const newImage = {
+            id: this.imageIdCounter,
+            path: imagePath,
+            mimeType,
+        };
+        this.attachedImages = [...this.attachedImages, newImage];
+        this.imageIdCounter++;
+        this.callbacks.onImagesStateChange?.(this.attachedImages);
+        return newImage;
+    }
+    removeImage(imageId) {
+        this.attachedImages = this.attachedImages.filter((img) => img.id !== imageId);
+        this.callbacks.onImagesStateChange?.(this.attachedImages);
+    }
+    clearImages() {
+        this.attachedImages = [];
+        this.callbacks.onImagesStateChange?.(this.attachedImages);
+    }
+    getAttachedImages() {
+        return this.attachedImages;
+    }
+    async handlePasteImage() {
+        try {
+            const result = await readClipboardImage();
+            if (result.success && result.imagePath && result.mimeType) {
+                // Add image to manager
+                const attachedImage = this.addImage(result.imagePath, result.mimeType);
+                // Insert image placeholder at cursor position
+                this.insertTextAtCursor(`[Image #${attachedImage.id}]`);
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            console.warn("Failed to paste image from clipboard:", error);
+            return false;
+        }
+    }
+    // Bash/MCP manager state methods
+    getShowBashManager() {
+        return this.showBashManager;
+    }
+    setShowBashManager(show) {
+        this.showBashManager = show;
+        this.callbacks.onBashManagerStateChange?.(show);
+    }
+    getShowMcpManager() {
+        return this.showMcpManager;
+    }
+    setShowMcpManager(show) {
+        this.showMcpManager = show;
+        this.callbacks.onMcpManagerStateChange?.(show);
+    }
+    // Handle submit logic
+    async handleSubmit(attachedImages, isLoading = false, isCommandRunning = false) {
+        // Prevent submission during loading or command execution
+        if (isLoading || isCommandRunning) {
+            return;
+        }
+        if (this.inputText.trim()) {
+            const trimmedInput = this.inputText.trim();
+            // Check if it's a memory message (starts with # and only one line)
+            if (trimmedInput.startsWith("#") && !trimmedInput.includes("\n")) {
+                // Activate memory type selector
+                this.activateMemoryTypeSelector(trimmedInput);
+                return;
+            }
+            // Extract image information
+            const imageRegex = /\[Image #(\d+)\]/g;
+            const matches = [...this.inputText.matchAll(imageRegex)];
+            const referencedImages = matches
+                .map((match) => {
+                const imageId = parseInt(match[1], 10);
+                return attachedImages.find((img) => img.id === imageId);
+            })
+                .filter((img) => img !== undefined)
+                .map((img) => ({ path: img.path, mimeType: img.mimeType }));
+            // Remove image placeholders, expand long text placeholders, send message
+            let cleanContent = this.inputText.replace(imageRegex, "").trim();
+            cleanContent = this.expandLongTextPlaceholders(cleanContent);
+            this.callbacks.onSendMessage?.(cleanContent, referencedImages.length > 0 ? referencedImages : undefined);
+            this.clearInput();
+            this.callbacks.onResetHistoryNavigation?.();
+            // Clear long text mapping
+            this.clearLongTextMap();
+        }
+    }
+    // Handle selector input (when any selector is active)
+    handleSelectorInput(input, key) {
+        if (key.backspace || key.delete) {
+            if (this.cursorPosition > 0) {
+                this.deleteCharAtCursor((newInput, newCursorPosition) => {
+                    // Check for special character deletion
+                    this.checkForAtDeletion(newCursorPosition);
+                    this.checkForSlashDeletion(newCursorPosition);
+                    this.checkForExclamationDeletion(newCursorPosition);
+                });
+            }
+            return true;
+        }
+        // Arrow keys and Enter should be handled by selector components
+        if (key.upArrow || key.downArrow || key.return) {
+            // Let selector component handle these keys, but prevent further processing
+            // by returning true (indicating we've handled the input)
+            return true;
+        }
+        if (input &&
+            !key.ctrl &&
+            !("alt" in key && key.alt) &&
+            !key.meta &&
+            !key.return &&
+            !key.escape &&
+            !key.leftArrow &&
+            !key.rightArrow &&
+            !("home" in key && key.home) &&
+            !("end" in key && key.end)) {
+            // Handle character input for search
+            this.insertTextAtCursor(input, () => {
+                // Special character handling is now managed by InputManager
+                this.handleSpecialCharInput(input);
+            });
+            return true;
+        }
+        return false;
+    }
+    // Handle normal input (when no selector is active)
+    async handleNormalInput(input, key, attachedImages, isLoading = false, isCommandRunning = false, clearImages) {
+        if (key.return) {
+            await this.handleSubmit(attachedImages, isLoading, isCommandRunning);
+            clearImages?.();
+            return true;
+        }
+        if (key.escape) {
+            if (this.showFileSelector) {
+                this.handleCancelFileSelect();
+            }
+            else if (this.showCommandSelector) {
+                this.handleCancelCommandSelect();
+            }
+            else if (this.showBashHistorySelector) {
+                this.handleCancelBashHistorySelect();
+            }
+            return true;
+        }
+        if (key.backspace || key.delete) {
+            if (this.cursorPosition > 0) {
+                this.deleteCharAtCursor();
+                this.callbacks.onResetHistoryNavigation?.();
+                // Check if we deleted any special characters
+                const newCursorPosition = this.cursorPosition - 1;
+                this.checkForAtDeletion(newCursorPosition);
+                this.checkForSlashDeletion(newCursorPosition);
+                this.checkForExclamationDeletion(newCursorPosition);
+            }
+            return true;
+        }
+        if (key.leftArrow) {
+            this.moveCursorLeft();
+            return true;
+        }
+        if (key.rightArrow) {
+            this.moveCursorRight();
+            return true;
+        }
+        if (("home" in key && key.home) || (key.ctrl && input === "a")) {
+            this.moveCursorToStart();
+            return true;
+        }
+        if (("end" in key && key.end) || (key.ctrl && input === "e")) {
+            this.moveCursorToEnd();
+            return true;
+        }
+        // Handle Ctrl+V for pasting images
+        if (key.ctrl && input === "v") {
+            this.handlePasteImage().catch((error) => {
+                console.warn("Failed to handle paste image:", error);
+            });
+            return true;
+        }
+        // Handle up/down keys for history navigation (only when no selector is active)
+        if (key.upArrow &&
+            !this.showFileSelector &&
+            !this.showCommandSelector &&
+            !this.showBashHistorySelector) {
+            this.navigateHistory("up", this.inputText);
+            return true;
+        }
+        if (key.downArrow &&
+            !this.showFileSelector &&
+            !this.showCommandSelector &&
+            !this.showBashHistorySelector) {
+            this.navigateHistory("down", this.inputText);
+            return true;
+        }
+        // Handle typing input
+        if (input &&
+            !key.ctrl &&
+            !("alt" in key && key.alt) &&
+            !key.meta &&
+            !key.return &&
+            !key.escape &&
+            !key.backspace &&
+            !key.delete &&
+            !key.leftArrow &&
+            !key.rightArrow &&
+            !("home" in key && key.home) &&
+            !("end" in key && key.end)) {
+            this.handlePasteInput(input);
+            return true;
+        }
+        return false;
+    }
+    // Main input handler - routes to appropriate handler based on state
+    async handleInput(input, key, attachedImages, isLoading = false, isCommandRunning = false, clearImages) {
+        // If selector was just used, ignore this input to prevent conflicts
+        if (this.selectorJustUsed) {
+            return true;
+        }
+        // Handle interrupt request - use Esc key to interrupt AI request or command
+        if (key.escape && (isLoading || isCommandRunning)) {
+            // Unified interrupt for AI message generation and command execution
+            this.callbacks.onAbortMessage?.();
+            return true;
+        }
+        // Check if any selector is active
+        if (this.showFileSelector ||
+            this.showCommandSelector ||
+            this.showBashHistorySelector ||
+            this.showMemoryTypeSelector ||
+            this.showBashManager ||
+            this.showMcpManager) {
+            if (this.showMemoryTypeSelector ||
+                this.showBashManager ||
+                this.showMcpManager) {
+                // Memory type selector, bash manager and MCP manager don't need to handle input, handled by component itself
+                return false;
+            }
+            return this.handleSelectorInput(input, key);
+        }
+        else {
+            return await this.handleNormalInput(input, key, attachedImages, isLoading, isCommandRunning, clearImages);
+        }
+    }
+    // Cleanup method
+    destroy() {
+        if (this.fileSearchDebounceTimer) {
+            clearTimeout(this.fileSearchDebounceTimer);
+            this.fileSearchDebounceTimer = null;
+        }
+        if (this.pasteDebounceTimer) {
+            clearTimeout(this.pasteDebounceTimer);
+            this.pasteDebounceTimer = null;
+        }
+    }
+}