wave-code 0.14.4 → 0.15.1

package/src/components/RewindCommand.tsx

@@ -1,7 +1,8 @@
-import React, { useState } from "react";
+import React, { useState, useReducer, useEffect } from "react";
 import { Box, Text, useInput } from "ink";
 import type { Message } from "wave-agent-sdk";
 import { getMessageContent } from "wave-agent-sdk";
+import { rewindSelectorReducer } from "../reducers/rewindSelectorReducer.js";
 
 export interface RewindCommandProps {
   messages: Message[];
@@ -22,7 +23,7 @@ export const RewindCommand: React.FC<RewindCommandProps> = ({
   const [messages, setMessages] = useState<Message[]>(initialMessages);
   const [isLoading, setIsLoading] = useState(!!getFullMessageThread);
 
-  React.useEffect(() => {
+  useEffect(() => {
     if (getFullMessageThread) {
       getFullMessageThread().then(({ messages: fullMessages }) => {
         setMessages(fullMessages);
@@ -37,48 +38,40 @@ export const RewindCommand: React.FC<RewindCommandProps> = ({
     .filter(({ msg }) => msg.role === "user" && !msg.isMeta);
 
   const MAX_VISIBLE_ITEMS = 3;
-  const [selectedIndex, setSelectedIndex] = useState(checkpoints.length - 1);
+
+  const [state, dispatch] = useReducer(rewindSelectorReducer, {
+    selectedIndex: checkpoints.length - 1,
+    pendingDecision: null,
+  });
+
+  const { selectedIndex, pendingDecision } = state;
 
   // Update selectedIndex when checkpoints change (after loading full thread)
-  React.useEffect(() => {
-    setSelectedIndex(checkpoints.length - 1);
+  useEffect(() => {
+    dispatch({ type: "RESET_INDEX", index: 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,
-  );
+  // Handle decisions from reducer
+  useEffect(() => {
+    if (!pendingDecision) return;
 
-  useInput((input, key) => {
-    if (key.return) {
+    if (pendingDecision === "select") {
       if (checkpoints.length > 0 && selectedIndex >= 0) {
         onSelect(checkpoints[selectedIndex].index);
       }
-      return;
-    }
-
-    if (key.escape) {
+    } else if (pendingDecision === "cancel") {
       onCancel();
-      return;
     }
 
-    if (key.upArrow) {
-      setSelectedIndex(Math.max(0, selectedIndex - 1));
-      return;
-    }
+    dispatch({ type: "CLEAR_DECISION" });
+  }, [pendingDecision, selectedIndex, checkpoints, onSelect, onCancel]);
 
-    if (key.downArrow) {
-      setSelectedIndex(Math.min(checkpoints.length - 1, selectedIndex + 1));
-      return;
-    }
+  useInput((input, key) => {
+    dispatch({
+      type: "HANDLE_KEY",
+      key,
+      maxIndex: checkpoints.length - 1,
+    });
   });
 
   if (isLoading) {
@@ -112,6 +105,19 @@ export const RewindCommand: React.FC<RewindCommandProps> = ({
     );
   }
 
+  // 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,
+  );
+
   return (
     <Box
       flexDirection="column"

package/src/components/SessionSelector.tsx

@@ -1,6 +1,7 @@
-import React, { useState } from "react";
+import React, { useReducer, useEffect } from "react";
 import { Box, Text, useInput } from "ink";
 import type { SessionMetadata } from "wave-agent-sdk";
+import { selectorReducer } from "../reducers/selectorReducer.js";
 
 export interface SessionSelectorProps {
   sessions: (SessionMetadata & { firstMessage?: string })[];
@@ -13,31 +14,33 @@ export const SessionSelector: React.FC<SessionSelectorProps> = ({
   onSelect,
   onCancel,
 }) => {
-  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [state, dispatch] = useReducer(selectorReducer, {
+    selectedIndex: 0,
+    pendingDecision: null,
+  });
+
+  const { selectedIndex, pendingDecision } = state;
+
+  useInput((_input, key) => {
+    dispatch({
+      type: "HANDLE_KEY",
+      key,
+      maxIndex: sessions.length - 1,
+      hasInsert: false,
+    });
+  });
 
-  useInput((input, key) => {
-    if (key.return) {
+  useEffect(() => {
+    if (pendingDecision === "select") {
       if (sessions.length > 0 && selectedIndex < sessions.length) {
         onSelect(sessions[selectedIndex].id);
       }
-      return;
-    }
-
-    if (key.escape) {
+      dispatch({ type: "CLEAR_DECISION" });
+    } else if (pendingDecision === "cancel") {
       onCancel();
-      return;
+      dispatch({ type: "CLEAR_DECISION" });
     }
-
-    if (key.upArrow) {
-      setSelectedIndex(Math.max(0, selectedIndex - 1));
-      return;
-    }
-
-    if (key.downArrow) {
-      setSelectedIndex(Math.min(sessions.length - 1, selectedIndex + 1));
-      return;
-    }
-  });
+  }, [pendingDecision, selectedIndex, sessions, onSelect, onCancel]);
 
   if (sessions.length === 0) {
     return (

package/src/components/StatusLine.tsx

@@ -25,7 +25,16 @@ export const StatusLine: React.FC<StatusLineProps> = ({
       ) : (
         <Text color="gray">
           Mode:{" "}
-          <Text color={permissionMode === "plan" ? "yellow" : "cyan"}>
+          <Text
+            color={
+              permissionMode === "plan"
+                ? "yellow"
+                : permissionMode === "bypassPermissions"
+                  ? "red"
+                  : "cyan"
+            }
+            bold={permissionMode === "bypassPermissions"}
+          >
             {permissionMode}
           </Text>{" "}
           (Shift+Tab to cycle)

package/src/components/WorktreeExitPrompt.tsx

@@ -1,5 +1,6 @@
-import React, { useState } from "react";
+import React, { useReducer, useEffect } from "react";
 import { Box, Text, useInput } from "ink";
+import { selectorReducer } from "../reducers/selectorReducer.js";
 
 interface WorktreeExitPromptProps {
   name: string;
@@ -20,26 +21,35 @@ export const WorktreeExitPrompt: React.FC<WorktreeExitPromptProps> = ({
   onRemove,
   onCancel,
 }) => {
-  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [state, dispatch] = useReducer(selectorReducer, {
+    selectedIndex: 0,
+    pendingDecision: null,
+  });
 
-  useInput((input, key) => {
-    if (key.upArrow) {
-      setSelectedIndex((prev) => (prev === 0 ? 1 : 0));
-    }
-    if (key.downArrow) {
-      setSelectedIndex((prev) => (prev === 1 ? 0 : 1));
-    }
-    if (key.return) {
+  const { selectedIndex, pendingDecision } = state;
+
+  useInput((_input, key) => {
+    dispatch({
+      type: "HANDLE_KEY",
+      key,
+      maxIndex: 1,
+      hasInsert: false,
+    });
+  });
+
+  useEffect(() => {
+    if (pendingDecision === "select") {
       if (selectedIndex === 0) {
         onKeep();
       } else {
         onRemove();
       }
-    }
-    if (key.escape) {
+      dispatch({ type: "CLEAR_DECISION" });
+    } else if (pendingDecision === "cancel") {
       onCancel();
+      dispatch({ type: "CLEAR_DECISION" });
     }
-  });
+  }, [pendingDecision, selectedIndex, onKeep, onRemove, onCancel]);
 
   return (
     <Box flexDirection="column" paddingX={1} marginY={1}>

package/src/contexts/useChat.tsx

@@ -24,6 +24,7 @@ import {
   AgentCallbacks,
   type ToolPermissionContext,
   OPERATION_CANCELLED_BY_USER,
+  extractLatestTotalTokens,
 } from "wave-agent-sdk";
 import { logger } from "../utils/logger.js";
 import { throttle } from "../utils/throttle.js";
@@ -79,7 +80,6 @@ export interface ChatContextType {
   // Permission functionality
   permissionMode: PermissionMode;
   setPermissionMode: (mode: PermissionMode) => void;
-  allowBypassInCycle: boolean;
   // Permission confirmation state
   isConfirmationVisible: boolean;
   hasPendingConfirmations: boolean;
@@ -158,28 +158,19 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   const [isTaskListVisible, setIsTaskListVisible] = useState(true);
 
   const [messages, setMessages] = useState<Message[]>([]);
+  const [latestTotalTokens, setLatestTotalTokens] = useState(0);
 
   const throttledSetMessages = useMemo(
     () =>
       throttle(
         () => {
           if (!isExpandedRef.current && agentRef.current) {
-            setMessages([...agentRef.current.messages]);
+            const msgs = [...agentRef.current.messages];
+            setMessages(msgs);
+            setLatestTotalTokens(extractLatestTotalTokens(msgs));
           }
         },
-        300,
-        { leading: true, trailing: true },
-      ),
-    [],
-  );
-
-  const throttledSetTokens = useMemo(
-    () =>
-      throttle(
-        ((tokens: number) => {
-          setlatestTotalTokens(tokens);
-        }) as (...args: unknown[]) => void,
-        300,
+        500,
         { leading: true, trailing: true },
       ),
     [],
@@ -189,19 +180,16 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     isExpandedRef.current = isExpanded;
     if (isExpanded) {
       throttledSetMessages.cancel();
-      throttledSetTokens.cancel();
     }
-  }, [isExpanded, throttledSetMessages, throttledSetTokens]);
+  }, [isExpanded, throttledSetMessages]);
 
   useEffect(() => {
     return () => {
       throttledSetMessages.cancel();
-      throttledSetTokens.cancel();
     };
-  }, [throttledSetMessages, throttledSetTokens]);
+  }, [throttledSetMessages]);
 
   const [isLoading, setIsLoading] = useState(false);
-  const [latestTotalTokens, setlatestTotalTokens] = useState(0);
   const [sessionId, setSessionId] = useState("");
   const [isCommandRunning, setIsCommandRunning] = useState(false);
   const [isCompacting, setIsCompacting] = useState(false);
@@ -301,9 +289,6 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   // Status metadata state
   const [workingDirectory, setWorkingDirectory] = useState("");
 
-  const allowBypassInCycle =
-    !!bypassPermissions || initialPermissionMode === "bypassPermissions";
-
   const agentRef = useRef<Agent | null>(null);
 
   // Permission confirmation methods with queue support
@@ -349,9 +334,6 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         onSessionIdChange: (sessionId) => {
           setSessionId(sessionId);
         },
-        onLatestTotalTokensChange: (tokens) => {
-          throttledSetTokens(tokens);
-        },
         onCompactionStateChange: (isCompactingState) => {
           setIsCompacting(isCompactingState);
         },
@@ -429,7 +411,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         setSessionId(agent.sessionId);
         setMessages(agent.messages);
         setIsLoading(agent.isLoading);
-        setlatestTotalTokens(agent.latestTotalTokens);
+        setLatestTotalTokens(extractLatestTotalTokens(agent.messages));
         setIsCommandRunning(agent.isCommandRunning);
         setIsCompacting(agent.isCompacting);
         setPermissionModeState(agent.getPermissionMode());
@@ -462,7 +444,6 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
       model,
       initialPermissionMode,
       throttledSetMessages,
-      throttledSetTokens,
     ],
   );
 
@@ -482,7 +463,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     setSlashCommands([]);
     setSessionId("");
     setIsLoading(false);
-    setlatestTotalTokens(0);
+    setLatestTotalTokens(0);
     setIsCommandRunning(false);
     setIsCompacting(false);
     if (currentSessionId) {
@@ -719,7 +700,9 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
       } else {
         // Transitioning to COLLAPSED: Restore from agent's actual state
         if (agentRef.current) {
-          setMessages([...agentRef.current.messages]);
+          const msgs = [...agentRef.current.messages];
+          setMessages(msgs);
+          setLatestTotalTokens(extractLatestTotalTokens(msgs));
         }
       }
       // Force remount to re-render Static items with new isExpanded state
@@ -765,7 +748,6 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     hasSlashCommand,
     permissionMode,
     setPermissionMode,
-    allowBypassInCycle,
     isConfirmationVisible,
     hasPendingConfirmations: confirmationQueue.length > 0,
     confirmingTool,