wave-code 0.14.3 → 0.15.0

package/src/hooks/useInputManager.ts

@@ -1,4 +1,4 @@
-import { useEffect, useReducer, useCallback, useRef } from "react";
+import { useEffect, useReducer, useCallback } from "react";
 import { Key } from "ink";
 import {
   inputReducer,
@@ -9,6 +9,7 @@ import {
   searchFiles as searchFilesUtil,
   PermissionMode,
   PromptEntry,
+  PromptHistoryManager,
 } from "wave-agent-sdk";
 import * as handlers from "../managers/inputHandlers.js";
 
@@ -16,17 +17,32 @@ export const useInputManager = (
   callbacks: Partial<InputManagerCallbacks> = {},
 ) => {
   const [state, dispatch] = useReducer(inputReducer, initialState);
-  const callbacksRef = useRef(callbacks);
-  const stateRef = useRef(state);
 
-  // Update refs when they change
-  useEffect(() => {
-    callbacksRef.current = callbacks;
-  }, [callbacks]);
-
-  useEffect(() => {
-    stateRef.current = state;
-  }, [state]);
+  const {
+    onInputTextChange,
+    onCursorPositionChange,
+    onFileSelectorStateChange,
+    onCommandSelectorStateChange,
+    onHistorySearchStateChange,
+    onBackgroundTaskManagerStateChange,
+    onMcpManagerStateChange,
+    onRewindManagerStateChange,
+    onHelpStateChange,
+    onStatusCommandStateChange,
+    onPluginManagerStateChange,
+    onModelSelectorStateChange,
+    onImagesStateChange,
+    onSendMessage,
+    onHasSlashCommand,
+    onAbortMessage,
+    onBackgroundCurrentTask,
+    onPermissionModeChange,
+    onAskBtw,
+    sessionId,
+    workdir,
+    getFullMessageThread,
+    logger,
+  } = callbacks;
 
   // Handle selectorJustUsed reset
   useEffect(() => {
@@ -66,10 +82,7 @@ export const useInputManager = (
         10,
       );
       const timer = setTimeout(() => {
-        const processedInput = stateRef.current.pasteBuffer.replace(
-          /\r/g,
-          "\n",
-        );
+        const processedInput = state.pasteBuffer.replace(/\r/g, "\n");
         dispatch({
           type: "INSERT_TEXT_WITH_PLACEHOLDER",
           payload: processedInput,
@@ -83,15 +96,156 @@ export const useInputManager = (
 
   // Sync state changes with callbacks
   useEffect(() => {
-    callbacksRef.current.onInputTextChange?.(state.inputText);
-  }, [state.inputText]);
+    onInputTextChange?.(state.inputText);
+  }, [state.inputText, onInputTextChange]);
 
   useEffect(() => {
-    callbacksRef.current.onCursorPositionChange?.(state.cursorPosition);
-  }, [state.cursorPosition]);
+    onCursorPositionChange?.(state.cursorPosition);
+  }, [state.cursorPosition, onCursorPositionChange]);
 
+  // Handle pending effects
   useEffect(() => {
-    callbacksRef.current.onFileSelectorStateChange?.(
+    if (!state.pendingEffect) return;
+
+    const effect = state.pendingEffect;
+    dispatch({ type: "CLEAR_PENDING_EFFECT" });
+
+    const runEffect = async () => {
+      try {
+        switch (effect.type) {
+          case "SEND_MESSAGE":
+            await onSendMessage?.(
+              effect.content,
+              effect.images,
+              effect.longTextMap,
+            );
+            break;
+          case "ABORT_MESSAGE":
+            onAbortMessage?.();
+            break;
+          case "BACKGROUND_CURRENT_TASK":
+            onBackgroundCurrentTask?.();
+            break;
+          case "ASK_BTW":
+            try {
+              const answer = await onAskBtw?.(effect.question);
+              dispatch({
+                type: "SET_BTW_STATE",
+                payload: { answer, isLoading: false },
+              });
+            } catch (error) {
+              console.error("Failed to ask side question:", error);
+              dispatch({
+                type: "SET_BTW_STATE",
+                payload: {
+                  answer:
+                    "Error: Failed to get an answer for your side question.",
+                  isLoading: false,
+                },
+              });
+            }
+            break;
+          case "PERMISSION_MODE_CHANGE":
+            onPermissionModeChange?.(effect.mode);
+            break;
+          case "SAVE_HISTORY":
+            PromptHistoryManager.addEntry(
+              effect.content,
+              sessionId,
+              effect.longTextMap,
+              workdir,
+            ).catch((err: unknown) => {
+              logger?.error("Failed to save prompt history", err);
+            });
+            break;
+          case "FETCH_HISTORY": {
+            let sessionIds: string[] | undefined = sessionId
+              ? [sessionId]
+              : undefined;
+
+            if (getFullMessageThread) {
+              try {
+                const thread = await getFullMessageThread();
+                sessionIds = thread.sessionIds;
+              } catch (error) {
+                logger?.error("Failed to fetch ancestor session IDs", error);
+              }
+            }
+
+            const history = await PromptHistoryManager.getHistory({
+              sessionId: sessionIds,
+              workdir: workdir,
+            });
+            dispatch({ type: "SET_HISTORY_ENTRIES", payload: history });
+            dispatch({ type: "NAVIGATE_HISTORY", payload: "up" });
+            break;
+          }
+          case "PASTE_IMAGE":
+            try {
+              await handlers.handlePasteImage(dispatch);
+            } catch (error) {
+              console.warn("Failed to handle paste image:", error);
+            }
+            break;
+          case "EXECUTE_COMMAND":
+            if (onSendMessage && onHasSlashCommand?.(effect.command)) {
+              const fullCommand = `/${effect.command}`;
+              try {
+                await onSendMessage(fullCommand, undefined, {});
+              } catch (error) {
+                console.error("Failed to execute slash command:", error);
+              }
+            } else {
+              // Internal command handling
+              const command = effect.command;
+              if (command === "tasks") {
+                dispatch({
+                  type: "SET_SHOW_BACKGROUND_TASK_MANAGER",
+                  payload: true,
+                });
+              } else if (command === "mcp") {
+                dispatch({ type: "SET_SHOW_MCP_MANAGER", payload: true });
+              } else if (command === "rewind") {
+                dispatch({ type: "SET_SHOW_REWIND_MANAGER", payload: true });
+              } else if (command === "help") {
+                dispatch({ type: "SET_SHOW_HELP", payload: true });
+              } else if (command === "status") {
+                dispatch({ type: "SET_SHOW_STATUS_COMMAND", payload: true });
+              } else if (command === "plugin") {
+                dispatch({ type: "SET_SHOW_PLUGIN_MANAGER", payload: true });
+              } else if (command === "model") {
+                dispatch({ type: "SET_SHOW_MODEL_SELECTOR", payload: true });
+              } else if (command === "btw") {
+                dispatch({
+                  type: "SET_BTW_STATE",
+                  payload: { isActive: true, question: "", isLoading: false },
+                });
+              }
+            }
+            break;
+        }
+      } catch (error) {
+        console.error("Effect execution error:", error);
+      }
+    };
+
+    runEffect();
+  }, [
+    state.pendingEffect,
+    onSendMessage,
+    onAbortMessage,
+    onBackgroundCurrentTask,
+    onAskBtw,
+    onPermissionModeChange,
+    sessionId,
+    workdir,
+    getFullMessageThread,
+    logger,
+    onHasSlashCommand,
+  ]);
+
+  useEffect(() => {
+    onFileSelectorStateChange?.(
       state.showFileSelector,
       state.filteredFiles,
       state.fileSearchQuery,
@@ -102,10 +256,11 @@ export const useInputManager = (
     state.filteredFiles,
     state.fileSearchQuery,
     state.atPosition,
+    onFileSelectorStateChange,
   ]);
 
   useEffect(() => {
-    callbacksRef.current.onCommandSelectorStateChange?.(
+    onCommandSelectorStateChange?.(
       state.showCommandSelector,
       state.commandSearchQuery,
       state.slashPosition,
@@ -114,48 +269,51 @@ export const useInputManager = (
     state.showCommandSelector,
     state.commandSearchQuery,
     state.slashPosition,
+    onCommandSelectorStateChange,
   ]);
 
   useEffect(() => {
-    callbacksRef.current.onHistorySearchStateChange?.(
+    onHistorySearchStateChange?.(
       state.showHistorySearch,
       state.historySearchQuery,
     );
-  }, [state.showHistorySearch, state.historySearchQuery]);
+  }, [
+    state.showHistorySearch,
+    state.historySearchQuery,
+    onHistorySearchStateChange,
+  ]);
 
   useEffect(() => {
-    callbacksRef.current.onBackgroundTaskManagerStateChange?.(
-      state.showBackgroundTaskManager,
-    );
-  }, [state.showBackgroundTaskManager]);
+    onBackgroundTaskManagerStateChange?.(state.showBackgroundTaskManager);
+  }, [state.showBackgroundTaskManager, onBackgroundTaskManagerStateChange]);
 
   useEffect(() => {
-    callbacksRef.current.onMcpManagerStateChange?.(state.showMcpManager);
-  }, [state.showMcpManager]);
+    onMcpManagerStateChange?.(state.showMcpManager);
+  }, [state.showMcpManager, onMcpManagerStateChange]);
 
   useEffect(() => {
-    callbacksRef.current.onRewindManagerStateChange?.(state.showRewindManager);
-  }, [state.showRewindManager]);
+    onRewindManagerStateChange?.(state.showRewindManager);
+  }, [state.showRewindManager, onRewindManagerStateChange]);
 
   useEffect(() => {
-    callbacksRef.current.onHelpStateChange?.(state.showHelp);
-  }, [state.showHelp]);
+    onHelpStateChange?.(state.showHelp);
+  }, [state.showHelp, onHelpStateChange]);
 
   useEffect(() => {
-    callbacksRef.current.onStatusCommandStateChange?.(state.showStatusCommand);
-  }, [state.showStatusCommand]);
+    onStatusCommandStateChange?.(state.showStatusCommand);
+  }, [state.showStatusCommand, onStatusCommandStateChange]);
 
   useEffect(() => {
-    callbacksRef.current.onPluginManagerStateChange?.(state.showPluginManager);
-  }, [state.showPluginManager]);
+    onPluginManagerStateChange?.(state.showPluginManager);
+  }, [state.showPluginManager, onPluginManagerStateChange]);
 
   useEffect(() => {
-    callbacksRef.current.onModelSelectorStateChange?.(state.showModelSelector);
-  }, [state.showModelSelector]);
+    onModelSelectorStateChange?.(state.showModelSelector);
+  }, [state.showModelSelector, onModelSelectorStateChange]);
 
   useEffect(() => {
-    callbacksRef.current.onImagesStateChange?.(state.attachedImages);
-  }, [state.attachedImages]);
+    onImagesStateChange?.(state.attachedImages);
+  }, [state.attachedImages, onImagesStateChange]);
 
   // Handle /btw side question
   useEffect(() => {
@@ -166,9 +324,7 @@ export const useInputManager = (
     ) {
       const askBtw = async () => {
         try {
-          const answer = await callbacksRef.current.onAskBtw?.(
-            state.btwState.question,
-          );
+          const answer = await onAskBtw?.(state.btwState.question);
           dispatch({
             type: "SET_BTW_STATE",
             payload: { answer, isLoading: false },
@@ -190,6 +346,7 @@ export const useInputManager = (
     state.btwState.isActive,
     state.btwState.isLoading,
     state.btwState.question,
+    onAskBtw,
   ]);
 
   // Methods
@@ -218,12 +375,7 @@ export const useInputManager = (
   }, []);
 
   const handleFileSelect = useCallback((filePath: string) => {
-    return handlers.handleFileSelect(
-      stateRef.current,
-      dispatch,
-      callbacksRef.current,
-      filePath,
-    );
+    dispatch({ type: "SELECT_FILE", payload: filePath });
   }, []);
 
   const handleCancelFileSelect = useCallback(() => {
@@ -234,51 +386,25 @@ export const useInputManager = (
     dispatch({ type: "SET_FILE_SEARCH_QUERY", payload: query });
   }, []);
 
-  const checkForAtDeletion = useCallback((cursorPos: number) => {
-    return handlers.checkForAtDeletion(stateRef.current, dispatch, cursorPos);
-  }, []);
+  const checkForAtDeletion = useCallback(
+    (cursorPos: number) => {
+      // This is now largely handled inside HANDLE_KEY,
+      // but kept for external calls if any.
+      return handlers.checkForAtDeletion(state, dispatch, cursorPos);
+    },
+    [state],
+  );
 
   const activateCommandSelector = useCallback((position: number) => {
     dispatch({ type: "ACTIVATE_COMMAND_SELECTOR", payload: position });
   }, []);
 
   const handleCommandSelect = useCallback((command: string) => {
-    return handlers.handleCommandSelect(
-      stateRef.current,
-      dispatch,
-      callbacksRef.current,
-      command,
-    );
+    dispatch({ type: "SELECT_COMMAND", payload: command });
   }, []);
 
   const handleCommandInsert = useCallback((command: string) => {
-    const currentState = stateRef.current;
-    if (currentState.slashPosition >= 0) {
-      const wordEnd = handlers.getWordEnd(
-        currentState.inputText,
-        currentState.slashPosition,
-      );
-      const beforeSlash = currentState.inputText.substring(
-        0,
-        currentState.slashPosition,
-      );
-      const afterWord = currentState.inputText.substring(wordEnd);
-      const newInput = beforeSlash + `/${command} ` + afterWord;
-      const newCursorPosition = beforeSlash.length + command.length + 2;
-
-      dispatch({ type: "SET_INPUT_TEXT", payload: newInput });
-      dispatch({ type: "SET_CURSOR_POSITION", payload: newCursorPosition });
-      dispatch({ type: "CANCEL_COMMAND_SELECTOR" });
-
-      callbacksRef.current.onInputTextChange?.(newInput);
-      callbacksRef.current.onCursorPositionChange?.(newCursorPosition);
-
-      return { newInput, newCursorPosition };
-    }
-    return {
-      newInput: currentState.inputText,
-      newCursorPosition: currentState.cursorPosition,
-    };
+    dispatch({ type: "INSERT_COMMAND", payload: command });
   }, []);
 
   const handleCancelCommandSelect = useCallback(() => {
@@ -289,13 +415,12 @@ export const useInputManager = (
     dispatch({ type: "SET_COMMAND_SEARCH_QUERY", payload: query });
   }, []);
 
-  const checkForSlashDeletion = useCallback((cursorPos: number) => {
-    return handlers.checkForSlashDeletion(
-      stateRef.current,
-      dispatch,
-      cursorPos,
-    );
-  }, []);
+  const checkForSlashDeletion = useCallback(
+    (cursorPos: number) => {
+      return handlers.checkForSlashDeletion(state, dispatch, cursorPos);
+    },
+    [state],
+  );
 
   const handleHistorySearchSelect = useCallback((entry: PromptEntry) => {
     dispatch({ type: "SELECT_HISTORY_ENTRY", payload: entry });
@@ -305,9 +430,12 @@ export const useInputManager = (
     dispatch({ type: "CANCEL_HISTORY_SEARCH" });
   }, []);
 
-  const processSelectorInput = useCallback((char: string) => {
-    handlers.processSelectorInput(stateRef.current, dispatch, char);
-  }, []);
+  const processSelectorInput = useCallback(
+    (char: string) => {
+      handlers.processSelectorInput(state, dispatch, char);
+    },
+    [state],
+  );
 
   const setInputText = useCallback((text: string) => {
     dispatch({ type: "SET_INPUT_TEXT", payload: text });
@@ -345,14 +473,13 @@ export const useInputManager = (
     dispatch({ type: "SET_SHOW_MODEL_SELECTOR", payload: show });
   }, []);
 
-  const setPermissionMode = useCallback((mode: PermissionMode) => {
-    dispatch({ type: "SET_PERMISSION_MODE", payload: mode });
-    callbacksRef.current.onPermissionModeChange?.(mode);
-  }, []);
-
-  const setAllowBypassInCycle = useCallback((allow: boolean) => {
-    dispatch({ type: "SET_ALLOW_BYPASS_IN_CYCLE", payload: allow });
-  }, []);
+  const setPermissionMode = useCallback(
+    (mode: PermissionMode) => {
+      dispatch({ type: "SET_PERMISSION_MODE", payload: mode });
+      onPermissionModeChange?.(mode);
+    },
+    [onPermissionModeChange],
+  );
 
   const setBtwState = useCallback(
     (payload: Partial<import("../managers/inputReducer.js").BtwState>) => {
@@ -377,35 +504,37 @@ export const useInputManager = (
     return await handlers.handlePasteImage(dispatch);
   }, []);
 
-  const handlePasteInput = useCallback((input: string) => {
-    handlers.handlePasteInput(
-      stateRef.current,
-      dispatch,
-      callbacksRef.current,
-      input,
-    );
-  }, []);
-
-  const handleSubmit = useCallback(
-    async (
-      attachedImages: Array<{ id: number; path: string; mimeType: string }>,
-    ) => {
-      await handlers.handleSubmit(
-        stateRef.current,
-        dispatch,
-        callbacksRef.current,
-        attachedImages,
-      );
+  const handlePasteInput = useCallback(
+    (input: string) => {
+      dispatch({
+        type: "HANDLE_KEY",
+        payload: {
+          input,
+          key: {} as Key,
+          hasSlashCommand: (cmd) => !!onHasSlashCommand?.(cmd),
+        },
+      });
     },
-    [],
+    [onHasSlashCommand],
   );
 
-  const expandLongTextPlaceholders = useCallback((text: string) => {
-    return handlers.expandLongTextPlaceholders(
-      text,
-      stateRef.current.longTextMap,
-    );
-  }, []);
+  const handleSubmit = useCallback(async () => {
+    dispatch({
+      type: "HANDLE_KEY",
+      payload: {
+        input: "",
+        key: { return: true } as Key,
+        hasSlashCommand: (cmd) => !!onHasSlashCommand?.(cmd),
+      },
+    });
+  }, [onHasSlashCommand]);
+
+  const expandLongTextPlaceholders = useCallback(
+    (text: string) => {
+      return handlers.expandLongTextPlaceholders(text, state.longTextMap);
+    },
+    [state.longTextMap],
+  );
 
   const clearLongTextMap = useCallback(() => {
     dispatch({ type: "CLEAR_LONG_TEXT_MAP" });
@@ -415,19 +544,25 @@ export const useInputManager = (
     async (
       input: string,
       key: Key,
-      attachedImages: Array<{ id: number; path: string; mimeType: string }>,
+      _attachedImages: Array<{ id: number; path: string; mimeType: string }>,
       clearImages?: () => void,
     ) => {
-      return await handlers.handleInput(
-        stateRef.current,
-        dispatch,
-        callbacksRef.current,
-        input,
-        key,
-        clearImages,
-      );
+      // Clear images side effect if return is pressed
+      if (key.return) {
+        clearImages?.();
+      }
+
+      dispatch({
+        type: "HANDLE_KEY",
+        payload: {
+          input,
+          key,
+          hasSlashCommand: (cmd) => !!onHasSlashCommand?.(cmd),
+        },
+      });
+      return true;
     },
-    [],
+    [onHasSlashCommand],
   );
 
   return {
@@ -494,7 +629,6 @@ export const useInputManager = (
     setShowPluginManager,
     setShowModelSelector,
     setPermissionMode,
-    setAllowBypassInCycle,
     setBtwState,
 
     // Image management

package/src/managers/inputHandlers.ts

@@ -124,12 +124,8 @@ export const cyclePermissionMode = (
   currentMode: PermissionMode,
   dispatch: React.Dispatch<InputAction>,
   callbacks: Partial<InputManagerCallbacks>,
-  allowBypassInCycle: boolean = false,
 ) => {
-  const modes: PermissionMode[] = ["default", "acceptEdits", "plan"];
-  if (allowBypassInCycle) {
-    modes.push("bypassPermissions");
-  }
+  const modes: PermissionMode[] = ["default", "acceptEdits", "plan", "bypassPermissions"];
   const currentIndex = modes.indexOf(currentMode);
   const nextIndex = currentIndex === -1 ? 0 : (currentIndex + 1) % modes.length;
   const nextMode = modes[nextIndex];
@@ -768,7 +764,6 @@ export const handleInput = async (
       state.permissionMode,
       dispatch,
       callbacks,
-      state.allowBypassInCycle,
     );
     return true;
   }