wave-code 0.18.3 → 0.18.5

package/src/components/MarketplaceView.tsx

@@ -1,18 +1,28 @@
 import React, { useReducer, useEffect } from "react";
 import { Box, Text, useInput } from "ink";
+import type { KnownMarketplace } from "wave-agent-sdk";
 import { usePluginManagerContext } from "../contexts/PluginManagerContext.js";
-import { selectorReducer } from "../reducers/selectorReducer.js";
+import {
+  selectorReducer,
+  type SelectorState,
+} from "../reducers/selectorReducer.js";
 
 import { MarketplaceList } from "./MarketplaceList.js";
 
 export const MarketplaceView: React.FC = () => {
   const { marketplaces, actions } = usePluginManagerContext();
-  const [state, dispatch] = useReducer(selectorReducer, {
+  const [state, dispatch] = useReducer(selectorReducer<KnownMarketplace>, {
     selectedIndex: 0,
     pendingDecision: null,
-  });
+    items: [],
+  } as SelectorState<KnownMarketplace>);
+
+  const { selectedIndex, pendingDecision, items } = state;
 
-  const { selectedIndex, pendingDecision } = state;
+  // Sync marketplaces into reducer state
+  useEffect(() => {
+    dispatch({ type: "SET_ITEMS", items: marketplaces });
+  }, [marketplaces]);
 
   useInput((input, key) => {
     if (input === "a") {
@@ -23,21 +33,20 @@ export const MarketplaceView: React.FC = () => {
     dispatch({
       type: "HANDLE_KEY",
       key,
-      maxIndex: marketplaces.length - 1,
       hasInsert: false,
     });
   });
 
   useEffect(() => {
     if (pendingDecision === "select") {
-      const mk = marketplaces[selectedIndex];
+      const mk = items[selectedIndex];
       if (mk) {
         actions.setSelectedId(mk.name);
         actions.setView("MARKETPLACE_DETAIL");
       }
       dispatch({ type: "CLEAR_DECISION" });
     }
-  }, [pendingDecision, selectedIndex, marketplaces, actions]);
+  }, [pendingDecision, selectedIndex, items, actions]);
 
   return (
     <Box flexDirection="column">

package/src/components/ModelSelector.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";
 
 export interface ModelSelectorProps {
   onCancel: () => void;
@@ -17,29 +20,29 @@ export const ModelSelector: React.FC<ModelSelectorProps> = ({
   configuredModels,
   onSelectModel,
 }) => {
-  const [state, dispatch] = useReducer(selectorReducer, {
+  const [state, dispatch] = useReducer(selectorReducer<string>, {
     selectedIndex:
       configuredModels.indexOf(currentModel) !== -1
         ? configuredModels.indexOf(currentModel)
         : 0,
     pendingDecision: null,
-  });
+    items: configuredModels,
+  } as SelectorState<string>);
 
-  const { selectedIndex, pendingDecision } = state;
+  const { selectedIndex, pendingDecision, items: models } = state;
 
   useInput((_input, key) => {
     dispatch({
       type: "HANDLE_KEY",
       key,
-      maxIndex: configuredModels.length - 1,
       hasInsert: false,
     });
   });
 
   useEffect(() => {
     if (pendingDecision === "select") {
-      if (configuredModels.length > 0) {
-        onSelectModel(configuredModels[selectedIndex]);
+      if (models.length > 0) {
+        onSelectModel(models[selectedIndex]);
       }
       onCancel();
       dispatch({ type: "CLEAR_DECISION" });
@@ -47,23 +50,17 @@ export const ModelSelector: React.FC<ModelSelectorProps> = ({
       onCancel();
       dispatch({ type: "CLEAR_DECISION" });
     }
-  }, [
-    pendingDecision,
-    selectedIndex,
-    configuredModels,
-    onSelectModel,
-    onCancel,
-  ]);
+  }, [pendingDecision, selectedIndex, models, onSelectModel, onCancel]);
 
   // Calculate visible window
   const startIndex = Math.max(
     0,
     Math.min(
       selectedIndex - Math.floor(MAX_VISIBLE_ITEMS / 2),
-      Math.max(0, configuredModels.length - MAX_VISIBLE_ITEMS),
+      Math.max(0, models.length - MAX_VISIBLE_ITEMS),
     ),
   );
-  const visibleModels = configuredModels.slice(
+  const visibleModels = models.slice(
     startIndex,
     startIndex + MAX_VISIBLE_ITEMS,
   );

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) {

package/src/utils/worktree.ts

@@ -1,4 +1,4 @@
-import { execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import * as path from "node:path";
 import * as fs from "node:fs";
 import { getDefaultRemoteBranch, getGitMainRepoRoot } from "wave-agent-sdk";
@@ -47,8 +47,9 @@ export function createWorktree(name: string, cwd: string): WorktreeSession {
 
   try {
     // Create worktree and branch
-    execSync(
-      `git worktree add -b ${branchName} "${worktreePath}" ${baseBranch}`,
+    execFileSync(
+      "git",
+      ["worktree", "add", "-b", branchName, worktreePath, baseBranch],
       {
         cwd: repoRoot,
         stdio: ["ignore", "pipe", "pipe"],
@@ -69,7 +70,7 @@ export function createWorktree(name: string, cwd: string): WorktreeSession {
     if (stderr.includes("already exists")) {
       // If branch already exists, try to add worktree without -b
       try {
-        execSync(`git worktree add "${worktreePath}" ${branchName}`, {
+        execFileSync("git", ["worktree", "add", worktreePath, branchName], {
           cwd: repoRoot,
           stdio: ["ignore", "pipe", "pipe"],
         });
@@ -95,12 +96,13 @@ export function createWorktree(name: string, cwd: string): WorktreeSession {
       // Base branch not fetched yet — try fetching then retrying
       const branchNameOnly = baseBranch.split("/").pop()!;
       try {
-        execSync(`git fetch origin ${branchNameOnly}`, {
+        execFileSync("git", ["fetch", "origin", branchNameOnly], {
           cwd: repoRoot,
           stdio: ["ignore", "pipe", "pipe"],
         });
-        execSync(
-          `git worktree add -b ${branchName} "${worktreePath}" ${baseBranch}`,
+        execFileSync(
+          "git",
+          ["worktree", "add", "-b", branchName, worktreePath, baseBranch],
           {
             cwd: repoRoot,
             stdio: ["ignore", "pipe", "pipe"],
@@ -118,10 +120,14 @@ export function createWorktree(name: string, cwd: string): WorktreeSession {
       } catch {
         // Fetch or retry failed — fall back to HEAD
         try {
-          execSync(`git worktree add -b ${branchName} "${worktreePath}" HEAD`, {
-            cwd: repoRoot,
-            stdio: ["ignore", "pipe", "pipe"],
-          });
+          execFileSync(
+            "git",
+            ["worktree", "add", "-b", branchName, worktreePath, "HEAD"],
+            {
+              cwd: repoRoot,
+              stdio: ["ignore", "pipe", "pipe"],
+            },
+          );
           return {
             name,
             path: worktreePath,
@@ -155,24 +161,28 @@ export function removeWorktree(session: WorktreeSession): void {
     // Get current branch in worktree before removing it
     let currentBranch: string | undefined;
     try {
-      currentBranch = execSync(`git rev-parse --abbrev-ref HEAD`, {
-        cwd: session.path,
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-      }).trim();
+      currentBranch = execFileSync(
+        "git",
+        ["rev-parse", "--abbrev-ref", "HEAD"],
+        {
+          cwd: session.path,
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "ignore"],
+        },
+      ).trim();
     } catch {
       // Ignore errors getting current branch
     }
 
     // Remove worktree
-    execSync(`git worktree remove --force "${session.path}"`, {
+    execFileSync("git", ["worktree", "remove", "--force", session.path], {
       cwd: repoRoot,
       stdio: ["ignore", "pipe", "pipe"],
     });
 
     // Delete original branch
     try {
-      execSync(`git branch -D ${session.branch}`, {
+      execFileSync("git", ["branch", "-D", session.branch], {
         cwd: repoRoot,
         stdio: ["ignore", "pipe", "pipe"],
       });
@@ -195,7 +205,7 @@ export function removeWorktree(session: WorktreeSession): void {
         currentBranch !== "master"
       ) {
         try {
-          execSync(`git branch -D ${currentBranch}`, {
+          execFileSync("git", ["branch", "-D", currentBranch], {
             cwd: repoRoot,
             stdio: ["ignore", "pipe", "pipe"],
           });