wave-code 0.13.5 → 0.14.0

package/src/components/ConfirmationSelector.tsx

@@ -1,4 +1,4 @@
-import React, { useEffect, useRef, useState } from "react";
+import React, { useEffect, useReducer } from "react";
 import { Box, Text, useInput } from "ink";
 import type { PermissionDecision, AskUserQuestionInput } from "wave-agent-sdk";
 import {
@@ -7,6 +7,11 @@ import {
   ENTER_PLAN_MODE_TOOL_NAME,
   ASK_USER_QUESTION_TOOL_NAME,
 } from "wave-agent-sdk";
+import {
+  confirmationReducer,
+  type ConfirmationState,
+} from "../reducers/confirmationReducer.js";
+import { questionReducer } from "../reducers/questionReducer.js";
 
 const getHeaderColor = (header: string) => {
   const colors = ["red", "green", "blue", "magenta", "cyan"] as const;
@@ -25,14 +30,6 @@ export interface ConfirmationSelectorProps {
   isExpanded?: boolean;
   onDecision: (decision: PermissionDecision) => void;
   onCancel: () => void;
-  onAbort: () => void;
-}
-
-interface ConfirmationState {
-  selectedOption: "clear" | "auto" | "allow" | "alternative";
-  alternativeText: string;
-  alternativeCursorPosition: number;
-  hasUserInput: boolean;
 }
 
 export const ConfirmationSelector: React.FC<ConfirmationSelectorProps> = ({
@@ -43,45 +40,42 @@ export const ConfirmationSelector: React.FC<ConfirmationSelectorProps> = ({
   isExpanded = false,
   onDecision,
   onCancel,
-  onAbort,
 }) => {
-  const [state, setState] = useState<ConfirmationState>({
+  const [state, dispatch] = useReducer(confirmationReducer, {
     selectedOption: toolName === EXIT_PLAN_MODE_TOOL_NAME ? "clear" : "allow",
     alternativeText: "",
     alternativeCursorPosition: 0,
     hasUserInput: false,
+    decision: null,
   });
 
-  const [questionState, setQuestionState] = useState({
+  const questions =
+    (toolInput as unknown as AskUserQuestionInput)?.questions || [];
+
+  const [questionState, questionDispatch] = useReducer(questionReducer, {
     currentQuestionIndex: 0,
     selectedOptionIndex: 0,
     selectedOptionIndices: new Set<number>(),
-    userAnswers: {} as Record<string, string>,
+    userAnswers: {},
     otherText: "",
     otherCursorPosition: 0,
-    savedStates: {} as Record<
-      number,
-      {
-        selectedOptionIndex: number;
-        selectedOptionIndices: Set<number>;
-        otherText: string;
-        otherCursorPosition: number;
-      }
-    >,
+    savedStates: {},
+    decision: null,
   });
 
-  const pendingDecisionRef = useRef<PermissionDecision | null>(null);
+  // Handle decisions from reducers
+  useEffect(() => {
+    if (state.decision) {
+      onDecision(state.decision);
+    }
+  }, [state.decision, onDecision]);
 
   useEffect(() => {
-    if (pendingDecisionRef.current) {
-      const decision = pendingDecisionRef.current;
-      pendingDecisionRef.current = null;
-      onDecision(decision);
+    if (questionState.decision) {
+      onDecision(questionState.decision);
     }
-  });
+  }, [questionState.decision, onDecision]);
 
-  const questions =
-    (toolInput as unknown as AskUserQuestionInput)?.questions || [];
   const currentQuestion = questions[questionState.currentQuestionIndex];
 
   const getAutoOptionText = () => {
@@ -107,7 +101,6 @@ export const ConfirmationSelector: React.FC<ConfirmationSelectorProps> = ({
   useInput((input, key) => {
     if (key.escape) {
       onCancel();
-      onAbort();
       return;
     }
 
@@ -117,296 +110,148 @@ export const ConfirmationSelector: React.FC<ConfirmationSelectorProps> = ({
       const isMultiSelect = currentQuestion.multiSelect;
 
       if (key.return) {
-        setQuestionState((prev) => {
-          const isOtherFocused =
-            prev.selectedOptionIndex === options.length - 1;
-          let answer = "";
-          if (isMultiSelect) {
-            const selectedLabels = Array.from(prev.selectedOptionIndices)
-              .filter((i) => i < currentQuestion.options.length)
-              .map((i) => currentQuestion.options[i].label);
-            const isOtherChecked = prev.selectedOptionIndices.has(
-              options.length - 1,
-            );
-            if (isOtherChecked && prev.otherText.trim()) {
-              selectedLabels.push(prev.otherText.trim());
-            }
-            answer = selectedLabels.join(", ");
-          } else {
-            if (isOtherFocused) {
-              answer = prev.otherText.trim();
-            } else {
-              answer = options[prev.selectedOptionIndex].label;
-            }
-          }
-
-          if (!answer) return prev;
-
-          const newAnswers = {
-            ...prev.userAnswers,
-            [currentQuestion.question]: answer,
-          };
-
-          if (prev.currentQuestionIndex < questions.length - 1) {
-            const nextIndex = prev.currentQuestionIndex + 1;
-            const savedStates = {
-              ...prev.savedStates,
-              [prev.currentQuestionIndex]: {
-                selectedOptionIndex: prev.selectedOptionIndex,
-                selectedOptionIndices: prev.selectedOptionIndices,
-                otherText: prev.otherText,
-                otherCursorPosition: prev.otherCursorPosition,
-              },
-            };
-
-            const nextState = savedStates[nextIndex] || {
-              selectedOptionIndex: 0,
-              selectedOptionIndices: new Set<number>(),
-              otherText: "",
-              otherCursorPosition: 0,
-            };
-
-            return {
-              ...prev,
-              currentQuestionIndex: nextIndex,
-              ...nextState,
-              userAnswers: newAnswers,
-              savedStates,
-            };
-          } else {
-            const finalAnswers = { ...newAnswers };
-            // Also collect from savedStates for any questions that were skipped via Tab
-            for (const [idxStr, s] of Object.entries(prev.savedStates)) {
-              const idx = parseInt(idxStr);
-              const q = questions[idx];
-              if (q && !finalAnswers[q.question]) {
-                const opts = [...q.options, { label: "Other" }];
-                let a = "";
-                if (q.multiSelect) {
-                  const selectedLabels = Array.from(s.selectedOptionIndices)
-                    .filter((i) => i < q.options.length)
-                    .map((i) => q.options[i].label);
-                  const isOtherChecked = s.selectedOptionIndices.has(
-                    opts.length - 1,
-                  );
-                  if (isOtherChecked && s.otherText.trim()) {
-                    selectedLabels.push(s.otherText.trim());
-                  }
-                  a = selectedLabels.join(", ");
-                } else {
-                  if (s.selectedOptionIndex === opts.length - 1) {
-                    a = s.otherText.trim();
-                  } else {
-                    a = opts[s.selectedOptionIndex].label;
-                  }
-                }
-                if (a) finalAnswers[q.question] = a;
-              }
-            }
-
-            // Only submit if all questions have been answered
-            const allAnswered = questions.every(
-              (q) => finalAnswers[q.question],
-            );
-            if (!allAnswered) return prev;
-
-            pendingDecisionRef.current = {
-              behavior: "allow",
-              message: JSON.stringify(finalAnswers),
-            };
-            return {
-              ...prev,
-              userAnswers: finalAnswers,
-            };
-          }
+        questionDispatch({
+          type: "CONFIRM_ANSWER",
+          currentQuestion,
+          options,
+          isMultiSelect: !!isMultiSelect,
+          questions,
         });
         return;
       }
 
       if (input === " ") {
-        setQuestionState((prev) => {
-          const isOtherFocused =
-            prev.selectedOptionIndex === options.length - 1;
-          if (
-            isMultiSelect &&
-            (!isOtherFocused ||
-              !prev.selectedOptionIndices.has(prev.selectedOptionIndex))
-          ) {
-            const nextIndices = new Set(prev.selectedOptionIndices);
-            if (nextIndices.has(prev.selectedOptionIndex))
-              nextIndices.delete(prev.selectedOptionIndex);
-            else nextIndices.add(prev.selectedOptionIndex);
-            return {
-              ...prev,
-              selectedOptionIndices: nextIndices,
-            };
-          }
-          return prev;
-        });
+        const isOtherFocused =
+          questionState.selectedOptionIndex === options.length - 1;
+        if (
+          isMultiSelect &&
+          (!isOtherFocused ||
+            !questionState.selectedOptionIndices.has(
+              questionState.selectedOptionIndex,
+            ))
+        ) {
+          questionDispatch({
+            type: "TOGGLE_MULTI_SELECT",
+            optionsLength: options.length,
+          });
+          return;
+        }
         // If it's other and focused, we don't return here, allowing the input handler below to handle it
       }
 
       if (key.upArrow) {
-        setQuestionState((prev) => ({
-          ...prev,
-          selectedOptionIndex: Math.max(0, prev.selectedOptionIndex - 1),
-        }));
+        questionDispatch({
+          type: "MOVE_OPTION_UP",
+          maxIndex: options.length - 1,
+        });
         return;
       }
       if (key.downArrow) {
-        setQuestionState((prev) => ({
-          ...prev,
-          selectedOptionIndex: Math.min(
-            options.length - 1,
-            prev.selectedOptionIndex + 1,
-          ),
-        }));
+        questionDispatch({
+          type: "MOVE_OPTION_DOWN",
+          maxIndex: options.length - 1,
+        });
         return;
       }
       if (key.tab) {
-        setQuestionState((prev) => {
-          const direction = key.shift ? -1 : 1;
-          let nextIndex = prev.currentQuestionIndex + direction;
-          if (nextIndex < 0) nextIndex = questions.length - 1;
-          if (nextIndex >= questions.length) nextIndex = 0;
-
-          if (nextIndex === prev.currentQuestionIndex) return prev;
-
-          const savedStates = {
-            ...prev.savedStates,
-            [prev.currentQuestionIndex]: {
-              selectedOptionIndex: prev.selectedOptionIndex,
-              selectedOptionIndices: prev.selectedOptionIndices,
-              otherText: prev.otherText,
-              otherCursorPosition: prev.otherCursorPosition,
-            },
-          };
-
-          const nextState = savedStates[nextIndex] || {
-            selectedOptionIndex: 0,
-            selectedOptionIndices: new Set<number>(),
-            otherText: "",
-            otherCursorPosition: 0,
-          };
-
-          return {
-            ...prev,
-            currentQuestionIndex: nextIndex,
-            ...nextState,
-            savedStates,
-          };
+        questionDispatch({
+          type: "CYCLE_QUESTION",
+          shift: key.shift,
+          questionCount: questions.length,
         });
         return;
       }
 
-      setQuestionState((prev) => {
-        const isOtherFocused = prev.selectedOptionIndex === options.length - 1;
-        if (isOtherFocused) {
-          if (key.leftArrow) {
-            return {
-              ...prev,
-              otherCursorPosition: Math.max(0, prev.otherCursorPosition - 1),
-            };
-          }
-          if (key.rightArrow) {
-            return {
-              ...prev,
-              otherCursorPosition: Math.min(
-                prev.otherText.length,
-                prev.otherCursorPosition + 1,
-              ),
-            };
-          }
-          if (key.backspace || key.delete) {
-            if (prev.otherCursorPosition > 0) {
-              return {
-                ...prev,
-                otherText:
-                  prev.otherText.slice(0, prev.otherCursorPosition - 1) +
-                  prev.otherText.slice(prev.otherCursorPosition),
-                otherCursorPosition: prev.otherCursorPosition - 1,
-              };
-            }
-          }
-          if (input && !key.ctrl && !key.meta) {
-            return {
-              ...prev,
-              otherText:
-                prev.otherText.slice(0, prev.otherCursorPosition) +
-                input +
-                prev.otherText.slice(prev.otherCursorPosition),
-              otherCursorPosition: prev.otherCursorPosition + input.length,
-            };
-          }
-        }
-        return prev;
-      });
+      // Always dispatch Other actions unconditionally; the reducer checks
+      // isOtherFocused from the latest state, so this works correctly even
+      // when inputs are batched before React re-renders.
+      if (key.leftArrow) {
+        questionDispatch({
+          type: "MOVE_OTHER_LEFT",
+          optionsLength: options.length,
+        });
+        return;
+      }
+      if (key.rightArrow) {
+        questionDispatch({
+          type: "MOVE_OTHER_RIGHT",
+          optionsLength: options.length,
+        });
+        return;
+      }
+      if (key.backspace || key.delete) {
+        questionDispatch({
+          type: "DELETE_OTHER",
+          optionsLength: options.length,
+        });
+        return;
+      }
+      if (input && !key.ctrl && !key.meta) {
+        questionDispatch({
+          type: "INSERT_OTHER",
+          text: input,
+          optionsLength: options.length,
+        });
+        return;
+      }
       return;
     }
 
     if (key.return) {
+      let decision: PermissionDecision | null = null;
       if (state.selectedOption === "clear") {
-        onDecision({
+        decision = {
           behavior: "allow",
           newPermissionMode: "acceptEdits",
           clearContext: true,
-        });
+        };
       } else if (state.selectedOption === "allow") {
         if (toolName === EXIT_PLAN_MODE_TOOL_NAME) {
-          onDecision({ behavior: "allow", newPermissionMode: "default" });
+          decision = { behavior: "allow", newPermissionMode: "default" };
         } else if (toolName === ENTER_PLAN_MODE_TOOL_NAME) {
-          onDecision({ behavior: "allow", newPermissionMode: "plan" });
+          decision = { behavior: "allow", newPermissionMode: "plan" };
         } else {
-          onDecision({ behavior: "allow" });
+          decision = { behavior: "allow" };
         }
       } else if (state.selectedOption === "auto") {
         if (toolName === BASH_TOOL_NAME) {
           const command = (toolInput?.command as string) || "";
           if (command.trim().startsWith("mkdir")) {
-            onDecision({ behavior: "allow", newPermissionMode: "acceptEdits" });
+            decision = { behavior: "allow", newPermissionMode: "acceptEdits" };
           } else {
             const rule = suggestedPrefix
               ? `Bash(${suggestedPrefix})`
               : `Bash(${toolInput?.command})`;
-            onDecision({ behavior: "allow", newPermissionRule: rule });
+            decision = { behavior: "allow", newPermissionRule: rule };
           }
         } else if (toolName === ENTER_PLAN_MODE_TOOL_NAME) {
-          onDecision({ behavior: "allow", newPermissionMode: "plan" });
+          decision = { behavior: "allow", newPermissionMode: "plan" };
         } else if (toolName.startsWith("mcp__")) {
-          onDecision({ behavior: "allow", newPermissionRule: toolName });
+          decision = { behavior: "allow", newPermissionRule: toolName };
         } else {
-          onDecision({ behavior: "allow", newPermissionMode: "acceptEdits" });
+          decision = { behavior: "allow", newPermissionMode: "acceptEdits" };
         }
       } else if (state.alternativeText.trim()) {
-        onDecision({ behavior: "deny", message: state.alternativeText.trim() });
+        decision = { behavior: "deny", message: state.alternativeText.trim() };
       } else if (toolName === ENTER_PLAN_MODE_TOOL_NAME) {
-        onDecision({
+        decision = {
           behavior: "deny",
           message: "User chose not to enter plan mode",
-        });
+        };
+      }
+      if (decision) {
+        dispatch({ type: "CONFIRM", decision });
       }
       return;
     }
 
     if (state.selectedOption === "alternative") {
       if (key.leftArrow) {
-        setState((prev) => ({
-          ...prev,
-          alternativeCursorPosition: Math.max(
-            0,
-            prev.alternativeCursorPosition - 1,
-          ),
-        }));
+        dispatch({ type: "MOVE_CURSOR_LEFT" });
         return;
       }
       if (key.rightArrow) {
-        setState((prev) => ({
-          ...prev,
-          alternativeCursorPosition: Math.min(
-            prev.alternativeText.length,
-            prev.alternativeCursorPosition + 1,
-          ),
-        }));
+        dispatch({ type: "MOVE_CURSOR_RIGHT" });
         return;
       }
     }
@@ -420,10 +265,10 @@ export const ConfirmationSelector: React.FC<ConfirmationSelectorProps> = ({
     if (key.upArrow) {
       const currentIndex = availableOptions.indexOf(state.selectedOption);
       if (currentIndex > 0) {
-        setState((prev) => ({
-          ...prev,
-          selectedOption: availableOptions[currentIndex - 1],
-        }));
+        dispatch({
+          type: "SELECT_OPTION",
+          option: availableOptions[currentIndex - 1],
+        });
       }
       return;
     }
@@ -431,10 +276,10 @@ export const ConfirmationSelector: React.FC<ConfirmationSelectorProps> = ({
     if (key.downArrow) {
       const currentIndex = availableOptions.indexOf(state.selectedOption);
       if (currentIndex < availableOptions.length - 1) {
-        setState((prev) => ({
-          ...prev,
-          selectedOption: availableOptions[currentIndex + 1],
-        }));
+        dispatch({
+          type: "SELECT_OPTION",
+          option: availableOptions[currentIndex + 1],
+        });
       }
       return;
     }
@@ -445,47 +290,20 @@ export const ConfirmationSelector: React.FC<ConfirmationSelectorProps> = ({
       let nextIndex = currentIndex + direction;
       if (nextIndex < 0) nextIndex = availableOptions.length - 1;
       if (nextIndex >= availableOptions.length) nextIndex = 0;
-      setState((prev) => ({
-        ...prev,
-        selectedOption: availableOptions[nextIndex],
-      }));
+      dispatch({
+        type: "SELECT_OPTION",
+        option: availableOptions[nextIndex],
+      });
       return;
     }
 
     if (input && !key.ctrl && !key.meta && !("alt" in key && key.alt)) {
-      setState((prev) => {
-        const nextText =
-          prev.alternativeText.slice(0, prev.alternativeCursorPosition) +
-          input +
-          prev.alternativeText.slice(prev.alternativeCursorPosition);
-        return {
-          ...prev,
-          selectedOption: "alternative",
-          alternativeText: nextText,
-          alternativeCursorPosition:
-            prev.alternativeCursorPosition + input.length,
-          hasUserInput: true,
-        };
-      });
+      dispatch({ type: "INSERT_TEXT", text: input });
       return;
     }
 
     if (key.backspace || key.delete) {
-      setState((prev) => {
-        if (prev.alternativeCursorPosition > 0) {
-          const nextText =
-            prev.alternativeText.slice(0, prev.alternativeCursorPosition - 1) +
-            prev.alternativeText.slice(prev.alternativeCursorPosition);
-          return {
-            ...prev,
-            selectedOption: "alternative",
-            alternativeText: nextText,
-            alternativeCursorPosition: prev.alternativeCursorPosition - 1,
-            hasUserInput: nextText.length > 0,
-          };
-        }
-        return prev;
-      });
+      dispatch({ type: "BACKSPACE" });
       return;
     }
   });

package/src/components/MessageList.tsx

@@ -43,23 +43,19 @@ export const MessageList = React.memo(
           b.stage === "streaming" ||
           b.stage === "start")) ||
       (b.type === "bang" && b.stage === "running") ||
-      (b.type === "reasoning" && b.stage === "streaming");
+      (b.type === "reasoning" && b.stage === "streaming") ||
+      (b.type === "text" && b.stage === "streaming");
 
     // Flatten messages into blocks with metadata
-    // Filter out streaming text blocks to avoid frequent height changes,
-    // but allow streaming reasoning blocks (rendered as truncated gray text)
+    // Include streaming text blocks (rendered as truncated gray text)
     const allBlocks = visibleMessages.flatMap((message, messageIndex) => {
-      return message.blocks
-        .filter(
-          (block) => !(block.type === "text" && block.stage === "streaming"),
-        )
-        .map((block, blockIndex) => ({
-          block,
-          message,
-          messageIndex,
-          // Unique key for each block to help Static component
-          key: `${message.id}-${blockIndex}`,
-        }));
+      return message.blocks.map((block, blockIndex) => ({
+        block,
+        message,
+        messageIndex,
+        // Unique key for each block to help Static component
+        key: `${message.id}-${blockIndex}`,
+      }));
     });
 
     // Find message indices that have any running/streaming block

package/src/components/TaskNotificationMessage.tsx

@@ -20,7 +20,7 @@ export const TaskNotificationMessage = ({
   return (
     <Box flexDirection="column">
       <Box>
-        <Text color={color}>● </Text>
+        <Text color={color}>◆ </Text>
         <Text color="white">{block.summary}</Text>
       </Box>
     </Box>

package/src/contexts/useChat.tsx

@@ -613,6 +613,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     if (currentConfirmation) {
       currentConfirmation.reject();
     }
+    agentRef.current?.abortMessage();
     hideConfirmation();
   }, [currentConfirmation, hideConfirmation]);
 
@@ -697,10 +698,8 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     }
 
     // Handle ESC key to cancel confirmation
-    if (key.escape) {
-      if (isConfirmationVisible) {
-        handleConfirmationCancel();
-      }
+    if (key.escape && isConfirmationVisible) {
+      handleConfirmationCancel();
     }
   });
 

package/src/managers/inputHandlers.ts

@@ -297,14 +297,12 @@ export const handlePasteInput = (
     inputString.includes("\r");
 
   if (isPasteOperation) {
-    if (!state.isPasting) {
-      dispatch({
-        type: "START_PASTE",
-        payload: { buffer: inputString, cursorPosition: state.cursorPosition },
-      });
-    } else {
-      dispatch({ type: "APPEND_PASTE_BUFFER", payload: inputString });
-    }
+    // Dispatch a single action type; the reducer determines start vs append
+    // by checking pasteBuffer, avoiding stale state issues
+    dispatch({
+      type: "APPEND_PASTE_CHUNK",
+      payload: { chunk: inputString, cursorPosition: state.cursorPosition },
+    });
   } else {
     let char = inputString;
     if (char === "！" && state.cursorPosition === 0) {