wave-code 0.18.3 → 0.18.4

package/src/components/SessionSelector.tsx

@@ -1,10 +1,15 @@
 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";
+import {
+  selectorReducer,
+  type SelectorState,
+} from "../reducers/selectorReducer.js";
+
+type SessionItem = SessionMetadata & { firstMessage?: string };
 
 export interface SessionSelectorProps {
-  sessions: (SessionMetadata & { firstMessage?: string })[];
+  sessions: SessionItem[];
   onSelect: (sessionId: string) => void;
   onCancel: () => void;
 }
@@ -14,33 +19,38 @@ export const SessionSelector: React.FC<SessionSelectorProps> = ({
   onSelect,
   onCancel,
 }) => {
-  const [state, dispatch] = useReducer(selectorReducer, {
+  const [state, dispatch] = useReducer(selectorReducer<SessionItem>, {
     selectedIndex: 0,
     pendingDecision: null,
-  });
+    items: [],
+  } as SelectorState<SessionItem>);
 
-  const { selectedIndex, pendingDecision } = state;
+  const { selectedIndex, pendingDecision, items } = state;
+
+  // Sync sessions into reducer state
+  useEffect(() => {
+    dispatch({ type: "SET_ITEMS", items: sessions });
+  }, [sessions]);
 
   useInput((_input, key) => {
     dispatch({
       type: "HANDLE_KEY",
       key,
-      maxIndex: sessions.length - 1,
       hasInsert: false,
     });
   });
 
   useEffect(() => {
     if (pendingDecision === "select") {
-      if (sessions.length > 0 && selectedIndex < sessions.length) {
-        onSelect(sessions[selectedIndex].id);
+      if (items.length > 0 && selectedIndex < items.length) {
+        onSelect(items[selectedIndex].id);
       }
       dispatch({ type: "CLEAR_DECISION" });
     } else if (pendingDecision === "cancel") {
       onCancel();
       dispatch({ type: "CLEAR_DECISION" });
     }
-  }, [pendingDecision, selectedIndex, sessions, onSelect, onCancel]);
+  }, [pendingDecision, selectedIndex, items, onSelect, onCancel]);
 
   if (sessions.length === 0) {
     return (

package/src/components/WorktreeExitPrompt.tsx

@@ -1,6 +1,9 @@
 import React, { useReducer, useEffect } from "react";
 import { Box, Text, useInput } from "ink";
-import { selectorReducer } from "../reducers/selectorReducer.js";
+import {
+  selectorReducer,
+  type SelectorState,
+} from "../reducers/selectorReducer.js";
 
 interface WorktreeExitPromptProps {
   name: string;
@@ -21,10 +24,11 @@ export const WorktreeExitPrompt: React.FC<WorktreeExitPromptProps> = ({
   onRemove,
   onCancel,
 }) => {
-  const [state, dispatch] = useReducer(selectorReducer, {
+  const [state, dispatch] = useReducer(selectorReducer<string>, {
     selectedIndex: 0,
     pendingDecision: null,
-  });
+    items: ["keep", "remove"],
+  } as SelectorState<string>);
 
   const { selectedIndex, pendingDecision } = state;
 
@@ -32,7 +36,6 @@ export const WorktreeExitPrompt: React.FC<WorktreeExitPromptProps> = ({
     dispatch({
       type: "HANDLE_KEY",
       key,
-      maxIndex: 1,
       hasInsert: false,
     });
   });

package/src/reducers/questionReducer.ts

@@ -52,11 +52,6 @@ export type QuestionAction =
       type: "HANDLE_KEY";
       input: string;
       key: Key;
-      currentQuestion: {
-        question: string;
-        options: Array<{ label: string }>;
-        multiSelect?: boolean;
-      };
       questions: Array<{
         question: string;
         options: Array<{ label: string }>;
@@ -265,7 +260,8 @@ export function questionReducer(
     case "CLEAR_DECISION":
       return { ...state, decision: null };
     case "HANDLE_KEY": {
-      const { input, key, currentQuestion, questions } = action;
+      const { input, key, questions } = action;
+      const currentQuestion = questions[state.currentQuestionIndex];
       if (!currentQuestion) return state;
 
       const options = [...currentQuestion.options, { label: "Other" }];

package/src/reducers/selectorReducer.ts

@@ -1,31 +1,38 @@
 import { Key } from "ink";
 
-export interface SelectorState {
+export interface SelectorState<T = unknown> {
   selectedIndex: number;
   pendingDecision: "select" | "insert" | "cancel" | null;
+  items: T[];
 }
 
-export type SelectorAction =
+export type SelectorAction<T = unknown> =
   | { type: "MOVE_UP" }
-  | { type: "MOVE_DOWN"; maxIndex: number }
+  | { type: "MOVE_DOWN" }
   | { type: "RESET_INDEX" }
-  | { type: "HANDLE_KEY"; key: Key; maxIndex: number; hasInsert: boolean }
+  | { type: "SET_ITEMS"; items: T[] }
+  | { type: "HANDLE_KEY"; key: Key; hasInsert: boolean }
   | { type: "CLEAR_DECISION" };
 
-export function selectorReducer(
-  state: SelectorState,
-  action: SelectorAction,
-): SelectorState {
+export function selectorReducer<T = unknown>(
+  state: SelectorState<T>,
+  action: SelectorAction<T>,
+): SelectorState<T> {
   switch (action.type) {
     case "MOVE_UP":
       return { ...state, selectedIndex: Math.max(0, state.selectedIndex - 1) };
     case "MOVE_DOWN":
       return {
         ...state,
-        selectedIndex: Math.min(action.maxIndex, state.selectedIndex + 1),
+        selectedIndex: Math.min(
+          state.items.length - 1,
+          state.selectedIndex + 1,
+        ),
       };
     case "RESET_INDEX":
       return { ...state, selectedIndex: 0 };
+    case "SET_ITEMS":
+      return { ...state, items: action.items, selectedIndex: 0 };
     case "HANDLE_KEY":
       if (action.key.upArrow) {
         return {
@@ -36,7 +43,10 @@ export function selectorReducer(
       if (action.key.downArrow) {
         return {
           ...state,
-          selectedIndex: Math.min(action.maxIndex, state.selectedIndex + 1),
+          selectedIndex: Math.min(
+            state.items.length - 1,
+            state.selectedIndex + 1,
+          ),
         };
       }
       if (action.key.return) {