wave-agent-sdk 0.16.9 → 0.16.12

package/src/utils/gitUtils.ts

@@ -82,69 +82,144 @@ export function getGitMainRepoRoot(cwd: string): string {
 }
 
 /**
- * Get the default remote branch (e.g., origin/main)
- * @param cwd Working directory
- * @returns Default remote branch name
+ * Resolve the git directory for a repository by walking up from `cwd`.
+ * Handles both normal repos (.git is a directory) and worktrees
+ * (.git is a file pointing to the main repo's worktree git dir).
+ * For worktrees, reads the `commondir` file to find the common git dir.
+ * @param cwd Working directory to start searching from
+ * @returns Absolute path to the git directory, or null if not found
  */
-export function getDefaultRemoteBranch(cwd: string): string {
-  // 1. Try git symbolic-ref refs/remotes/origin/HEAD
-  try {
-    const head = execSync("git symbolic-ref refs/remotes/origin/HEAD", {
-      cwd,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-    return head.replace("refs/remotes/", "");
-  } catch {
-    // Ignore error and proceed to next step
+export function resolveGitDir(cwd: string): string | null {
+  let currentPath = path.resolve(cwd);
+  while (currentPath !== path.dirname(currentPath)) {
+    const gitPath = path.join(currentPath, ".git");
+    if (fsSync.existsSync(gitPath)) {
+      const stat = fsSync.statSync(gitPath);
+      if (stat.isDirectory()) {
+        // Normal repo: .git is a directory
+        return gitPath;
+      }
+      // Worktree: .git is a file containing "gitdir: <path>"
+      try {
+        const content = fsSync.readFileSync(gitPath, "utf8").trim();
+        const prefix = "gitdir: ";
+        if (content.startsWith(prefix)) {
+          const worktreeGitDir = content.substring(prefix.length);
+          // Read commondir to find the common git dir
+          const commondirPath = path.join(worktreeGitDir, "commondir");
+          if (fsSync.existsSync(commondirPath)) {
+            const commondirRel = fsSync
+              .readFileSync(commondirPath, "utf8")
+              .trim();
+            return path.resolve(worktreeGitDir, commondirRel);
+          }
+          // Fallback: resolve ../.. from the worktree git dir
+          return path.resolve(worktreeGitDir, "..", "..");
+        }
+      } catch {
+        return null;
+      }
+    }
+    currentPath = path.dirname(currentPath);
   }
+  return null;
+}
 
-  // 2. Check if origin/main exists
+/**
+ * Read a symbolic ref file in the git directory.
+ * If the file content starts with "ref: ", returns the target ref path.
+ * Symbolic refs are never packed in packed-refs, so only loose refs are checked.
+ * @param gitDir Absolute path to the git directory
+ * @param refPath Relative path to the ref file (e.g., "refs/remotes/origin/HEAD")
+ * @returns The symbolic ref target, or null if not a symbolic ref or on error
+ */
+function readSymref(gitDir: string, refPath: string): string | null {
   try {
-    execSync("git rev-parse --verify origin/main", {
-      cwd,
-      stdio: "ignore",
-    });
-    return "origin/main";
+    const fullPath = path.join(gitDir, refPath);
+    const content = fsSync.readFileSync(fullPath, "utf8").trim();
+    if (content.startsWith("ref: ")) {
+      return content.substring("ref: ".length);
+    }
+    return null;
   } catch {
-    // Ignore error and proceed to next step
+    return null;
   }
+}
 
-  // 3. Check if origin/master exists
+/**
+ * Check if a git ref exists, checking both loose refs and packed-refs.
+ * @param gitDir Absolute path to the git directory
+ * @param refPath Relative path to the ref (e.g., "refs/remotes/origin/main")
+ * @returns True if the ref exists, false otherwise
+ */
+function refExists(gitDir: string, refPath: string): boolean {
+  // 1. Check loose ref
+  const loosePath = path.join(gitDir, refPath);
+  if (fsSync.existsSync(loosePath)) {
+    return true;
+  }
+  // 2. Check packed-refs
   try {
-    execSync("git rev-parse --verify origin/master", {
-      cwd,
-      stdio: "ignore",
-    });
-    return "origin/master";
+    const packedRefsPath = path.join(gitDir, "packed-refs");
+    const content = fsSync.readFileSync(packedRefsPath, "utf8");
+    for (const line of content.split("\n")) {
+      // Skip comments and peeled lines
+      if (line.startsWith("#") || line.startsWith("^")) {
+        continue;
+      }
+      // Format: <sha> <refPath>
+      const parts = line.split(" ");
+      if (parts.length >= 2 && parts[1] === refPath) {
+        return true;
+      }
+    }
   } catch {
-    // Ignore error and proceed to next step
+    // packed-refs doesn't exist or can't be read
   }
+  return false;
+}
 
-  // 4. Try to get the current branch's upstream
-  try {
-    return execSync("git rev-parse --abbrev-ref --symbolic-full-name @{u}", {
-      cwd,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-  } catch {
-    // Ignore error and proceed to next step
+/**
+ * Get the default remote branch (e.g., origin/main) using filesystem reads.
+ * No subprocess calls — matches Claude Code's approach.
+ *
+ * Priority:
+ * 1. Read refs/remotes/origin/HEAD symref → extract branch name (verify it exists)
+ * 2. Check if refs/remotes/origin/main ref exists
+ * 3. Check if refs/remotes/origin/master ref exists
+ * 4. Hardcoded "main" fallback
+ *
+ * @param cwd Working directory
+ * @returns Default remote branch name
+ */
+export function getDefaultRemoteBranch(cwd: string): string {
+  const gitDir = resolveGitDir(cwd);
+  if (!gitDir) {
+    return "main";
   }
 
-  // 5. Try to get the current branch name
-  try {
-    return execSync("git rev-parse --abbrev-ref HEAD", {
-      cwd,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-  } catch {
-    // Ignore error and proceed to next step
+  // 1. Try reading origin/HEAD symref
+  const symref = readSymref(gitDir, "refs/remotes/origin/HEAD");
+  if (symref) {
+    const branch = symref.replace("refs/remotes/", "");
+    // Verify the resolved branch actually exists (origin/HEAD can be stale)
+    if (refExists(gitDir, symref)) {
+      return branch;
+    }
+  }
+
+  // 2. Check if origin/main exists
+  if (refExists(gitDir, "refs/remotes/origin/main")) {
+    return "origin/main";
+  }
+
+  // 3. Check if origin/master exists
+  if (refExists(gitDir, "refs/remotes/origin/master")) {
+    return "origin/master";
   }
 
-  // 6. Fallback to origin/main
-  return "origin/main";
+  // 4. Hardcoded fallback
+  return "main";
 }
 
 /**

package/src/utils/mcpUtils.ts

@@ -1,6 +1,8 @@
 import { ChatCompletionFunctionTool } from "openai/resources.js";
 import type { ToolPlugin, ToolResult, ToolContext } from "../tools/types.js";
 import type { McpTool, McpServerStatus } from "../types/index.js";
+import { processToolResult } from "./toolResultStorage.js";
+import { DEFAULT_MAX_RESULT_SIZE_CHARS } from "../constants/toolLimits.js";
 
 /**
  * Recursively clean schema to remove unsupported fields
@@ -97,9 +99,18 @@ export function createMcpToolPlugin(
     ): Promise<ToolResult> {
       try {
         const result = await executeTool(prefixedName, args, context);
+
+        // Process content for size limits — only text content, not images
+        const processedContent = processToolResult(
+          result.content || `Executed ${mcpTool.name}`,
+          DEFAULT_MAX_RESULT_SIZE_CHARS,
+          `mcp_${serverName}_${mcpTool.name}`,
+        );
+
         return {
           success: true,
-          content: result.content || `Executed ${mcpTool.name}`,
+          content: processedContent,
+          images: result.images,
         };
       } catch (error) {
         return {

package/src/utils/openaiClient.ts

@@ -176,8 +176,11 @@ export class OpenAIClient {
       error.status = response.status;
       error.body = errorBody;
 
-      if (response.status === 429 && attempt < maxRetries) {
-        logger.warn("OpenAI API 429 Too Many Requests, retrying...", {
+      const retryableStatus =
+        response.status === 429 ||
+        (response.status >= 500 && response.status !== 501);
+      if (retryableStatus && attempt < maxRetries) {
+        logger.warn("OpenAI API error, retrying...", {
           attempt: attempt + 1,
           status: response.status,
         });

package/src/utils/toolResultStorage.ts

@@ -0,0 +1,117 @@
+/**
+ * Shared tool result persistence and truncation logic.
+ *
+ * When a tool result exceeds a size threshold, the full content is saved to a
+ * file in /tmp/wave-tool-results/ and the model receives a <persisted-output>
+ * preview with the file path so it can use the Read tool to access the full output.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import {
+  DEFAULT_MAX_RESULT_SIZE_CHARS,
+  PREVIEW_SIZE_BYTES,
+} from "../constants/toolLimits.js";
+import { logger } from "./globalLogger.js";
+
+const TOOL_RESULTS_DIR = path.join(os.tmpdir(), "wave-tool-results");
+
+/**
+ * Get (and create if needed) the tool-results directory.
+ * Uses /tmp/wave-tool-results/ for simplicity and automatic OS cleanup.
+ */
+export function getToolResultsDir(): string {
+  fs.mkdirSync(TOOL_RESULTS_DIR, { recursive: true });
+  return TOOL_RESULTS_DIR;
+}
+
+/**
+ * Persist full tool output to a file in the tool-results directory.
+ * Returns the file path on success, or undefined on failure.
+ */
+export function persistToolResult(
+  content: string,
+  prefix: string = "tool",
+): string | undefined {
+  try {
+    const dir = getToolResultsDir();
+    const id = `${prefix}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    const filePath = path.join(dir, `${id}.txt`);
+    fs.writeFileSync(filePath, content, "utf8");
+    return filePath;
+  } catch (error) {
+    logger?.error("Failed to persist tool result:", error);
+    return undefined;
+  }
+}
+
+/**
+ * Generate a preview from content: first `previewSize` characters with ellipsis.
+ */
+export function generatePreview(
+  content: string,
+  previewSize: number = PREVIEW_SIZE_BYTES,
+): string {
+  if (content.length <= previewSize) return content;
+  return content.substring(0, previewSize) + "\n...";
+}
+
+/**
+ * Build the <persisted-output> wrapper message that the model sees.
+ *
+ * Example output:
+ * <persisted-output>
+ * Output too large (150,000 characters). Full output saved to: /tmp/wave-tool-results/mcp_server_tool_12345.txt
+ * Preview (first 2,048 characters):
+ * {preview content}
+ * ...
+ * </persisted-output>
+ */
+export function buildPersistedOutputMessage(
+  totalChars: number,
+  filePath: string,
+  preview: string,
+): string {
+  return [
+    "<persisted-output>",
+    `Output too large (${totalChars.toLocaleString()} characters). Full output saved to: ${filePath}`,
+    `Preview (first ${PREVIEW_SIZE_BYTES.toLocaleString()} characters):`,
+    preview,
+    "</persisted-output>",
+  ].join("\n");
+}
+
+/**
+ * Process tool result: if content exceeds maxChars, persist to file and return
+ * truncated content with <persisted-output> wrapper. Otherwise return unchanged.
+ *
+ * This is the main entry point for both MCP and bash tools.
+ *
+ * @param content - The tool result content
+ * @param maxChars - Maximum characters before persistence kicks in (defaults to DEFAULT_MAX_RESULT_SIZE_CHARS)
+ * @param prefix - File name prefix for the persisted file (e.g. "bash", "mcp")
+ * @returns The content to send to the model (either original or persisted-output wrapper)
+ */
+export function processToolResult(
+  content: string,
+  maxChars: number = DEFAULT_MAX_RESULT_SIZE_CHARS,
+  prefix: string = "tool",
+): string {
+  if (content.length <= maxChars) {
+    return content;
+  }
+
+  const filePath = persistToolResult(content, prefix);
+
+  if (filePath) {
+    const preview = generatePreview(content);
+    return buildPersistedOutputMessage(content.length, filePath, preview);
+  }
+
+  // Fallback: truncation only (persistence failed)
+  return (
+    content.substring(0, maxChars) +
+    "\n\n... (output truncated, failed to persist full output)"
+  );
+}

package/src/utils/worktreeUtils.ts

@@ -174,6 +174,69 @@ export function createWorktree(name: string, cwd: string): WorktreeInfo {
         );
       }
     }
+    if (
+      stderr.includes("not a valid object name") ||
+      stderr.includes("unknown revision")
+    ) {
+      // Base branch not fetched yet — try fetching then retrying
+      const branchNameOnly = baseBranch.split("/").pop()!;
+      try {
+        execSync(`git fetch origin ${branchNameOnly}`, {
+          cwd: repoRoot,
+          stdio: ["ignore", "pipe", "pipe"],
+          env: {
+            ...process.env,
+            GIT_TERMINAL_PROMPT: "0",
+            GIT_ASKPASS: "",
+          },
+        });
+        execSync(
+          `git worktree add -b ${branchName} "${worktreePath}" ${baseBranch}`,
+          {
+            cwd: repoRoot,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: {
+              ...process.env,
+              GIT_TERMINAL_PROMPT: "0",
+              GIT_ASKPASS: "",
+            },
+          },
+        );
+        return {
+          name,
+          path: worktreePath,
+          branch: branchName,
+          repoRoot,
+          isNew: true,
+          originalHeadCommit,
+        };
+      } catch {
+        // Fetch or retry failed — fall back to HEAD
+        try {
+          execSync(`git worktree add -b ${branchName} "${worktreePath}" HEAD`, {
+            cwd: repoRoot,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: {
+              ...process.env,
+              GIT_TERMINAL_PROMPT: "0",
+              GIT_ASKPASS: "",
+            },
+          });
+          return {
+            name,
+            path: worktreePath,
+            branch: branchName,
+            repoRoot,
+            isNew: true,
+            originalHeadCommit,
+          };
+        } catch {
+          throw new Error(
+            `Failed to create worktree: ${(error as Error).message}\n${stderr}`,
+          );
+        }
+      }
+    }
     throw new Error(
       `Failed to create worktree: ${(error as Error).message}\n${stderr}`,
     );