wave-code 0.14.4 → 0.15.1

package/src/print-cli.ts

@@ -71,18 +71,21 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
       isReasoning = false;
       isContent = false;
       // Assistant message started - no content to output yet
-      process.stdout.write("\n");
     },
     onAssistantReasoningUpdated: (chunk: string) => {
       if (!isReasoning) {
-        process.stdout.write("💭 Reasoning:\n");
+        process.stdout.write("\n💭 Reasoning:\n");
         isReasoning = true;
       }
       process.stdout.write(chunk);
     },
     onAssistantContentUpdated: (chunk: string) => {
-      if (isReasoning && !isContent) {
-        process.stdout.write("\n\n📝 Response:\n");
+      if (!isContent) {
+        if (isReasoning) {
+          process.stdout.write("\n\n📝 Response:\n");
+        } else {
+          process.stdout.write("\n");
+        }
         isContent = true;
       }
       // FR-001: Stream content updates for real-time display - output only the new chunk
@@ -93,24 +96,24 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
     onSubagentAssistantMessageAdded: (subagentId: string) => {
       subagentReasoningStates.set(subagentId, false);
       subagentContentStates.set(subagentId, false);
-      process.stdout.write("\n   ");
     },
     onSubagentAssistantReasoningUpdated: (
       subagentId: string,
       chunk: string,
     ) => {
       if (!subagentReasoningStates.get(subagentId)) {
-        process.stdout.write("💭 Reasoning: ");
+        process.stdout.write("\n   💭 Reasoning: ");
         subagentReasoningStates.set(subagentId, true);
       }
       process.stdout.write(chunk);
     },
     onSubagentAssistantContentUpdated: (subagentId: string, chunk: string) => {
-      if (
-        subagentReasoningStates.get(subagentId) &&
-        !subagentContentStates.get(subagentId)
-      ) {
-        process.stdout.write("\n   📝 Response: ");
+      if (!subagentContentStates.get(subagentId)) {
+        if (subagentReasoningStates.get(subagentId)) {
+          process.stdout.write("\n   📝 Response: ");
+        } else {
+          process.stdout.write("\n   ");
+        }
         subagentContentStates.set(subagentId, true);
       }
       process.stdout.write(chunk);
@@ -161,6 +164,12 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
     // Send message if provided and not empty
     if (typeof message === "string" && message.trim() !== "") {
       await agent.sendMessage(message);
+      process.stdout.write("\n");
+    }
+
+    // Wait for running background tasks and subagents to complete
+    while (agent.hasRunningBackgroundWork) {
+      await new Promise((resolve) => setTimeout(resolve, 500));
     }
 
     // Display usage summary before exit

package/src/reducers/backgroundTaskManagerReducer.ts

@@ -1,3 +1,5 @@
+import { Key } from "ink";
+
 export interface Task {
   id: string;
   type: string;
@@ -16,21 +18,31 @@ export interface DetailOutput {
   outputPath?: string;
 }
 
+export type PendingEffect =
+  | { type: "CANCEL" }
+  | { type: "STOP_TASK"; taskId: string };
+
 export interface BackgroundTaskManagerState {
   tasks: Task[];
   selectedIndex: number;
   viewMode: "list" | "detail";
   detailTaskId: string | null;
   detailOutput: DetailOutput | null;
+  pendingEffect: PendingEffect | null;
 }
 
 export type BackgroundTaskManagerAction =
   | { type: "SET_TASKS"; tasks: Task[] }
   | { type: "SELECT_INDEX"; index: number }
+  | { type: "MOVE_UP" }
+  | { type: "MOVE_DOWN" }
+  | { type: "SELECT_CURRENT" }
   | { type: "SET_VIEW_MODE"; mode: "list" | "detail" }
   | { type: "SET_DETAIL_TASK_ID"; id: string | null }
   | { type: "SET_DETAIL_OUTPUT"; output: DetailOutput | null }
-  | { type: "RESET_DETAIL" };
+  | { type: "RESET_DETAIL" }
+  | { type: "HANDLE_KEY"; input: string; key: Key }
+  | { type: "CLEAR_PENDING_EFFECT" };
 
 export function backgroundTaskManagerReducer(
   state: BackgroundTaskManagerState,
@@ -41,6 +53,25 @@ export function backgroundTaskManagerReducer(
       return { ...state, tasks: action.tasks };
     case "SELECT_INDEX":
       return { ...state, selectedIndex: action.index };
+    case "MOVE_UP":
+      return { ...state, selectedIndex: Math.max(0, state.selectedIndex - 1) };
+    case "MOVE_DOWN":
+      return {
+        ...state,
+        selectedIndex: Math.min(
+          state.tasks.length > 0 ? state.tasks.length - 1 : 0,
+          state.selectedIndex + 1,
+        ),
+      };
+    case "SELECT_CURRENT":
+      if (state.tasks.length > 0 && state.selectedIndex < state.tasks.length) {
+        return {
+          ...state,
+          detailTaskId: state.tasks[state.selectedIndex].id,
+          viewMode: "detail",
+        };
+      }
+      return state;
     case "SET_VIEW_MODE":
       return { ...state, viewMode: action.mode };
     case "SET_DETAIL_TASK_ID":
@@ -54,6 +85,84 @@ export function backgroundTaskManagerReducer(
         detailTaskId: null,
         detailOutput: null,
       };
+    case "HANDLE_KEY": {
+      const { input, key } = action;
+      if (state.viewMode === "list") {
+        if (key.return) {
+          if (
+            state.tasks.length > 0 &&
+            state.selectedIndex < state.tasks.length
+          ) {
+            return {
+              ...state,
+              detailTaskId: state.tasks[state.selectedIndex].id,
+              viewMode: "detail",
+            };
+          }
+          return state;
+        }
+
+        if (key.escape) {
+          return { ...state, pendingEffect: { type: "CANCEL" } };
+        }
+
+        if (key.upArrow) {
+          return {
+            ...state,
+            selectedIndex: Math.max(0, state.selectedIndex - 1),
+          };
+        }
+
+        if (key.downArrow) {
+          return {
+            ...state,
+            selectedIndex: Math.min(
+              state.tasks.length > 0 ? state.tasks.length - 1 : 0,
+              state.selectedIndex + 1,
+            ),
+          };
+        }
+
+        if (input === "k") {
+          if (
+            state.tasks.length > 0 &&
+            state.selectedIndex < state.tasks.length
+          ) {
+            const selectedTask = state.tasks[state.selectedIndex];
+            if (selectedTask.status === "running") {
+              return {
+                ...state,
+                pendingEffect: { type: "STOP_TASK", taskId: selectedTask.id },
+              };
+            }
+          }
+          return state;
+        }
+      } else if (state.viewMode === "detail") {
+        if (key.escape) {
+          return {
+            ...state,
+            viewMode: "list",
+            detailTaskId: null,
+            detailOutput: null,
+          };
+        }
+
+        if (input === "k" && state.detailTaskId) {
+          const task = state.tasks.find((t) => t.id === state.detailTaskId);
+          if (task && task.status === "running") {
+            return {
+              ...state,
+              pendingEffect: { type: "STOP_TASK", taskId: state.detailTaskId },
+            };
+          }
+          return state;
+        }
+      }
+      return state;
+    }
+    case "CLEAR_PENDING_EFFECT":
+      return { ...state, pendingEffect: null };
     default:
       return state;
   }

package/src/reducers/confirmationReducer.ts

@@ -1,4 +1,10 @@
+import { Key } from "ink";
 import type { PermissionDecision } from "wave-agent-sdk";
+import {
+  BASH_TOOL_NAME,
+  EXIT_PLAN_MODE_TOOL_NAME,
+  ENTER_PLAN_MODE_TOOL_NAME,
+} from "wave-agent-sdk";
 
 export interface ConfirmationState {
   selectedOption: "clear" | "auto" | "allow" | "alternative";
@@ -14,7 +20,17 @@ export type ConfirmationAction =
   | { type: "BACKSPACE" }
   | { type: "MOVE_CURSOR_LEFT" }
   | { type: "MOVE_CURSOR_RIGHT" }
-  | { type: "CONFIRM"; decision: PermissionDecision };
+  | { type: "CONFIRM"; decision: PermissionDecision }
+  | { type: "CLEAR_DECISION" }
+  | {
+      type: "HANDLE_KEY";
+      input: string;
+      key: Key;
+      toolName: string;
+      toolInput?: Record<string, unknown>;
+      suggestedPrefix?: string;
+      hidePersistentOption?: boolean;
+    };
 
 export function confirmationReducer(
   state: ConfirmationState,
@@ -68,6 +84,162 @@ export function confirmationReducer(
       };
     case "CONFIRM":
       return { ...state, decision: action.decision };
+    case "CLEAR_DECISION":
+      return { ...state, decision: null };
+    case "HANDLE_KEY": {
+      const {
+        input,
+        key,
+        toolName,
+        toolInput,
+        suggestedPrefix,
+        hidePersistentOption,
+      } = action;
+
+      if (key.return) {
+        let decision: PermissionDecision | null = null;
+        if (state.selectedOption === "clear") {
+          decision = {
+            behavior: "allow",
+            newPermissionMode: "acceptEdits",
+            clearContext: true,
+          };
+        } else if (state.selectedOption === "allow") {
+          if (toolName === EXIT_PLAN_MODE_TOOL_NAME) {
+            decision = { behavior: "allow", newPermissionMode: "default" };
+          } else if (toolName === ENTER_PLAN_MODE_TOOL_NAME) {
+            decision = { behavior: "allow", newPermissionMode: "plan" };
+          } else {
+            decision = { behavior: "allow" };
+          }
+        } else if (state.selectedOption === "auto") {
+          if (toolName === BASH_TOOL_NAME) {
+            const command = (toolInput?.command as string) || "";
+            if (command.trim().startsWith("mkdir")) {
+              decision = {
+                behavior: "allow",
+                newPermissionMode: "acceptEdits",
+              };
+            } else {
+              const rule = suggestedPrefix
+                ? `Bash(${suggestedPrefix})`
+                : `Bash(${toolInput?.command})`;
+              decision = { behavior: "allow", newPermissionRule: rule };
+            }
+          } else if (toolName === ENTER_PLAN_MODE_TOOL_NAME) {
+            decision = { behavior: "allow", newPermissionMode: "plan" };
+          } else if (toolName.startsWith("mcp__")) {
+            decision = { behavior: "allow", newPermissionRule: toolName };
+          } else {
+            decision = { behavior: "allow", newPermissionMode: "acceptEdits" };
+          }
+        } else if (state.alternativeText.trim()) {
+          decision = {
+            behavior: "deny",
+            message: state.alternativeText.trim(),
+          };
+        } else if (toolName === ENTER_PLAN_MODE_TOOL_NAME) {
+          decision = {
+            behavior: "deny",
+            message: "User chose not to enter plan mode",
+          };
+        }
+
+        if (decision) {
+          return { ...state, decision };
+        }
+        return state;
+      }
+
+      if (state.selectedOption === "alternative") {
+        if (key.leftArrow) {
+          return {
+            ...state,
+            alternativeCursorPosition: Math.max(
+              0,
+              state.alternativeCursorPosition - 1,
+            ),
+          };
+        }
+        if (key.rightArrow) {
+          return {
+            ...state,
+            alternativeCursorPosition: Math.min(
+              state.alternativeText.length,
+              state.alternativeCursorPosition + 1,
+            ),
+          };
+        }
+      }
+
+      const availableOptions: ConfirmationState["selectedOption"][] = [];
+      if (toolName === EXIT_PLAN_MODE_TOOL_NAME) availableOptions.push("clear");
+      availableOptions.push("allow");
+      if (!hidePersistentOption) availableOptions.push("auto");
+      availableOptions.push("alternative");
+
+      if (key.upArrow) {
+        const currentIndex = availableOptions.indexOf(state.selectedOption);
+        if (currentIndex > 0) {
+          return {
+            ...state,
+            selectedOption: availableOptions[currentIndex - 1],
+          };
+        }
+        return state;
+      }
+
+      if (key.downArrow) {
+        const currentIndex = availableOptions.indexOf(state.selectedOption);
+        if (currentIndex < availableOptions.length - 1) {
+          return {
+            ...state,
+            selectedOption: availableOptions[currentIndex + 1],
+          };
+        }
+        return state;
+      }
+
+      if (key.tab) {
+        const currentIndex = availableOptions.indexOf(state.selectedOption);
+        const direction = key.shift ? -1 : 1;
+        let nextIndex = currentIndex + direction;
+        if (nextIndex < 0) nextIndex = availableOptions.length - 1;
+        if (nextIndex >= availableOptions.length) nextIndex = 0;
+        return { ...state, selectedOption: availableOptions[nextIndex] };
+      }
+
+      if (input && !key.ctrl && !key.meta && !("alt" in key && key.alt)) {
+        const nextText =
+          state.alternativeText.slice(0, state.alternativeCursorPosition) +
+          input +
+          state.alternativeText.slice(state.alternativeCursorPosition);
+        return {
+          ...state,
+          selectedOption: "alternative",
+          alternativeText: nextText,
+          alternativeCursorPosition:
+            state.alternativeCursorPosition + input.length,
+          hasUserInput: true,
+        };
+      }
+
+      if (key.backspace || key.delete) {
+        if (state.alternativeCursorPosition <= 0) return state;
+        const nextText =
+          state.alternativeText.slice(0, state.alternativeCursorPosition - 1) +
+          state.alternativeText.slice(state.alternativeCursorPosition);
+        return {
+          ...state,
+          selectedOption: "alternative",
+          alternativeText: nextText,
+          alternativeCursorPosition: state.alternativeCursorPosition - 1,
+          hasUserInput: nextText.length > 0,
+        };
+      }
+
+      return state;
+    }
     default:
       return state;
   }

package/src/reducers/helpSelectorReducer.ts

@@ -0,0 +1,77 @@
+import { Key } from "ink";
+
+export interface SelectorState {
+  selectedIndex: number;
+  activeTab: "general" | "commands" | "custom-commands";
+  pendingDecision: "select" | "insert" | "cancel" | "tab-switch" | null;
+}
+
+export type SelectorAction =
+  | { type: "MOVE_UP" }
+  | { type: "MOVE_DOWN"; maxIndex: number }
+  | { type: "RESET_INDEX" }
+  | { type: "SWITCH_TAB"; tabs: string[] }
+  | { type: "HANDLE_KEY"; key: Key; maxIndex: number; tabs: string[] }
+  | { type: "CLEAR_DECISION" };
+
+export function helpSelectorReducer(
+  state: SelectorState,
+  action: SelectorAction,
+): SelectorState {
+  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),
+      };
+    case "RESET_INDEX":
+      return { ...state, selectedIndex: 0 };
+    case "SWITCH_TAB": {
+      const currentIndex = action.tabs.indexOf(state.activeTab);
+      const nextIndex = (currentIndex + 1) % action.tabs.length;
+      return {
+        ...state,
+        activeTab: action.tabs[nextIndex] as
+          | "general"
+          | "commands"
+          | "custom-commands",
+        selectedIndex: 0,
+      };
+    }
+    case "HANDLE_KEY":
+      if (action.key.upArrow) {
+        return {
+          ...state,
+          selectedIndex: Math.max(0, state.selectedIndex - 1),
+        };
+      }
+      if (action.key.downArrow) {
+        return {
+          ...state,
+          selectedIndex: Math.min(action.maxIndex, state.selectedIndex + 1),
+        };
+      }
+      if (action.key.tab) {
+        const currentIndex = action.tabs.indexOf(state.activeTab);
+        const nextIndex = (currentIndex + 1) % action.tabs.length;
+        return {
+          ...state,
+          activeTab: action.tabs[nextIndex] as
+            | "general"
+            | "commands"
+            | "custom-commands",
+          selectedIndex: 0,
+        };
+      }
+      if (action.key.escape) {
+        return { ...state, pendingDecision: "cancel" };
+      }
+      return state;
+    case "CLEAR_DECISION":
+      return { ...state, pendingDecision: null };
+    default:
+      return state;
+  }
+}

package/src/reducers/mcpManagerReducer.ts

@@ -1,12 +1,28 @@
+import { Key } from "ink";
+
+export type PendingEffect =
+  | { type: "CANCEL" }
+  | { type: "CONNECT_SERVER"; serverName: string }
+  | { type: "DISCONNECT_SERVER"; serverName: string };
+
 export interface McpManagerState {
   selectedIndex: number;
   viewMode: "list" | "detail";
+  pendingEffect: PendingEffect | null;
 }
 
 export type McpManagerAction =
   | { type: "MOVE_UP"; serverCount: number }
   | { type: "MOVE_DOWN"; serverCount: number }
-  | { type: "SET_VIEW_MODE"; viewMode: "list" | "detail" };
+  | { type: "SET_VIEW_MODE"; viewMode: "list" | "detail" }
+  | {
+      type: "HANDLE_KEY";
+      input: string;
+      key: Key;
+      serverCount: number;
+      servers: Array<{ name: string; status: string }>;
+    }
+  | { type: "CLEAR_PENDING_EFFECT" };
 
 export function mcpManagerReducer(
   state: McpManagerState,
@@ -25,6 +41,71 @@ export function mcpManagerReducer(
       };
     case "SET_VIEW_MODE":
       return { ...state, viewMode: action.viewMode };
+    case "HANDLE_KEY": {
+      const { input, key, serverCount, servers } = action;
+
+      if (key.return) {
+        if (state.viewMode === "list") {
+          return { ...state, viewMode: "detail" };
+        }
+        return state;
+      }
+
+      if (key.escape) {
+        if (state.viewMode === "detail") {
+          return { ...state, viewMode: "list" };
+        } else {
+          return { ...state, pendingEffect: { type: "CANCEL" } };
+        }
+      }
+
+      if (key.upArrow) {
+        return {
+          ...state,
+          selectedIndex: Math.max(0, state.selectedIndex - 1),
+        };
+      }
+
+      if (key.downArrow) {
+        return {
+          ...state,
+          selectedIndex: Math.min(serverCount - 1, state.selectedIndex + 1),
+        };
+      }
+
+      // Hotkeys for server actions
+      if (input === "c") {
+        const server = servers[state.selectedIndex];
+        if (
+          server &&
+          (server.status === "disconnected" || server.status === "error")
+        ) {
+          return {
+            ...state,
+            pendingEffect: { type: "CONNECT_SERVER", serverName: server.name },
+          };
+        }
+        return state;
+      }
+
+      if (input === "d") {
+        const server = servers[state.selectedIndex];
+        if (server && server.status === "connected") {
+          return {
+            ...state,
+            pendingEffect: {
+              type: "DISCONNECT_SERVER",
+              serverName: server.name,
+            },
+          };
+        }
+        return state;
+      }
+
+      return state;
+    }
+    case "CLEAR_PENDING_EFFECT":
+      return { ...state, pendingEffect: null };
     default:
       return state;
   }

package/src/reducers/pluginDetailReducer.ts

@@ -1,6 +1,9 @@
+import { Key } from "ink";
+
 export interface PluginDetailState {
   selectedScopeIndex: number;
   selectedActionIndex: number;
+  pendingDecision: "select" | "cancel" | null;
 }
 
 export type PluginDetailAction =
@@ -9,7 +12,9 @@ export type PluginDetailAction =
   | { type: "MOVE_SCOPE_UP"; maxIndex: number }
   | { type: "MOVE_SCOPE_DOWN"; maxIndex: number }
   | { type: "MOVE_ACTION_UP"; maxIndex: number }
-  | { type: "MOVE_ACTION_DOWN"; maxIndex: number };
+  | { type: "MOVE_ACTION_DOWN"; maxIndex: number }
+  | { type: "HANDLE_KEY"; key: Key; maxIndex: number }
+  | { type: "CLEAR_DECISION" };
 
 export function pluginDetailReducer(
   state: PluginDetailState,
@@ -52,6 +57,42 @@ export function pluginDetailReducer(
             ? state.selectedActionIndex + 1
             : 0,
       };
+    case "HANDLE_KEY":
+      if (action.key.upArrow) {
+        return {
+          ...state,
+          selectedScopeIndex:
+            state.selectedScopeIndex > 0
+              ? state.selectedScopeIndex - 1
+              : action.maxIndex,
+          selectedActionIndex:
+            state.selectedActionIndex > 0
+              ? state.selectedActionIndex - 1
+              : action.maxIndex,
+        };
+      }
+      if (action.key.downArrow) {
+        return {
+          ...state,
+          selectedScopeIndex:
+            state.selectedScopeIndex < action.maxIndex
+              ? state.selectedScopeIndex + 1
+              : 0,
+          selectedActionIndex:
+            state.selectedActionIndex < action.maxIndex
+              ? state.selectedActionIndex + 1
+              : 0,
+        };
+      }
+      if (action.key.return) {
+        return { ...state, pendingDecision: "select" };
+      }
+      if (action.key.escape) {
+        return { ...state, pendingDecision: "cancel" };
+      }
+      return state;
+    case "CLEAR_DECISION":
+      return { ...state, pendingDecision: null };
     default:
       return state;
   }