wave-code 0.0.4 → 0.0.5

package/src/managers/InputManager.ts

@@ -0,0 +1,1102 @@
+import { FileItem } from "../components/FileSelector.js";
+import { searchFiles as searchFilesUtil } from "../utils/fileSearch.js";
+import { readClipboardImage } from "../utils/clipboard.js";
+import type { Key } from "ink";
+
+export interface AttachedImage {
+  id: number;
+  path: string;
+  mimeType: string;
+}
+
+export interface InputManagerCallbacks {
+  onInputTextChange?: (text: string) => void;
+  onCursorPositionChange?: (position: number) => void;
+  onFileSelectorStateChange?: (
+    show: boolean,
+    files: FileItem[],
+    query: string,
+    position: number,
+  ) => void;
+  onCommandSelectorStateChange?: (
+    show: boolean,
+    query: string,
+    position: number,
+  ) => void;
+  onBashHistorySelectorStateChange?: (
+    show: boolean,
+    query: string,
+    position: number,
+  ) => void;
+  onMemoryTypeSelectorStateChange?: (show: boolean, message: string) => void;
+  onShowBashManager?: () => void;
+  onShowMcpManager?: () => void;
+  onBashManagerStateChange?: (show: boolean) => void;
+  onMcpManagerStateChange?: (show: boolean) => void;
+  onImagesStateChange?: (images: AttachedImage[]) => void;
+  onSendMessage?: (
+    content: string,
+    images?: Array<{ path: string; mimeType: string }>,
+  ) => void | Promise<void>;
+  onHasSlashCommand?: (commandId: string) => boolean;
+  onSaveMemory?: (message: string, type: "project" | "user") => Promise<void>;
+  onAbortMessage?: () => void;
+  onResetHistoryNavigation?: () => void;
+}
+
+export class InputManager {
+  // Core input state
+  private inputText: string = "";
+  private cursorPosition: number = 0;
+
+  // File selector state
+  private showFileSelector: boolean = false;
+  private atPosition: number = -1;
+  private fileSearchQuery: string = "";
+  private filteredFiles: FileItem[] = [];
+  private fileSearchDebounceTimer: NodeJS.Timeout | null = null;
+
+  // Command selector state
+  private showCommandSelector: boolean = false;
+  private slashPosition: number = -1;
+  private commandSearchQuery: string = "";
+
+  // Bash history selector state
+  private showBashHistorySelector: boolean = false;
+  private exclamationPosition: number = -1;
+  private bashHistorySearchQuery: string = "";
+
+  // Memory type selector state
+  private showMemoryTypeSelector: boolean = false;
+  private memoryMessage: string = "";
+
+  // Input history state
+  private userInputHistory: string[] = [];
+  private historyIndex: number = -1;
+  private historyBuffer: string = "";
+
+  // Paste debounce state
+  private pasteDebounceTimer: NodeJS.Timeout | null = null;
+  private pasteBuffer: string = "";
+  private initialPasteCursorPosition: number = 0;
+  private isPasting: boolean = false;
+
+  // Long text compression state
+  private longTextCounter: number = 0;
+  private longTextMap: Map<string, string> = new Map();
+
+  // Image management state
+  private attachedImages: AttachedImage[] = [];
+  private imageIdCounter: number = 1;
+
+  // Additional UI state
+  private showBashManager: boolean = false;
+  private showMcpManager: boolean = false;
+
+  // Flag to prevent handleInput conflicts when selector selection occurs
+  private selectorJustUsed: boolean = false;
+
+  private callbacks: InputManagerCallbacks;
+
+  constructor(callbacks: InputManagerCallbacks = {}) {
+    this.callbacks = callbacks;
+  }
+
+  // Update callbacks
+  updateCallbacks(callbacks: Partial<InputManagerCallbacks>) {
+    this.callbacks = { ...this.callbacks, ...callbacks };
+  }
+
+  // Core input methods
+  getInputText(): string {
+    return this.inputText;
+  }
+
+  setInputText(text: string): void {
+    this.inputText = text;
+    this.callbacks.onInputTextChange?.(text);
+  }
+
+  getCursorPosition(): number {
+    return this.cursorPosition;
+  }
+
+  setCursorPosition(position: number): void {
+    this.cursorPosition = Math.max(
+      0,
+      Math.min(this.inputText.length, position),
+    );
+    this.callbacks.onCursorPositionChange?.(this.cursorPosition);
+  }
+
+  insertTextAtCursor(
+    text: string,
+    callback?: (newText: string, newCursorPosition: number) => void,
+  ): void {
+    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?: (newText: string, newCursorPosition: number) => void,
+  ): void {
+    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(): void {
+    this.inputText = "";
+    this.cursorPosition = 0;
+    this.callbacks.onInputTextChange?.("");
+    this.callbacks.onCursorPositionChange?.(0);
+  }
+
+  moveCursorLeft(): void {
+    this.setCursorPosition(this.cursorPosition - 1);
+  }
+
+  moveCursorRight(): void {
+    this.setCursorPosition(this.cursorPosition + 1);
+  }
+
+  moveCursorToStart(): void {
+    this.setCursorPosition(0);
+  }
+
+  moveCursorToEnd(): void {
+    this.setCursorPosition(this.inputText.length);
+  }
+
+  // File selector methods
+  private async searchFiles(query: string): Promise<void> {
+    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,
+      );
+    }
+  }
+
+  private debouncedSearchFiles(query: string): void {
+    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: number): void {
+    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: string): void {
+    this.fileSearchQuery = query;
+    this.debouncedSearchFiles(query);
+  }
+
+  handleFileSelect(filePath: string): {
+    newInput: string;
+    newCursorPosition: number;
+  } {
+    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(): void {
+    this.showFileSelector = false;
+    this.atPosition = -1;
+    this.fileSearchQuery = "";
+    this.filteredFiles = [];
+
+    this.callbacks.onFileSelectorStateChange?.(false, [], "", -1);
+  }
+
+  checkForAtDeletion(cursorPosition: number): boolean {
+    if (this.showFileSelector && cursorPosition <= this.atPosition) {
+      this.handleCancelFileSelect();
+      return true;
+    }
+    return false;
+  }
+
+  // Command selector methods
+  activateCommandSelector(position: number): void {
+    this.showCommandSelector = true;
+    this.slashPosition = position;
+    this.commandSearchQuery = "";
+
+    this.callbacks.onCommandSelectorStateChange?.(true, "", position);
+  }
+
+  updateCommandSearchQuery(query: string): void {
+    this.commandSearchQuery = query;
+    this.callbacks.onCommandSelectorStateChange?.(
+      this.showCommandSelector,
+      query,
+      this.slashPosition,
+    );
+  }
+
+  handleCommandSelect(command: string): {
+    newInput: string;
+    newCursorPosition: number;
+  } {
+    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: string): {
+    newInput: string;
+    newCursorPosition: number;
+  } {
+    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(): void {
+    this.showCommandSelector = false;
+    this.slashPosition = -1;
+    this.commandSearchQuery = "";
+
+    this.callbacks.onCommandSelectorStateChange?.(false, "", -1);
+  }
+
+  checkForSlashDeletion(cursorPosition: number): boolean {
+    if (this.showCommandSelector && cursorPosition <= this.slashPosition) {
+      this.handleCancelCommandSelect();
+      return true;
+    }
+    return false;
+  }
+
+  // Bash history selector methods
+  activateBashHistorySelector(position: number): void {
+    this.showBashHistorySelector = true;
+    this.exclamationPosition = position;
+    this.bashHistorySearchQuery = "";
+
+    this.callbacks.onBashHistorySelectorStateChange?.(true, "", position);
+  }
+
+  updateBashHistorySearchQuery(query: string): void {
+    this.bashHistorySearchQuery = query;
+    this.callbacks.onBashHistorySelectorStateChange?.(
+      this.showBashHistorySelector,
+      query,
+      this.exclamationPosition,
+    );
+  }
+
+  handleBashHistorySelect(command: string): {
+    newInput: string;
+    newCursorPosition: number;
+  } {
+    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(): void {
+    this.showBashHistorySelector = false;
+    this.exclamationPosition = -1;
+    this.bashHistorySearchQuery = "";
+
+    this.callbacks.onBashHistorySelectorStateChange?.(false, "", -1);
+  }
+
+  handleBashHistoryExecute(command: string): string {
+    this.showBashHistorySelector = false;
+    this.exclamationPosition = -1;
+    this.bashHistorySearchQuery = "";
+
+    this.callbacks.onBashHistorySelectorStateChange?.(false, "", -1);
+
+    return command; // Return command to execute
+  }
+
+  checkForExclamationDeletion(cursorPosition: number): boolean {
+    if (
+      this.showBashHistorySelector &&
+      cursorPosition <= this.exclamationPosition
+    ) {
+      this.handleCancelBashHistorySelect();
+      return true;
+    }
+    return false;
+  }
+
+  // Memory type selector methods
+  activateMemoryTypeSelector(message: string): void {
+    this.showMemoryTypeSelector = true;
+    this.memoryMessage = message;
+
+    this.callbacks.onMemoryTypeSelectorStateChange?.(true, message);
+  }
+
+  handleMemoryTypeSelect(type: "project" | "user"): void {
+    // 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(): void {
+    this.showMemoryTypeSelector = false;
+    this.memoryMessage = "";
+
+    this.callbacks.onMemoryTypeSelectorStateChange?.(false, "");
+  }
+
+  // Input history methods
+  setUserInputHistory(history: string[]): void {
+    this.userInputHistory = history;
+  }
+
+  navigateHistory(
+    direction: "up" | "down",
+    currentInput: string,
+  ): { newInput: string; newCursorPosition: number } {
+    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: string;
+    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(): void {
+    this.historyIndex = -1;
+    this.historyBuffer = "";
+  }
+
+  // Getter methods for state
+  isFileSelectorActive(): boolean {
+    return this.showFileSelector;
+  }
+
+  isCommandSelectorActive(): boolean {
+    return this.showCommandSelector;
+  }
+
+  isBashHistorySelectorActive(): boolean {
+    return this.showBashHistorySelector;
+  }
+
+  isMemoryTypeSelectorActive(): boolean {
+    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: string): void {
+    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: string): string {
+    this.longTextCounter += 1;
+    const compressedLabel = `[LongText#${this.longTextCounter}]`;
+    this.longTextMap.set(compressedLabel, originalText);
+    return compressedLabel;
+  }
+
+  expandLongTextPlaceholders(text: string): string {
+    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(): void {
+    this.longTextMap.clear();
+  }
+
+  // Paste handling methods
+  handlePasteInput(input: string): void {
+    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: string, mimeType: string): AttachedImage {
+    const newImage: AttachedImage = {
+      id: this.imageIdCounter,
+      path: imagePath,
+      mimeType,
+    };
+    this.attachedImages = [...this.attachedImages, newImage];
+    this.imageIdCounter++;
+    this.callbacks.onImagesStateChange?.(this.attachedImages);
+    return newImage;
+  }
+
+  removeImage(imageId: number): void {
+    this.attachedImages = this.attachedImages.filter(
+      (img) => img.id !== imageId,
+    );
+    this.callbacks.onImagesStateChange?.(this.attachedImages);
+  }
+
+  clearImages(): void {
+    this.attachedImages = [];
+    this.callbacks.onImagesStateChange?.(this.attachedImages);
+  }
+
+  getAttachedImages(): AttachedImage[] {
+    return this.attachedImages;
+  }
+
+  async handlePasteImage(): Promise<boolean> {
+    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(): boolean {
+    return this.showBashManager;
+  }
+
+  setShowBashManager(show: boolean): void {
+    this.showBashManager = show;
+    this.callbacks.onBashManagerStateChange?.(show);
+  }
+
+  getShowMcpManager(): boolean {
+    return this.showMcpManager;
+  }
+
+  setShowMcpManager(show: boolean): void {
+    this.showMcpManager = show;
+    this.callbacks.onMcpManagerStateChange?.(show);
+  }
+
+  // Handle submit logic
+  async handleSubmit(
+    attachedImages: Array<{ id: number; path: string; mimeType: string }>,
+    isLoading: boolean = false,
+    isCommandRunning: boolean = false,
+  ): Promise<void> {
+    // 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 is { id: number; path: string; mimeType: string } =>
+            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: string, key: Key): boolean {
+    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: string,
+    key: Key,
+    attachedImages: Array<{ id: number; path: string; mimeType: string }>,
+    isLoading: boolean = false,
+    isCommandRunning: boolean = false,
+    clearImages?: () => void,
+  ): Promise<boolean> {
+    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: string,
+    key: Key,
+    attachedImages: Array<{ id: number; path: string; mimeType: string }>,
+    isLoading: boolean = false,
+    isCommandRunning: boolean = false,
+    clearImages?: () => void,
+  ): Promise<boolean> {
+    // 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(): void {
+    if (this.fileSearchDebounceTimer) {
+      clearTimeout(this.fileSearchDebounceTimer);
+      this.fileSearchDebounceTimer = null;
+    }
+    if (this.pasteDebounceTimer) {
+      clearTimeout(this.pasteDebounceTimer);
+      this.pasteDebounceTimer = null;
+    }
+  }
+}