wave-code 0.7.1 → 0.8.0

package/src/managers/InputManager.ts

@@ -33,6 +33,7 @@ export interface InputManagerCallbacks {
   onMcpManagerStateChange?: (show: boolean) => void;
   onRewindManagerStateChange?: (show: boolean) => void;
   onHelpStateChange?: (show: boolean) => void;
+  onStatusCommandStateChange?: (show: boolean) => void;
   onImagesStateChange?: (images: AttachedImage[]) => void;
   onSendMessage?: (
     content: string,
@@ -40,6 +41,7 @@ export interface InputManagerCallbacks {
   ) => void | Promise<void>;
   onHasSlashCommand?: (commandId: string) => boolean;
   onAbortMessage?: () => void;
+  onClearMessages?: () => void;
   onBackgroundCurrentTask?: () => void;
   onResetHistoryNavigation?: () => void;
   onPermissionModeChange?: (mode: PermissionMode) => void;
@@ -86,6 +88,7 @@ export class InputManager {
   private showMcpManager: boolean = false;
   private showRewindManager: boolean = false;
   private showHelp: boolean = false;
+  private showStatusCommand: boolean = false;
 
   // Permission mode state
   private permissionMode: PermissionMode = "default";
@@ -342,7 +345,10 @@ export class InputManager {
 
         // If not an agent command or execution failed, check local commands
         if (!commandExecuted) {
-          if (command === "tasks") {
+          if (command === "clear") {
+            this.callbacks.onClearMessages?.();
+            commandExecuted = true;
+          } else if (command === "tasks") {
             this.setShowBackgroundTaskManager(true);
             commandExecuted = true;
           } else if (command === "mcp") {
@@ -354,6 +360,9 @@ export class InputManager {
           } else if (command === "help") {
             this.setShowHelp(true);
             commandExecuted = true;
+          } else if (command === "status") {
+            this.setShowStatusCommand(true);
+            commandExecuted = true;
           }
         }
       })();
@@ -667,11 +676,33 @@ export class InputManager {
     this.callbacks.onHelpStateChange?.(show);
   }
 
+  getShowStatusCommand(): boolean {
+    return this.showStatusCommand;
+  }
+
+  setShowStatusCommand(show: boolean): void {
+    this.showStatusCommand = show;
+    this.callbacks.onStatusCommandStateChange?.(show);
+  }
+
   // Permission mode methods
   getPermissionMode(): PermissionMode {
     return this.permissionMode;
   }
 
+  isAnySelectorOrManagerActive(): boolean {
+    return (
+      this.showFileSelector ||
+      this.showCommandSelector ||
+      this.showHistorySearch ||
+      this.showBackgroundTaskManager ||
+      this.showMcpManager ||
+      this.showRewindManager ||
+      this.showHelp ||
+      this.showStatusCommand
+    );
+  }
+
   setPermissionMode(mode: PermissionMode): void {
     this.permissionMode = mode;
   }
@@ -920,9 +951,7 @@ export class InputManager {
     if (
       key.escape &&
       (isLoading || isCommandRunning) &&
-      !this.showBackgroundTaskManager &&
-      !this.showMcpManager &&
-      !this.showRewindManager
+      !this.isAnySelectorOrManagerActive()
     ) {
       // Unified interrupt for AI message generation and command execution
       this.callbacks.onAbortMessage?.();
@@ -937,22 +966,15 @@ export class InputManager {
     }
 
     // Check if any selector is active
-    if (
-      this.showFileSelector ||
-      this.showCommandSelector ||
-      this.showHistorySearch ||
-      this.showBackgroundTaskManager ||
-      this.showMcpManager ||
-      this.showRewindManager ||
-      this.showHelp
-    ) {
+    if (this.isAnySelectorOrManagerActive()) {
       if (
         this.showBackgroundTaskManager ||
         this.showMcpManager ||
         this.showRewindManager ||
-        this.showHelp
+        this.showHelp ||
+        this.showStatusCommand
       ) {
-        // Task manager, MCP manager, Rewind and Help don't need to handle input, handled by component itself
+        // Task manager, MCP manager, Rewind, Help and Status don't need to handle input, handled by component itself
         // Return true to indicate we've "handled" it (by ignoring it) so it doesn't leak to normal input
         return true;
       }

package/src/print-cli.ts

@@ -1,14 +1,19 @@
-import { Agent, AgentCallbacks } from "wave-agent-sdk";
+import {
+  Agent,
+  AgentCallbacks,
+  hasUncommittedChanges,
+  hasNewCommits,
+  getDefaultRemoteBranch,
+} from "wave-agent-sdk";
 import { displayUsageSummary } from "./utils/usageSummary.js";
+import { removeWorktree } from "./utils/worktree.js";
+import { BaseAppProps } from "./types.js";
 
-export interface PrintCliOptions {
+export interface PrintCliOptions extends BaseAppProps {
   restoreSessionId?: string;
   continueLastSession?: boolean;
   message?: string;
   showStats?: boolean;
-  bypassPermissions?: boolean;
-  pluginDirs?: string[];
-  tools?: string[];
 }
 
 function displayTimingInfo(startTime: Date, showStats: boolean): void {
@@ -35,6 +40,9 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
     bypassPermissions,
     pluginDirs,
     tools,
+    worktreeSession,
+    workdir,
+    model,
   } = options;
 
   if (
@@ -139,6 +147,8 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
       permissionMode: bypassPermissions ? "bypassPermissions" : undefined,
       plugins: pluginDirs?.map((path) => ({ type: "local", path })),
       tools,
+      workdir,
+      model,
       // 保持流式模式以获得更好的命令行用户体验
     });
 
@@ -163,6 +173,23 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
 
     // Destroy agent and exit after sendMessage completes
     await agent.destroy();
+
+    // Handle worktree cleanup for print mode
+    if (worktreeSession) {
+      const cwd = workdir || worktreeSession.path;
+      const baseBranch = getDefaultRemoteBranch(cwd);
+      const hasChanges = hasUncommittedChanges(cwd);
+      const hasCommits = hasNewCommits(cwd, baseBranch);
+
+      if (!hasChanges && !hasCommits) {
+        removeWorktree(worktreeSession);
+      } else {
+        process.stdout.write(
+          `\n⚠️ Worktree '${worktreeSession.name}' has changes or commits. Keeping it at: ${worktreeSession.path}\n`,
+        );
+      }
+    }
+
     process.exit(0);
   } catch (error) {
     console.error("Failed to send message:", error);
@@ -182,6 +209,22 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
       displayTimingInfo(startTime, showStats);
 
       await agent.destroy();
+
+      // Handle worktree cleanup for print mode even on error
+      if (worktreeSession) {
+        const cwd = workdir || worktreeSession.path;
+        const baseBranch = getDefaultRemoteBranch(cwd);
+        const hasChanges = hasUncommittedChanges(cwd);
+        const hasCommits = hasNewCommits(cwd, baseBranch);
+
+        if (!hasChanges && !hasCommits) {
+          removeWorktree(worktreeSession);
+        } else {
+          process.stdout.write(
+            `\n⚠️ Worktree '${worktreeSession.name}' has changes or commits. Keeping it at: ${worktreeSession.path}\n`,
+          );
+        }
+      }
     }
     process.exit(1);
   }

package/src/session-selector-cli.tsx

@@ -3,8 +3,12 @@ import { render, Box } from "ink";
 import { listSessions, truncateContent } from "wave-agent-sdk";
 import { SessionSelector } from "./components/SessionSelector.js";
 
-export async function startSessionSelectorCli(): Promise<string | null> {
-  const currentWorkdir = process.cwd();
+export async function startSessionSelectorCli({
+  workdir,
+}: {
+  workdir?: string;
+} = {}): Promise<string | null> {
+  const currentWorkdir = workdir || process.cwd();
   const sessions = await listSessions(currentWorkdir);
 
   if (sessions.length === 0) {

package/src/types.ts

@@ -0,0 +1,11 @@
+import { WorktreeSession } from "./utils/worktree.js";
+
+export interface BaseAppProps {
+  bypassPermissions?: boolean;
+  pluginDirs?: string[];
+  tools?: string[];
+  worktreeSession?: WorktreeSession;
+  workdir?: string;
+  version?: string;
+  model?: string;
+}

package/src/utils/worktree.ts

@@ -0,0 +1,164 @@
+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 interface WorktreeSession {
+  name: string;
+  path: string;
+  branch: string;
+  repoRoot: string;
+  hasUncommittedChanges: boolean;
+  hasNewCommits: boolean;
+  isNew: boolean;
+}
+
+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: string, cwd: string): WorktreeSession {
+  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: unknown) {
+    const stderr = (error as { stderr?: Buffer }).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: unknown) {
+        throw new Error(
+          `Failed to add existing worktree branch: ${(innerError as Error).message}`,
+        );
+      }
+    }
+    throw new Error(
+      `Failed to create worktree: ${(error as Error).message}\n${stderr}`,
+    );
+  }
+}
+
+/**
+ * Remove a git worktree and its associated branch
+ * @param session Worktree session details
+ */
+export function removeWorktree(session: WorktreeSession): void {
+  const repoRoot = session.repoRoot;
+
+  try {
+    // 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();
+    } 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: unknown) {
+    console.error(
+      `Failed to remove worktree or branch: ${(error as Error).message}`,
+    );
+  }
+}

package/dist/components/CommandOutputDisplay.d.ts

@@ -1,9 +0,0 @@
-import React from "react";
-import type { CommandOutputBlock } from "wave-agent-sdk";
-interface CommandOutputDisplayProps {
-    block: CommandOutputBlock;
-    isExpanded?: boolean;
-}
-export declare const CommandOutputDisplay: React.FC<CommandOutputDisplayProps>;
-export {};
-//# sourceMappingURL=CommandOutputDisplay.d.ts.map

package/dist/components/CommandOutputDisplay.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CommandOutputDisplay.d.ts","sourceRoot":"","sources":["../../src/components/CommandOutputDisplay.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA8B,MAAM,OAAO,CAAC;AAEnD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEzD,UAAU,yBAAyB;IACjC,KAAK,EAAE,kBAAkB,CAAC;IAC1B,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC,yBAAyB,CAiDpE,CAAC"}