wave-agent-sdk 0.19.4 → 0.19.6

package/src/tools/exitWorktreeTool.ts

@@ -4,10 +4,6 @@
  */
 
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
-import {
-  getCurrentWorktreeSession,
-  setCurrentWorktreeSession,
-} from "../utils/worktreeSession.js";
 import {
   removeWorktree,
   countWorktreeChanges,
@@ -89,8 +85,8 @@ export const exitWorktreeTool: ToolPlugin = {
       };
     }
 
-    // Validate: must be in an active worktree session
-    const session = getCurrentWorktreeSession();
+    // Validate: must be in an active worktree session (for this session)
+    const session = context.aiManager?.getWorktreeSession();
     if (!session) {
       return {
         success: false,
@@ -139,11 +135,9 @@ export const exitWorktreeTool: ToolPlugin = {
 
     if (action === "keep") {
       // Clear session state
-      setCurrentWorktreeSession(null);
-
-      // Restore CWD
       const aiManager = context.aiManager;
       if (aiManager) {
+        aiManager.setWorktreeSession(null);
         aiManager.setWorkdir(originalCwd);
       }
 
@@ -170,12 +164,10 @@ export const exitWorktreeTool: ToolPlugin = {
 
     removeWorktree(worktreeInfo);
 
-    // Clear session state
-    setCurrentWorktreeSession(null);
-
-    // Restore CWD
+    // Clear session state and restore CWD
     const aiManager = context.aiManager;
     if (aiManager) {
+      aiManager.setWorktreeSession(null);
       aiManager.setWorkdir(originalCwd);
     }
 

package/src/tools/grepTool.ts

@@ -8,6 +8,18 @@ import {
   AGENT_TOOL_NAME,
 } from "../constants/tools.js";
 
+// Version control system directories to exclude from searches.
+// These are excluded automatically because they create noise in search results.
+// Mirrors Claude Code's VCS_DIRECTORIES_TO_EXCLUDE.
+const VCS_DIRECTORIES_TO_EXCLUDE = [
+  ".git",
+  ".svn",
+  ".hg",
+  ".bzr",
+  ".jj",
+  ".sl",
+] as const;
+
 /**
  * Grep tool plugin - powerful search tool based on ripgrep
  */
@@ -144,7 +156,19 @@ export const grepTool: ToolPlugin = {
 
     try {
       const workdir = context.workdir;
-      const rgArgs: string[] = ["--color=never", "--max-columns=500"];
+      const rgArgs: string[] = [
+        "--color=never",
+        "--max-columns=500",
+        // Search hidden files/directories by default (aligns with Claude Code).
+        // --hidden does NOT disable .gitignore; only --no-ignore would.
+        "--hidden",
+      ];
+
+      // Exclude VCS directories to avoid noise from version control metadata.
+      // --hidden above would otherwise traverse .git/.svn/etc.
+      for (const dir of VCS_DIRECTORIES_TO_EXCLUDE) {
+        rgArgs.push("--glob", `!${dir}`);
+      }
 
       // Set output mode
       if (outputMode === "files_with_matches") {

package/src/types/hooks.ts

@@ -196,6 +196,34 @@ export interface HookJsonInput {
   end_source?: SessionEndSource; // Present for SessionEnd events
   compact_instructions?: string; // Present for PreCompact events
   compact_summary?: string; // Present for PostCompact events
+  background_tasks?: BackgroundTaskInfo[]; // Present for Stop events: running background tasks snapshot
+  session_crons?: SessionCronInfo[]; // Present for Stop events: session-scoped cron jobs snapshot
+  last_assistant_message?: string; // Present for Stop and SubagentStop events: text content of the last assistant message
+}
+
+// Describes one in-flight background task in the Stop hook input.
+// Aligned with Claude Code (v2.1.145+) background_tasks array element schema.
+// Conditional fields are populated based on `type`:
+//   - "shell":    `command` is set
+//   - "subagent": `agent_type` is set
+//   - "workflow": `name` is set
+export interface BackgroundTaskInfo {
+  id: string;
+  type: "shell" | "subagent" | "workflow";
+  status: string;
+  description: string; // Capped at 1000 chars with "… [+N chars]" marker
+  command?: string; // Present only for shell tasks (≤1000 chars)
+  agent_type?: string; // Present only for subagent tasks
+  name?: string; // Present only for workflow tasks
+}
+
+// Describes one session-scoped cron job in the Stop hook input.
+// Aligned with Claude Code (v2.1.145+) session_crons array element schema.
+export interface SessionCronInfo {
+  id: string;
+  schedule: string; // Cron expression
+  recurring: boolean;
+  prompt: string;
 }
 
 // Extended context interface for passing additional data to hook executor
@@ -216,6 +244,9 @@ export interface ExtendedHookExecutionContext extends HookExecutionContext {
   endSource?: SessionEndSource; // Session end source (SessionEnd only)
   compactInstructions?: string; // Custom instructions for PreCompact
   compactSummary?: string; // Summary text for PostCompact
+  backgroundTasks?: BackgroundTaskInfo[]; // Running background tasks snapshot (Stop only)
+  sessionCrons?: SessionCronInfo[]; // Session-scoped cron jobs snapshot (Stop only)
+  lastAssistantMessage?: string; // Text content of last assistant message (Stop and SubagentStop only)
 }
 
 // Environment variables injected into hook processes

package/src/types/messaging.ts

@@ -95,6 +95,8 @@ export interface ReasoningBlock {
   type: "reasoning";
   content: string;
   stage?: "streaming" | "end";
+  startTime?: number; // Unix ms, set when the first reasoning content arrives
+  endTime?: number; // Unix ms, set when stage transitions to "end"
 }
 
 export interface FileHistoryBlock {

package/src/utils/containerSetup.ts

@@ -88,6 +88,10 @@ export function setupAgentContainer(
     container.register("MainRepoRoot", getGitMainRepoRoot(workdir));
   }
 
+  // Per-agent worktree session state (EnterWorktree/ExitWorktree). Stored in the
+  // container so it is isolated per session, not shared process-wide.
+  container.register("WorktreeSession", null);
+
   const notificationQueue = new NotificationQueue();
   container.register("NotificationQueue", notificationQueue);
 

package/src/utils/shellResolver.ts

@@ -1,19 +1,170 @@
 import fs from "fs";
+import path from "path";
+import { execFileSync } from "child_process";
 
 export const WINDOWS_GIT_BASH_PATHS = [
   "C:\\Program Files\\Git\\bin\\bash.exe",
   "C:\\Program Files (x86)\\Git\\bin\\bash.exe",
 ];
 
-export function resolveShellPath(): string | undefined {
-  if (process.platform !== "win32") {
-    return undefined;
+// Common git.exe locations (checked before falling back to `where.exe`).
+const WINDOWS_GIT_EXE_PATHS = [
+  "C:\\Program Files\\Git\\cmd\\git.exe",
+  "C:\\Program Files (x86)\\Git\\cmd\\git.exe",
+];
+
+// Common directories where bash/zsh may live, used as fallback after PATH lookup.
+const FIXED_SHELL_DIRS = [
+  "/bin",
+  "/usr/bin",
+  "/usr/local/bin",
+  "/opt/homebrew/bin",
+];
+
+function isExecutable(shellPath: string): boolean {
+  try {
+    fs.accessSync(shellPath, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Resolve a command name (e.g. "bash") to an absolute path by searching $PATH. */
+function which(command: string): string | undefined {
+  const pathEnv = process.env.PATH;
+  if (!pathEnv) return undefined;
+  for (const dir of pathEnv.split(":")) {
+    if (!dir) continue;
+    const candidate = path.join(dir, command);
+    if (isExecutable(candidate)) {
+      return candidate;
+    }
+  }
+  return undefined;
+}
+
+function isSupportedShell(shellPath: string): boolean {
+  return shellPath.includes("bash") || shellPath.includes("zsh");
+}
+
+/**
+ * Locate the `git` executable on Windows, then infer bash.exe from it.
+ * Checks common Git for Windows install locations first, then falls back
+ * to `where.exe git` (aligned with Claude Code's findExecutable('git')).
+ * Returns the inferred bash.exe path, or undefined if not found.
+ */
+function inferGitBashFromGit(): string | undefined {
+  // 1. Common git.exe locations
+  let gitExe: string | undefined;
+  for (const candidate of WINDOWS_GIT_EXE_PATHS) {
+    if (fs.existsSync(candidate)) {
+      gitExe = candidate;
+      break;
+    }
+  }
+
+  // 2. Fallback: where.exe git
+  if (!gitExe) {
+    try {
+      const result = execFileSync("where", ["git"], {
+        stdio: "pipe",
+        encoding: "utf8",
+        timeout: 3000,
+      }).trim();
+      // where.exe may return multiple lines; take the first non-empty one.
+      gitExe = result.split(/\r?\n/).find((line) => line.trim()) || undefined;
+    } catch {
+      gitExe = undefined;
+    }
+  }
+
+  if (!gitExe) return undefined;
+
+  // git.exe is at <install>/cmd/git.exe → bash.exe is at <install>/bin/bash.exe
+  // join treats git.exe as a segment, so ".." cancels it (→ cmd dir),
+  // the second ".." cancels cmd (→ <install>), then bin/bash.exe.
+  const bashPath = path.win32.join(gitExe, "..", "..", "bin", "bash.exe");
+  if (fs.existsSync(bashPath)) {
+    return bashPath;
   }
+  return undefined;
+}
 
-  if (process.env.GIT_BASH_PATH) {
-    return process.env.GIT_BASH_PATH;
+/**
+ * Resolve a bash or zsh binary on macOS/Linux.
+ *
+ * Priority (aligned with Claude Code's findSuitableShell):
+ *   1. WAVE_SHELL env var (only if it points to an executable bash/zsh)
+ *   2. $SHELL (only if it is bash/zsh)
+ *   3. `which bash` / `which zsh` discovered on $PATH
+ *   4. Common fixed locations (/bin, /usr/bin, /usr/local/bin, /opt/homebrew/bin)
+ *
+ * When $SHELL is bash, bash is preferred; otherwise zsh is preferred. This
+ * matters because /bin/sh may be dash (Debian/Ubuntu) or POSIX-mode bash
+ * (macOS), neither of which supports bashisms like process substitution
+ * `<()`, causing `eval '<()...'` to fail at parse time.
+ */
+function resolveUnixShell(): string | undefined {
+  // 1. WAVE_SHELL env override
+  const waveShell = process.env.WAVE_SHELL;
+  if (waveShell && isSupportedShell(waveShell) && isExecutable(waveShell)) {
+    return waveShell;
   }
 
+  // 2. $SHELL (only bash/zsh)
+  const envShell = process.env.SHELL;
+  const isEnvShellSupported = !!envShell && isSupportedShell(envShell);
+  const preferBash = envShell?.includes("bash") ?? false;
+
+  // 3. Locate via PATH
+  const bashPath = which("bash");
+  const zshPath = which("zsh");
+
+  // 4. Fixed common locations, ordered by user preference
+  const shellOrder = preferBash ? ["bash", "zsh"] : ["zsh", "bash"];
+  const candidates = shellOrder.flatMap((shell) =>
+    FIXED_SHELL_DIRS.map((dir) => `${dir}/${shell}`),
+  );
+
+  // Discovered PATH paths: preferred type first, the other as fallback
+  if (preferBash) {
+    if (bashPath) candidates.unshift(bashPath);
+    if (zshPath) candidates.push(zshPath);
+  } else {
+    if (zshPath) candidates.unshift(zshPath);
+    if (bashPath) candidates.push(bashPath);
+  }
+
+  // Always prioritize $SHELL if it is a supported, executable shell
+  if (isEnvShellSupported && envShell && isExecutable(envShell)) {
+    candidates.unshift(envShell);
+  }
+
+  return candidates.find((candidate) => isExecutable(candidate));
+}
+
+/**
+ * Resolve the Git Bash path on Windows.
+ *
+ * Priority (aligned with Claude Code's findGitBashPath):
+ *   1. WAVE_GIT_BASH_PATH env var
+ *   2. Infer from `git` executable location (<git dir>/../../bin/bash.exe)
+ *   3. Common install paths (C:\Program Files\Git\bin\bash.exe, etc.)
+ */
+function resolveWindowsShell(): string | undefined {
+  // 1. Env var override
+  if (process.env.WAVE_GIT_BASH_PATH) {
+    return process.env.WAVE_GIT_BASH_PATH;
+  }
+
+  // 2. Infer from git executable location
+  const inferred = inferGitBashFromGit();
+  if (inferred) {
+    return inferred;
+  }
+
+  // 4. Common install paths
   const paths = [
     ...WINDOWS_GIT_BASH_PATHS,
     process.env.LOCALAPPDATA
@@ -21,11 +172,19 @@ export function resolveShellPath(): string | undefined {
       : null,
   ].filter(Boolean) as string[];
 
-  for (const path of paths) {
-    if (fs.existsSync(path)) {
-      return path;
+  for (const p of paths) {
+    if (fs.existsSync(p)) {
+      return p;
     }
   }
 
   return undefined;
 }
+
+export function resolveShellPath(): string | undefined {
+  if (process.platform === "win32") {
+    return resolveWindowsShell();
+  }
+
+  return resolveUnixShell();
+}

package/src/utils/worktreeSession.ts

@@ -1,9 +1,11 @@
 /**
- * Module-level worktree session state tracking.
- * Analogous to Claude Code's currentWorktreeSession in worktree.ts.
+ * Worktree session state tracking.
  *
- * Tracks whether the current session entered a worktree via EnterWorktree tool,
- * so ExitWorktree can validate scope and restore the original CWD.
+ * The session state is stored per-agent in each session's DI container (see the
+ * "WorktreeSession" container slot registered in containerSetup.ts and accessed via
+ * AIManager.getWorktreeSession()/setWorktreeSession()). This keeps worktree state
+ * isolated per session in stdio multi-agent mode — a process-level singleton would
+ * leak state across concurrent sessions (see specs/047-worktree.md FR-042).
  */
 
 export interface WorktreeSession {
@@ -22,15 +24,3 @@ export interface WorktreeSession {
   /** The HEAD commit of the original branch at worktree creation time */
   originalHeadCommit?: string;
 }
-
-let currentWorktreeSession: WorktreeSession | null = null;
-
-export function getCurrentWorktreeSession(): WorktreeSession | null {
-  return currentWorktreeSession;
-}
-
-export function setCurrentWorktreeSession(
-  session: WorktreeSession | null,
-): void {
-  currentWorktreeSession = session;
-}