wave-code 0.7.2 → 0.8.1

package/src/cli.tsx

@@ -2,13 +2,12 @@ import React from "react";
 import { render } from "ink";
 import { App } from "./components/App.js";
 import { cleanupLogs } from "./utils/logger.js";
+import { removeWorktree } from "./utils/worktree.js";
+import { BaseAppProps } from "./types.js";
 
-export interface CliOptions {
+export interface CliOptions extends BaseAppProps {
   restoreSessionId?: string;
   continueLastSession?: boolean;
-  bypassPermissions?: boolean;
-  pluginDirs?: string[];
-  tools?: string[];
 }
 
 export async function startCli(options: CliOptions): Promise<void> {
@@ -18,77 +17,55 @@ export async function startCli(options: CliOptions): Promise<void> {
     bypassPermissions,
     pluginDirs,
     tools,
+    worktreeSession,
+    workdir,
+    version,
+    model,
   } = options;
 
   // Continue with ink-based UI for normal mode
-  // Global cleanup tracker
-  let isCleaningUp = false;
-  let appUnmounted = false;
+  let shouldRemoveWorktree = false;
 
-  const cleanup = async () => {
-    if (isCleaningUp) return;
-    isCleaningUp = true;
-
-    console.log("\nShutting down gracefully...");
-
-    try {
-      // Clean up old log files
-      await cleanupLogs().catch((error) => {
-        console.warn("Failed to cleanup old logs:", error);
-      });
-
-      // Unmount the React app to trigger cleanup
-      if (!appUnmounted) {
-        unmount();
-        appUnmounted = true;
-        // Give React time to cleanup
-        await new Promise((resolve) => setTimeout(resolve, 100));
-      }
-
-      process.exit(0);
-    } catch (error: unknown) {
-      console.error("Error during cleanup:", error);
-      process.exit(1);
-    }
+  const handleExit = (shouldRemove: boolean) => {
+    shouldRemoveWorktree = shouldRemove;
+    unmount();
   };
 
-  // Handle process signals
-  process.on("SIGINT", cleanup);
-  process.on("SIGTERM", cleanup);
-
-  // Handle uncaught exceptions
-  process.on("uncaughtException", (error) => {
-    console.error("Uncaught exception:", error);
-    cleanup();
-  });
-
-  process.on("unhandledRejection", (reason, promise) => {
-    console.error("Unhandled rejection at:", promise, "reason:", reason);
-    cleanup();
-  });
-
   // Render the application
-  const { unmount } = render(
+  const { unmount, waitUntilExit } = render(
     <App
       restoreSessionId={restoreSessionId}
       continueLastSession={continueLastSession}
       bypassPermissions={bypassPermissions}
       pluginDirs={pluginDirs}
       tools={tools}
+      worktreeSession={worktreeSession}
+      workdir={workdir}
+      version={version}
+      model={model}
+      onExit={handleExit}
     />,
+    { exitOnCtrlC: false },
   );
 
-  // Store unmount function for cleanup when process exits normally
-  process.on("exit", () => {
-    if (!appUnmounted) {
-      try {
-        unmount();
-      } catch {
-        // Ignore errors during unmount
-      }
+  // Wait for the app to finish unmounting
+  await waitUntilExit();
+
+  try {
+    // Clean up old log files
+    await cleanupLogs().catch((error) => {
+      console.warn("Failed to cleanup old logs:", error);
+    });
+
+    // Cleanup worktree if requested
+    if (shouldRemoveWorktree && worktreeSession) {
+      process.chdir(worktreeSession.repoRoot);
+      removeWorktree(worktreeSession);
     }
-  });
 
-  // Return a promise that never resolves to keep the CLI running
-  return new Promise(() => {});
+    process.exit(0);
+  } catch (error: unknown) {
+    console.error("Error during cleanup:", error);
+    process.exit(1);
+  }
 }

package/src/components/App.tsx

@@ -1,27 +1,105 @@
-import React, { useState, useEffect, useRef } from "react";
-import { useStdout } from "ink";
+import React, { useState, useEffect, useRef, useCallback } from "react";
+import { useStdout, useInput } from "ink";
 import { ChatInterface } from "./ChatInterface.js";
 import { ChatProvider, useChat } from "../contexts/useChat.js";
 import { AppProvider } from "../contexts/useAppConfig.js";
+import { WorktreeExitPrompt } from "./WorktreeExitPrompt.js";
+import {
+  hasUncommittedChanges,
+  hasNewCommits,
+  getDefaultRemoteBranch,
+} from "wave-agent-sdk";
+import { BaseAppProps } from "../types.js";
 
-interface AppProps {
+interface AppProps extends BaseAppProps {
   restoreSessionId?: string;
   continueLastSession?: boolean;
-  bypassPermissions?: boolean;
-  pluginDirs?: string[];
-  tools?: string[];
+  onExit: (shouldRemove: boolean) => void;
 }
 
-const AppWithProviders: React.FC<{
-  bypassPermissions?: boolean;
-  pluginDirs?: string[];
-  tools?: string[];
-}> = ({ bypassPermissions, pluginDirs, tools }) => {
+interface AppWithProvidersProps extends BaseAppProps {
+  onExit: (shouldRemove: boolean) => void;
+}
+
+const AppWithProviders: React.FC<AppWithProvidersProps> = ({
+  bypassPermissions,
+  pluginDirs,
+  tools,
+  worktreeSession,
+  workdir,
+  version,
+  model,
+  onExit,
+}) => {
+  const [isExiting, setIsExiting] = useState(false);
+  const [worktreeStatus, setWorktreeStatus] = useState<{
+    hasUncommittedChanges: boolean;
+    hasNewCommits: boolean;
+  } | null>(null);
+
+  const handleSignal = useCallback(async () => {
+    if (worktreeSession) {
+      const cwd = workdir || worktreeSession.path;
+      const baseBranch = getDefaultRemoteBranch(cwd);
+      const hasChanges = hasUncommittedChanges(cwd);
+      const hasCommits = hasNewCommits(cwd, baseBranch);
+
+      if (hasChanges || hasCommits) {
+        setWorktreeStatus({
+          hasUncommittedChanges: hasChanges,
+          hasNewCommits: hasCommits,
+        });
+        setIsExiting(true);
+      } else {
+        onExit(true);
+      }
+    } else {
+      onExit(false);
+    }
+  }, [worktreeSession, workdir, onExit]);
+
+  useInput((input, key) => {
+    if (input === "c" && key.ctrl) {
+      handleSignal();
+    }
+  });
+
+  useEffect(() => {
+    const onSigInt = () => handleSignal();
+    const onSigTerm = () => handleSignal();
+
+    process.on("SIGINT", onSigInt);
+    process.on("SIGTERM", onSigTerm);
+
+    return () => {
+      process.off("SIGINT", onSigInt);
+      process.off("SIGTERM", onSigTerm);
+    };
+  }, [handleSignal]);
+
+  if (isExiting && worktreeSession && worktreeStatus) {
+    return (
+      <WorktreeExitPrompt
+        name={worktreeSession.name}
+        path={worktreeSession.path}
+        hasUncommittedChanges={worktreeStatus.hasUncommittedChanges}
+        hasNewCommits={worktreeStatus.hasNewCommits}
+        onKeep={() => onExit(false)}
+        onRemove={() => onExit(true)}
+        onCancel={() => setIsExiting(false)}
+      />
+    );
+  }
+
   return (
     <ChatProvider
       bypassPermissions={bypassPermissions}
       pluginDirs={pluginDirs}
       tools={tools}
+      workdir={workdir}
+      worktreeSession={worktreeSession}
+      version={version}
+      model={model}
     >
       <ChatInterfaceWithRemount />
     </ChatProvider>
@@ -81,6 +159,11 @@ export const App: React.FC<AppProps> = ({
   bypassPermissions,
   pluginDirs,
   tools,
+  worktreeSession,
+  workdir,
+  version,
+  model,
+  onExit,
 }) => {
   return (
     <AppProvider
@@ -91,6 +174,11 @@ export const App: React.FC<AppProps> = ({
         bypassPermissions={bypassPermissions}
         pluginDirs={pluginDirs}
         tools={tools}
+        worktreeSession={worktreeSession}
+        workdir={workdir}
+        version={version}
+        model={model}
+        onExit={onExit}
       />
     </AppProvider>
   );

package/src/components/{CommandOutputDisplay.tsx → BangDisplay.tsx}

@@ -1,13 +1,13 @@
 import React, { useState, useEffect } from "react";
 import { Box, Text } from "ink";
-import type { CommandOutputBlock } from "wave-agent-sdk";
+import type { BangBlock } from "wave-agent-sdk";
 
-interface CommandOutputDisplayProps {
-  block: CommandOutputBlock;
+interface BangDisplayProps {
+  block: BangBlock;
   isExpanded?: boolean;
 }
 
-export const CommandOutputDisplay: React.FC<CommandOutputDisplayProps> = ({
+export const BangDisplay: React.FC<BangDisplayProps> = ({
   block,
   isExpanded = false,
 }) => {

package/src/components/ChatInterface.tsx

@@ -36,8 +36,13 @@ export const ChatInterface: React.FC = () => {
     handleConfirmationDecision,
     handleConfirmationCancel: originalHandleConfirmationCancel,
     setWasLastDetailsTooTall,
+    version,
+    workdir,
+    getModelConfig,
   } = useChat();
 
+  const model = getModelConfig().model;
+
   const handleDetailsHeightMeasured = useCallback((height: number) => {
     setDetailsHeight(height);
   }, []);
@@ -91,6 +96,9 @@ export const ChatInterface: React.FC = () => {
         messages={messages}
         isExpanded={isExpanded}
         hideDynamicBlocks={isConfirmationVisible}
+        version={version}
+        workdir={workdir}
+        model={model}
       />
 
       {(isLoading || isCommandRunning || isCompressing) &&

package/src/components/CommandSelector.tsx

@@ -1,34 +1,7 @@
 import React, { useState } from "react";
 import { Box, Text, useInput } from "ink";
 import type { SlashCommand } from "wave-agent-sdk";
-
-const AVAILABLE_COMMANDS: SlashCommand[] = [
-  {
-    id: "tasks",
-    name: "tasks",
-    description: "View and manage background tasks (shells and subagents)",
-    handler: () => {}, // Handler here won't be used, actual processing is in the hook
-  },
-  {
-    id: "mcp",
-    name: "mcp",
-    description: "View and manage MCP servers",
-    handler: () => {}, // Handler here won't be used, actual processing is in the hook
-  },
-  {
-    id: "rewind",
-    name: "rewind",
-    description:
-      "Revert conversation and file changes to a previous checkpoint",
-    handler: () => {}, // Handler here won't be used, actual processing is in the hook
-  },
-  {
-    id: "help",
-    name: "help",
-    description: "Show help and key bindings",
-    handler: () => {}, // Handler here won't be used, actual processing is in the hook
-  },
-];
+import { AVAILABLE_COMMANDS } from "../constants/commands.js";
 
 export interface CommandSelectorProps {
   searchQuery: string;
@@ -48,8 +21,13 @@ export const CommandSelector: React.FC<CommandSelectorProps> = ({
   const MAX_VISIBLE_ITEMS = 3;
   const [selectedIndex, setSelectedIndex] = useState(0);
 
+  // Reset selected index when search query changes
+  React.useEffect(() => {
+    setSelectedIndex(0);
+  }, [searchQuery]);
+
   // Merge agent commands and local commands
-  const allCommands = [...commands, ...AVAILABLE_COMMANDS];
+  const allCommands = [...AVAILABLE_COMMANDS, ...commands];
 
   // Filter command list
   const filteredCommands = allCommands.filter(

package/src/components/ConfirmationSelector.tsx

@@ -1,4 +1,4 @@
-import React, { useLayoutEffect, useRef, useState } from "react";
+import React, { useEffect, useLayoutEffect, useRef, useState } from "react";
 import { Box, Text, useInput, useStdout, measureElement } from "ink";
 import type { PermissionDecision, AskUserQuestionInput } from "wave-agent-sdk";
 import {
@@ -70,6 +70,25 @@ export const ConfirmationSelector: React.FC<ConfirmationSelectorProps> = ({
     userAnswers: {} as Record<string, string>,
     otherText: "",
     otherCursorPosition: 0,
+    savedStates: {} as Record<
+      number,
+      {
+        selectedOptionIndex: number;
+        selectedOptionIndices: Set<number>;
+        otherText: string;
+        otherCursorPosition: number;
+      }
+    >,
+  });
+
+  const pendingDecisionRef = useRef<PermissionDecision | null>(null);
+
+  useEffect(() => {
+    if (pendingDecisionRef.current) {
+      const decision = pendingDecisionRef.current;
+      pendingDecisionRef.current = null;
+      onDecision(decision);
+    }
   });
 
   const questions =
@@ -133,23 +152,75 @@ export const ConfirmationSelector: React.FC<ConfirmationSelectorProps> = ({
           };
 
           if (prev.currentQuestionIndex < questions.length - 1) {
-            return {
-              ...prev,
-              currentQuestionIndex: prev.currentQuestionIndex + 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(),
-              userAnswers: newAnswers,
+              selectedOptionIndices: new Set<number>(),
               otherText: "",
               otherCursorPosition: 0,
             };
+
+            return {
+              ...prev,
+              currentQuestionIndex: nextIndex,
+              ...nextState,
+              userAnswers: newAnswers,
+              savedStates,
+            };
           } else {
-            onDecision({
+            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(newAnswers),
-            });
+              message: JSON.stringify(finalAnswers),
+            };
             return {
               ...prev,
-              userAnswers: newAnswers,
+              userAnswers: finalAnswers,
             };
           }
         });
@@ -196,6 +267,41 @@ export const ConfirmationSelector: React.FC<ConfirmationSelectorProps> = ({
         }));
         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,
+          };
+        });
+        return;
+      }
 
       setQuestionState((prev) => {
         const isOtherFocused = prev.selectedOptionIndex === options.length - 1;
@@ -321,6 +427,19 @@ export const ConfirmationSelector: React.FC<ConfirmationSelectorProps> = ({
       return;
     }
 
+    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;
+      setState((prev) => ({
+        ...prev,
+        selectedOption: availableOptions[nextIndex],
+      }));
+      return;
+    }
+
     if (input && !key.ctrl && !key.meta && !("alt" in key && key.alt)) {
       setState((prev) => {
         const nextText =
@@ -436,7 +555,7 @@ export const ConfirmationSelector: React.FC<ConfirmationSelectorProps> = ({
                 Question {questionState.currentQuestionIndex + 1} of{" "}
                 {questions.length} •
                 {currentQuestion.multiSelect ? " Space to toggle •" : ""} Use ↑↓
-                to navigate • Enter to confirm
+                or Tab to navigate • Enter to confirm
               </Text>
             </Box>
           </Box>
@@ -531,7 +650,7 @@ export const ConfirmationSelector: React.FC<ConfirmationSelectorProps> = ({
             </Box>
           </Box>
           <Box marginTop={1}>
-            <Text dimColor>Use ↑↓ to navigate • ESC to cancel</Text>
+            <Text dimColor>Use ↑↓ or Tab to navigate • ESC to cancel</Text>
           </Box>
         </>
       )}