wave-code 0.7.2 → 0.8.0

package/dist/utils/worktree.js

@@ -0,0 +1,135 @@
+import { execSync } from "node:child_process";
+import * as path from "node:path";
+import * as fs from "node:fs";
+import { getGitRepoRoot, getDefaultRemoteBranch } from "wave-agent-sdk";
+export const WORKTREE_DIR = ".wave/worktrees";
+/**
+ * Create a new git worktree
+ * @param name Worktree name
+ * @param cwd Current working directory
+ * @returns Worktree session details
+ */
+export function createWorktree(name, cwd) {
+    const repoRoot = getGitRepoRoot(cwd);
+    const worktreePath = path.join(repoRoot, WORKTREE_DIR, name);
+    const branchName = `worktree-${name}`;
+    const baseBranch = getDefaultRemoteBranch(cwd);
+    // Ensure parent directory exists
+    const parentDir = path.dirname(worktreePath);
+    if (!fs.existsSync(parentDir)) {
+        fs.mkdirSync(parentDir, { recursive: true });
+    }
+    // Check if worktree already exists
+    if (fs.existsSync(worktreePath)) {
+        // If it exists, we assume it's already set up correctly
+        return {
+            name,
+            path: worktreePath,
+            branch: branchName,
+            repoRoot,
+            hasUncommittedChanges: false,
+            hasNewCommits: false,
+            isNew: false,
+        };
+    }
+    try {
+        // Create worktree and branch
+        execSync(`git worktree add -b ${branchName} "${worktreePath}" ${baseBranch}`, {
+            cwd: repoRoot,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return {
+            name,
+            path: worktreePath,
+            branch: branchName,
+            repoRoot,
+            hasUncommittedChanges: false,
+            hasNewCommits: false,
+            isNew: true,
+        };
+    }
+    catch (error) {
+        const stderr = error.stderr?.toString() || "";
+        if (stderr.includes("already exists")) {
+            // If branch already exists, try to add worktree without -b
+            try {
+                execSync(`git worktree add "${worktreePath}" ${branchName}`, {
+                    cwd: repoRoot,
+                    stdio: ["ignore", "pipe", "pipe"],
+                });
+                return {
+                    name,
+                    path: worktreePath,
+                    branch: branchName,
+                    repoRoot,
+                    hasUncommittedChanges: false,
+                    hasNewCommits: false,
+                    isNew: true,
+                };
+            }
+            catch (innerError) {
+                throw new Error(`Failed to add existing worktree branch: ${innerError.message}`);
+            }
+        }
+        throw new Error(`Failed to create worktree: ${error.message}\n${stderr}`);
+    }
+}
+/**
+ * Remove a git worktree and its associated branch
+ * @param session Worktree session details
+ */
+export function removeWorktree(session) {
+    const repoRoot = session.repoRoot;
+    try {
+        // Get current branch in worktree before removing it
+        let currentBranch;
+        try {
+            currentBranch = execSync(`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}"`, {
+            cwd: repoRoot,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        // Delete original branch
+        try {
+            execSync(`git branch -D ${session.branch}`, {
+                cwd: repoRoot,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        }
+        catch {
+            // Ignore errors deleting original branch
+        }
+        // Delete current branch if it's different and not a protected branch
+        if (currentBranch &&
+            currentBranch !== session.branch &&
+            currentBranch !== "HEAD") {
+            const defaultRemoteBranch = getDefaultRemoteBranch(repoRoot);
+            const defaultBranchName = defaultRemoteBranch.split("/").pop();
+            if (currentBranch !== defaultBranchName &&
+                currentBranch !== "main" &&
+                currentBranch !== "master") {
+                try {
+                    execSync(`git branch -D ${currentBranch}`, {
+                        cwd: repoRoot,
+                        stdio: ["ignore", "pipe", "pipe"],
+                    });
+                }
+                catch {
+                    // Ignore errors deleting current branch
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error(`Failed to remove worktree or branch: ${error.message}`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-code",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "CLI-based code assistant powered by AI, built with React and Ink",
   "repository": {
     "type": "git",
@@ -39,7 +39,7 @@
     "react": "^19.2.4",
     "react-dom": "19.2.4",
     "yargs": "^17.7.2",
-    "wave-agent-sdk": "0.7.2"
+    "wave-agent-sdk": "0.8.0"
   },
   "devDependencies": {
     "@types/react": "^19.1.8",

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

@@ -3,6 +3,12 @@ import { Box, Text, useInput } from "ink";
 import type { SlashCommand } from "wave-agent-sdk";
 
 const AVAILABLE_COMMANDS: SlashCommand[] = [
+  {
+    id: "clear",
+    name: "clear",
+    description: "Clear the chat session and terminal",
+    handler: () => {}, // Handler here won't be used, actual processing is in the hook
+  },
   {
     id: "tasks",
     name: "tasks",
@@ -28,6 +34,12 @@ const AVAILABLE_COMMANDS: SlashCommand[] = [
     description: "Show help and key bindings",
     handler: () => {}, // Handler here won't be used, actual processing is in the hook
   },
+  {
+    id: "status",
+    name: "status",
+    description: "Show agent status and configuration",
+    handler: () => {}, // Handler here won't be used, actual processing is in the hook
+  },
 ];
 
 export interface CommandSelectorProps {
@@ -48,8 +60,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

@@ -70,6 +70,15 @@ 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 questions =
@@ -133,23 +142,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 {
+            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;
+
             onDecision({
               behavior: "allow",
-              message: JSON.stringify(newAnswers),
+              message: JSON.stringify(finalAnswers),
             });
             return {
               ...prev,
-              userAnswers: newAnswers,
+              userAnswers: finalAnswers,
             };
           }
         });
@@ -196,6 +257,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 +417,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 +545,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 +640,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>
         </>
       )}

package/src/components/HelpView.tsx

@@ -21,6 +21,8 @@ export const HelpView: React.FC<HelpViewProps> = ({ onCancel }) => {
     { key: "Ctrl+B", description: "Background current task" },
     { key: "Ctrl+V", description: "Paste image" },
     { key: "Shift+Tab", description: "Cycle permission mode" },
+    { key: "/status", description: "Show agent status and configuration" },
+    { key: "/clear", description: "Clear the chat session and terminal" },
     {
       key: "Esc",
       description: "Interrupt AI or command / Cancel selector / Close help",