wave-code 0.8.3 → 0.9.0

package/src/components/RewindCommand.tsx

@@ -35,6 +35,7 @@ export const RewindCommand: React.FC<RewindCommandProps> = ({
     .map((msg, index) => ({ msg, index }))
     .filter(({ msg }) => msg.role === "user");
 
+  const MAX_VISIBLE_ITEMS = 3;
   const [selectedIndex, setSelectedIndex] = useState(checkpoints.length - 1);
 
   // Update selectedIndex when checkpoints change (after loading full thread)
@@ -42,6 +43,19 @@ export const RewindCommand: React.FC<RewindCommandProps> = ({
     setSelectedIndex(checkpoints.length - 1);
   }, [checkpoints.length]);
 
+  // Calculate visible window
+  const startIndex = Math.max(
+    0,
+    Math.min(
+      selectedIndex - Math.floor(MAX_VISIBLE_ITEMS / 2),
+      Math.max(0, checkpoints.length - MAX_VISIBLE_ITEMS),
+    ),
+  );
+  const visibleCheckpoints = checkpoints.slice(
+    startIndex,
+    startIndex + MAX_VISIBLE_ITEMS,
+  );
+
   useInput((input, key) => {
     if (key.return) {
       if (checkpoints.length > 0 && selectedIndex >= 0) {
@@ -114,12 +128,14 @@ export const RewindCommand: React.FC<RewindCommandProps> = ({
       </Box>
 
       <Box flexDirection="column">
-        {checkpoints.map((checkpoint, index) => {
-          const isSelected = index === selectedIndex;
+        {visibleCheckpoints.map((checkpoint, index) => {
+          const actualIndex = startIndex + index;
+          const isSelected = actualIndex === selectedIndex;
           const content = checkpoint.msg.blocks
             .filter((b): b is TextBlock => b.type === "text")
             .map((b) => b.content)
             .join(" ")
+            .replace(/\n/g, "\\n")
             .substring(0, 60);
 
           return (
@@ -130,7 +146,7 @@ export const RewindCommand: React.FC<RewindCommandProps> = ({
               >
                 {isSelected ? "▶ " : "  "}[{checkpoint.index}]{" "}
                 {content || "(No text content)"}
-                {index === checkpoints.length - 1 ? " (Latest)" : ""}
+                {actualIndex === checkpoints.length - 1 ? " (Latest)" : ""}
               </Text>
             </Box>
           );
@@ -142,8 +158,8 @@ export const RewindCommand: React.FC<RewindCommandProps> = ({
       </Box>
       <Box>
         <Text color="red" dimColor>
-          ⚠️ Warning: This will delete all subsequent messages and revert file
-          and task list changes.
+          Warning: This will delete all subsequent messages and revert file and
+          task list changes.
         </Text>
       </Box>
     </Box>

package/src/components/ToolDisplay.tsx

@@ -129,8 +129,8 @@ export const ToolDisplay: React.FC<ToolDisplayProps> = ({
         </Box>
       )}
 
-      {/* Diff display - only show after tool execution completes and was successful */}
-      {stage === "end" && success && (
+      {/* Diff display - only show after tool execution completes and was successful, and NOT in expanded mode */}
+      {!isExpanded && stage === "end" && success && (
         <DiffDisplay
           toolName={name}
           parameters={parameters}

package/src/contexts/useChat.tsx

@@ -37,6 +37,10 @@ export interface ChatContextType {
   isExpanded: boolean;
   isTaskListVisible: boolean;
   setIsTaskListVisible: (visible: boolean) => void;
+  queuedMessages: Array<{
+    content: string;
+    images?: Array<{ path: string; mimeType: string }>;
+  }>;
   // AI functionality
   sessionId: string;
   sendMessage: (
@@ -139,6 +143,13 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
 
   const [isTaskListVisible, setIsTaskListVisible] = useState(true);
 
+  const [queuedMessages, setQueuedMessages] = useState<
+    Array<{
+      content: string;
+      images?: Array<{ path: string; mimeType: string }>;
+    }>
+  >([]);
+
   // AI State
   const [messages, setMessages] = useState<Message[]>([]);
 
@@ -393,6 +404,11 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
 
       if (!hasTextContent && !hasImageAttachments) return;
 
+      if (isLoading || isCommandRunning) {
+        setQueuedMessages((prev) => [...prev, { content, images }]);
+        return;
+      }
+
       try {
         // Handle bash mode - check if it's a bash command (starts with ! and only one line)
         if (content.startsWith("!") && !content.includes("\n")) {
@@ -432,15 +448,26 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         // Loading state will be automatically updated by the useEffect that watches messages
       }
     },
-    [],
+    [isLoading, isCommandRunning],
   );
 
+  // Process queued messages when idle
+  useEffect(() => {
+    if (!isLoading && !isCommandRunning && queuedMessages.length > 0) {
+      const nextMessage = queuedMessages[0];
+      setQueuedMessages((prev) => prev.slice(1));
+      sendMessage(nextMessage.content, nextMessage.images);
+    }
+  }, [isLoading, isCommandRunning, queuedMessages, sendMessage]);
+
   // Unified interrupt method, interrupt both AI messages and command execution
   const abortMessage = useCallback(() => {
+    setQueuedMessages([]);
     agentRef.current?.abortMessage();
   }, []);
 
   const clearMessages = useCallback(() => {
+    setQueuedMessages([]);
     agentRef.current?.clearMessages();
   }, []);
 
@@ -604,6 +631,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     isExpanded,
     isTaskListVisible,
     setIsTaskListVisible,
+    queuedMessages,
     sessionId,
     sendMessage,
     abortMessage,

package/src/hooks/useInputManager.ts

@@ -204,14 +204,16 @@ export const useInputManager = (
   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 afterQuery = currentState.inputText.substring(
-        currentState.cursorPosition,
-      );
-      const newInput = beforeSlash + `/${command} ` + afterQuery;
+      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 });
@@ -255,14 +257,8 @@ export const useInputManager = (
     dispatch({ type: "CANCEL_HISTORY_SEARCH" });
   }, []);
 
-  const handleSpecialCharInput = useCallback((char: string) => {
-    handlers.handleSpecialCharInput(
-      stateRef.current,
-      dispatch,
-      char,
-      stateRef.current.cursorPosition,
-      stateRef.current.inputText,
-    );
+  const processSelectorInput = useCallback((char: string) => {
+    handlers.processSelectorInput(stateRef.current, dispatch, char);
   }, []);
 
   const setInputText = useCallback((text: string) => {
@@ -326,15 +322,11 @@ export const useInputManager = (
   const handleSubmit = useCallback(
     async (
       attachedImages: Array<{ id: number; path: string; mimeType: string }>,
-      isLoading: boolean = false,
-      isCommandRunning: boolean = false,
     ) => {
       await handlers.handleSubmit(
         stateRef.current,
         dispatch,
         callbacksRef.current,
-        isLoading,
-        isCommandRunning,
         attachedImages,
       );
     },
@@ -357,8 +349,6 @@ export const useInputManager = (
       input: string,
       key: Key,
       attachedImages: Array<{ id: number; path: string; mimeType: string }>,
-      isLoading: boolean = false,
-      isCommandRunning: boolean = false,
       clearImages?: () => void,
     ) => {
       return await handlers.handleInput(
@@ -367,8 +357,6 @@ export const useInputManager = (
         callbacksRef.current,
         input,
         key,
-        isLoading,
-        isCommandRunning,
         clearImages,
       );
     },
@@ -424,7 +412,7 @@ export const useInputManager = (
     handleCancelHistorySearch,
 
     // Special handling
-    handleSpecialCharInput,
+    processSelectorInput,
 
     // Bash/MCP Manager
     setShowBackgroundTaskManager,

package/src/managers/inputHandlers.ts

@@ -30,18 +30,12 @@ export const handleSubmit = async (
   state: InputState,
   dispatch: React.Dispatch<InputAction>,
   callbacks: Partial<InputManagerCallbacks>,
-  isLoading: boolean = false,
-  isCommandRunning: boolean = false,
   attachedImagesOverride?: Array<{
     id: number;
     path: string;
     mimeType: string;
   }>,
 ): Promise<void> => {
-  if (isLoading || isCommandRunning) {
-    return;
-  }
-
   if (state.inputText.trim()) {
     const imageRegex = /\[Image #(\d+)\]/g;
     const matches = [...state.inputText.matchAll(imageRegex)];
@@ -114,6 +108,72 @@ export const cyclePermissionMode = (
   callbacks.onPermissionModeChange?.(nextMode);
 };
 
+const SELECTOR_TRIGGERS = [
+  {
+    char: "@",
+    type: "ACTIVATE_FILE_SELECTOR",
+    shouldActivate: (char: string, pos: number, text: string) =>
+      char === "@" && (pos === 1 || /\s/.test(text[pos - 2])),
+  },
+  {
+    char: "/",
+    type: "ACTIVATE_COMMAND_SELECTOR",
+    shouldActivate: (
+      char: string,
+      pos: number,
+      text: string,
+      state: InputState,
+    ) =>
+      char === "/" &&
+      !state.showFileSelector &&
+      (pos === 1 || /\s/.test(text[pos - 2])),
+  },
+] as const;
+
+const getProjectedState = (state: InputState, char: string) => {
+  const beforeCursor = state.inputText.substring(0, state.cursorPosition);
+  const afterCursor = state.inputText.substring(state.cursorPosition);
+  const newInputText = beforeCursor + char + afterCursor;
+  const newCursorPosition = state.cursorPosition + char.length;
+  return { newInputText, newCursorPosition };
+};
+
+export const getAtSelectorPosition = (
+  text: string,
+  cursorPosition: number,
+): number => {
+  let i = cursorPosition - 1;
+  while (i >= 0 && !/\s/.test(text[i])) {
+    if (text[i] === "@") {
+      // Check if this @ is at the start or preceded by whitespace
+      if (i === 0 || /\s/.test(text[i - 1])) {
+        return i;
+      }
+      break;
+    }
+    i--;
+  }
+  return -1;
+};
+
+export const getSlashSelectorPosition = (
+  text: string,
+  cursorPosition: number,
+): number => {
+  let i = cursorPosition - 1;
+  while (i >= 0 && !/\s/.test(text[i])) {
+    if (text[i] === "/") {
+      // Check if this / is at the start or preceded by whitespace
+      if (i === 0 || /\s/.test(text[i - 1])) {
+        return i;
+      }
+      break;
+    }
+    i--;
+  }
+  return -1;
+};
+
 export const updateSearchQueriesForActiveSelectors = (
   state: InputState,
   dispatch: React.Dispatch<InputAction>,
@@ -133,26 +193,58 @@ export const updateSearchQueriesForActiveSelectors = (
   }
 };
 
-export const handleSpecialCharInput = (
+export const processSelectorInput = (
   state: InputState,
   dispatch: React.Dispatch<InputAction>,
   char: string,
-  cursorPosition: number,
-  inputText: string,
 ): void => {
-  if (char === "@") {
-    dispatch({ type: "ACTIVATE_FILE_SELECTOR", payload: cursorPosition - 1 });
-  } else if (char === "/" && !state.showFileSelector && cursorPosition === 1) {
+  const { newInputText, newCursorPosition } = getProjectedState(state, char);
+
+  const trigger = SELECTOR_TRIGGERS.find((t) =>
+    t.shouldActivate(char, newCursorPosition, newInputText, state),
+  );
+
+  if (trigger) {
     dispatch({
-      type: "ACTIVATE_COMMAND_SELECTOR",
-      payload: cursorPosition - 1,
-    });
+      type: trigger.type,
+      payload: newCursorPosition - 1,
+    } as InputAction);
   } else {
+    const atPos = getAtSelectorPosition(newInputText, newCursorPosition);
+    let showFileSelector = state.showFileSelector;
+    let atPosition = state.atPosition;
+    if (atPos !== -1 && !state.showFileSelector) {
+      dispatch({
+        type: "ACTIVATE_FILE_SELECTOR",
+        payload: atPos,
+      });
+      showFileSelector = true;
+      atPosition = atPos;
+    }
+
+    const slashPos = getSlashSelectorPosition(newInputText, newCursorPosition);
+    let showCommandSelector = state.showCommandSelector;
+    let slashPosition = state.slashPosition;
+    if (slashPos !== -1 && !state.showCommandSelector) {
+      dispatch({
+        type: "ACTIVATE_COMMAND_SELECTOR",
+        payload: slashPos,
+      });
+      showCommandSelector = true;
+      slashPosition = slashPos;
+    }
+
     updateSearchQueriesForActiveSelectors(
-      state,
+      {
+        ...state,
+        showFileSelector,
+        atPosition,
+        showCommandSelector,
+        slashPosition,
+      },
       dispatch,
-      inputText,
-      cursorPosition,
+      newInputText,
+      newCursorPosition,
     );
   }
 };
@@ -187,20 +279,16 @@ export const handlePasteInput = (
     callbacks.onResetHistoryNavigation?.();
     dispatch({ type: "INSERT_TEXT", payload: char });
 
-    // Calculate new state for special char handling
-    const newCursorPosition = state.cursorPosition + char.length;
-    const beforeCursor = state.inputText.substring(0, state.cursorPosition);
-    const afterCursor = state.inputText.substring(state.cursorPosition);
-    const newInputText = beforeCursor + char + afterCursor;
+    processSelectorInput(state, dispatch, char);
+  }
+};
 
-    handleSpecialCharInput(
-      state,
-      dispatch,
-      char,
-      newCursorPosition,
-      newInputText,
-    );
+export const getWordEnd = (text: string, startPos: number): number => {
+  let i = startPos;
+  while (i < text.length && !/\s/.test(text[i])) {
+    i++;
   }
+  return i;
 };
 
 export const handleCommandSelect = (
@@ -210,9 +298,10 @@ export const handleCommandSelect = (
   command: string,
 ) => {
   if (state.slashPosition >= 0) {
+    const wordEnd = getWordEnd(state.inputText, state.slashPosition);
     const beforeSlash = state.inputText.substring(0, state.slashPosition);
-    const afterQuery = state.inputText.substring(state.cursorPosition);
-    const newInput = beforeSlash + afterQuery;
+    const afterWord = state.inputText.substring(wordEnd);
+    const newInput = beforeSlash + afterWord;
     const newCursorPosition = beforeSlash.length;
 
     dispatch({ type: "SET_INPUT_TEXT", payload: newInput });
@@ -264,10 +353,11 @@ export const handleFileSelect = (
   filePath: string,
 ) => {
   if (state.atPosition >= 0) {
+    const wordEnd = getWordEnd(state.inputText, state.atPosition);
     const beforeAt = state.inputText.substring(0, state.atPosition);
-    const afterQuery = state.inputText.substring(state.cursorPosition);
-    const newInput = beforeAt + `${filePath} ` + afterQuery;
-    const newCursorPosition = beforeAt.length + filePath.length + 1;
+    const afterWord = state.inputText.substring(wordEnd);
+    const newInput = beforeAt + `@${filePath} ` + afterWord;
+    const newCursorPosition = beforeAt.length + filePath.length + 2;
 
     dispatch({ type: "SET_INPUT_TEXT", payload: newInput });
     dispatch({ type: "SET_CURSOR_POSITION", payload: newCursorPosition });
@@ -343,6 +433,26 @@ export const handleSelectorInput = (
     return true;
   }
 
+  if (key.leftArrow) {
+    const newCursorPosition = state.cursorPosition - 1;
+    dispatch({ type: "MOVE_CURSOR", payload: -1 });
+    checkForAtDeletion(state, dispatch, newCursorPosition);
+    checkForSlashDeletion(state, dispatch, newCursorPosition);
+    return true;
+  }
+
+  if (key.rightArrow) {
+    const newCursorPosition = state.cursorPosition + 1;
+    dispatch({ type: "MOVE_CURSOR", payload: 1 });
+    checkForAtDeletion(state, dispatch, newCursorPosition);
+    checkForSlashDeletion(state, dispatch, newCursorPosition);
+    return true;
+  }
+
+  if (input === " " && state.showFileSelector) {
+    dispatch({ type: "CANCEL_FILE_SELECTOR" });
+  }
+
   if (
     input &&
     !key.ctrl &&
@@ -358,19 +468,7 @@ export const handleSelectorInput = (
   ) {
     dispatch({ type: "INSERT_TEXT", payload: input });
 
-    // Calculate new state for special char handling
-    const newCursorPosition = state.cursorPosition + input.length;
-    const beforeCursor = state.inputText.substring(0, state.cursorPosition);
-    const afterCursor = state.inputText.substring(state.cursorPosition);
-    const newInputText = beforeCursor + input + afterCursor;
-
-    handleSpecialCharInput(
-      state,
-      dispatch,
-      input,
-      newCursorPosition,
-      newInputText,
-    );
+    processSelectorInput(state, dispatch, input);
     return true;
   }
 
@@ -383,12 +481,10 @@ export const handleNormalInput = async (
   callbacks: Partial<InputManagerCallbacks>,
   input: string,
   key: Key,
-  isLoading: boolean = false,
-  isCommandRunning: boolean = false,
   clearImages?: () => void,
 ): Promise<boolean> => {
   if (key.return) {
-    await handleSubmit(state, dispatch, callbacks, isLoading, isCommandRunning);
+    await handleSubmit(state, dispatch, callbacks);
     clearImages?.();
     return true;
   }
@@ -405,11 +501,61 @@ export const handleNormalInput = async (
   if (key.backspace || key.delete) {
     if (state.cursorPosition > 0) {
       const newCursorPosition = state.cursorPosition - 1;
+      const beforeCursor = state.inputText.substring(
+        0,
+        state.cursorPosition - 1,
+      );
+      const afterCursor = state.inputText.substring(state.cursorPosition);
+      const newInputText = beforeCursor + afterCursor;
+
       dispatch({ type: "DELETE_CHAR" });
       callbacks.onResetHistoryNavigation?.();
 
       checkForAtDeletion(state, dispatch, newCursorPosition);
       checkForSlashDeletion(state, dispatch, newCursorPosition);
+
+      // Reactivate file selector if cursor is now within an @word
+      const atPos = getAtSelectorPosition(newInputText, newCursorPosition);
+      let showFileSelector = state.showFileSelector;
+      let atPosition = state.atPosition;
+      if (atPos !== -1 && !state.showFileSelector) {
+        dispatch({
+          type: "ACTIVATE_FILE_SELECTOR",
+          payload: atPos,
+        });
+        showFileSelector = true;
+        atPosition = atPos;
+      }
+
+      const slashPos = getSlashSelectorPosition(
+        newInputText,
+        newCursorPosition,
+      );
+      let showCommandSelector = state.showCommandSelector;
+      let slashPosition = state.slashPosition;
+      if (slashPos !== -1 && !state.showCommandSelector) {
+        dispatch({
+          type: "ACTIVATE_COMMAND_SELECTOR",
+          payload: slashPos,
+        });
+        showCommandSelector = true;
+        slashPosition = slashPos;
+      }
+
+      updateSearchQueriesForActiveSelectors(
+        {
+          ...state,
+          inputText: newInputText,
+          cursorPosition: newCursorPosition,
+          showFileSelector,
+          atPosition,
+          showCommandSelector,
+          slashPosition,
+        },
+        dispatch,
+        newInputText,
+        newCursorPosition,
+      );
     }
     return true;
   }
@@ -468,8 +614,6 @@ export const handleInput = async (
   callbacks: Partial<InputManagerCallbacks>,
   input: string,
   key: Key,
-  isLoading: boolean = false,
-  isCommandRunning: boolean = false,
   clearImages?: () => void,
 ): Promise<boolean> => {
   if (state.selectorJustUsed) {
@@ -478,7 +622,6 @@ export const handleInput = async (
 
   if (key.escape) {
     if (
-      (isLoading || isCommandRunning) &&
       !(
         state.showFileSelector ||
         state.showCommandSelector ||
@@ -552,8 +695,6 @@ export const handleInput = async (
       callbacks,
       input,
       key,
-      isLoading,
-      isCommandRunning,
       clearImages,
     );
   }