wave-agent-sdk 0.14.3 → 0.15.0

package/src/services/hook.ts

@@ -277,21 +277,6 @@ export async function executeCommands(
   return results;
 }
 
-/**
- * Execute a CwdChanged hook
- */
-export async function executeCwdChangedHooks(
-  oldCwd: string,
-  newCwd: string,
-  context: ExtendedHookExecutionContext,
-): Promise<HookExecutionResult[]> {
-  // CwdChanged hooks are executed through HookManager.executeCwdChangedHooks()
-  void context;
-  void oldCwd;
-  void newCwd;
-  return [];
-}
-
 /**
  * Validate command safety (basic checks)
  */

package/src/services/session.ts

@@ -953,7 +953,12 @@ export async function handleSessionRestoration(
       // Use only JSONL format - no legacy support
       sessionToRestore = await loadSessionFromJsonl(restoreSessionId, workdir);
       if (!sessionToRestore) {
-        throw new Error(`Session not found: ${restoreSessionId}`);
+        // Session doesn't exist on disk (e.g. new project with no messages saved yet).
+        // Gracefully fall back to starting fresh instead of throwing.
+        logger?.warn(
+          `Session ${restoreSessionId} not found on disk, starting fresh session`,
+        );
+        return;
       }
     } else if (continueLastSession) {
       // Use only JSONL format - no legacy support

package/src/tools/bashTool.ts

@@ -240,14 +240,7 @@ Try to maintain your current working directory throughout the session by using a
 
     // Foreground execution (original behavior)
     return new Promise((resolve) => {
-      // Create a temporary file to store the CWD
-      const tempCwdFile = path.join(
-        os.tmpdir(),
-        `wave_cwd_${Date.now()}_${Math.random().toString(36).substring(2, 11)}.tmp`,
-      );
-      const wrappedCommand = `${command} && pwd -P >| ${tempCwdFile}`;
-
-      const child: ChildProcess = spawn(wrappedCommand, {
+      const child: ChildProcess = spawn(command, {
         shell: true,
         stdio: "pipe",
         cwd: context.workdir,
@@ -431,55 +424,13 @@ Try to maintain your current working directory throughout the session by using a
             clearTimeout(timeoutHandle);
           }
 
-          // Read the new CWD from the temporary file
-          let newCwd: string | undefined;
-          try {
-            if (fs.existsSync(tempCwdFile)) {
-              newCwd = fs.readFileSync(tempCwdFile, "utf8").trim();
-              // Validate the path exists before calling the callback
-              fs.accessSync(newCwd, fs.constants.F_OK);
-            }
-          } catch (fileError) {
-            logger.warn(
-              `Could not read or validate new CWD from temp file ${tempCwdFile}:`,
-              fileError,
-            );
-            newCwd = undefined;
-          } finally {
-            // Ensure temp file is cleaned up even if reading fails
-            try {
-              if (fs.existsSync(tempCwdFile)) {
-                fs.unlinkSync(tempCwdFile);
-              }
-            } catch (fileError) {
-              logger.error("Failed to clean up temp CWD file:", fileError);
-            }
-          }
-
-          // If CWD changed, call the onCwdChange callback and add notification
-          let cwdChangedNotification = "";
-          if (newCwd && newCwd !== context.workdir && context.onCwdChange) {
-            const isInSafeZone =
-              context.permissionManager?.isPathInSafeZone?.(newCwd) ?? true;
-
-            if (isInSafeZone) {
-              context.onCwdChange(newCwd);
-            } else if (context.originalWorkdir) {
-              context.onCwdChange(context.originalWorkdir);
-              cwdChangedNotification = `Shell cwd was reset to ${context.originalWorkdir}\n`;
-            } else {
-              context.onCwdChange(newCwd);
-            }
-          }
-
           const exitCode = code ?? 0;
           const combinedOutput =
             outputBuffer + (errorBuffer ? "\n" + errorBuffer : "");
 
           // Handle large output by truncation and persistence if needed
           const finalOutput =
-            cwdChangedNotification +
-            (combinedOutput || `Command executed with exit code: ${exitCode}`);
+            combinedOutput || `Command executed with exit code: ${exitCode}`;
           const content = processOutput(finalOutput);
 
           const lines = combinedOutput.trim().split("\n");

package/src/tools/editTool.ts

@@ -136,7 +136,7 @@ Usage:
         return {
           success: false,
           content: "",
-          error: analyzeEditMismatch(originalContent, oldString),
+          error: analyzeEditMismatch(),
         };
       }
 

package/src/tools/types.ts

@@ -58,7 +58,6 @@ export interface ToolContext {
   abortSignal?: AbortSignal;
   backgroundTaskManager?: import("../managers/backgroundTaskManager.js").BackgroundTaskManager;
   workdir: string;
-  originalWorkdir?: string;
   /** Permission mode for this tool execution */
   permissionMode?: PermissionMode;
   /** Custom permission callback */
@@ -104,6 +103,4 @@ export interface ToolContext {
   };
   /** State of files read in the current session for deduplication */
   readFileState?: Map<string, { mtime: number; hash: string }>;
-  /** Callback to notify when the current working directory changes */
-  onCwdChange?: (newCwd: string) => void;
 }

package/src/types/agent.ts

@@ -98,6 +98,5 @@ export interface AgentCallbacks
   onConfiguredModelsChange?: (models: string[]) => void;
   onLoadingChange?: (loading: boolean) => void;
   onCommandRunningChange?: (running: boolean) => void;
-  onWorkdirChange?: (newCwd: string) => void;
   onQueuedMessagesChange?: (messages: QueuedMessage[]) => void;
 }

package/src/types/hooks.ts

@@ -21,7 +21,6 @@ export type HookEvent =
   | "SubagentStop"
   | "PermissionRequest"
   | "WorktreeCreate"
-  | "CwdChanged"
   | "SessionStart"
   | "SessionEnd";
 
@@ -110,7 +109,6 @@ export function isValidHookEvent(event: string): event is HookEvent {
     "SubagentStop",
     "PermissionRequest",
     "WorktreeCreate",
-    "CwdChanged",
     "SessionStart",
     "SessionEnd",
   ].includes(event);
@@ -169,7 +167,7 @@ export interface HookJsonInput {
   session_id: string; // Format: "wave_session_{uuid}_{shortId}"
   transcript_path: string; // Format: "~/.wave/sessions/session_{shortId}.json"
   cwd: string; // Absolute path to current working directory
-  hook_event_name: HookEvent; // "PreToolUse" | "PostToolUse" | "UserPromptSubmit" | "Stop" | "SubagentStop" | "PermissionRequest" | "WorktreeCreate" | "CwdChanged" | "SessionStart"
+  hook_event_name: HookEvent; // "PreToolUse" | "PostToolUse" | "UserPromptSubmit" | "Stop" | "SubagentStop" | "PermissionRequest" | "WorktreeCreate" | "SessionStart"
 
   // Optional fields based on event type
   tool_name?: string; // Present for PreToolUse, PostToolUse, PermissionRequest
@@ -178,8 +176,6 @@ export interface HookJsonInput {
   user_prompt?: string; // Present for UserPromptSubmit only
   subagent_type?: string; // Present when hook is executed by a subagent
   name?: string; // Present for WorktreeCreate events
-  old_cwd?: string; // Present for CwdChanged events
-  new_cwd?: string; // Present for CwdChanged events
   source?: SessionStartSource; // Present for SessionStart events
   agent_type?: string; // Present for SessionStart events
   end_source?: SessionEndSource; // Present for SessionEnd events
@@ -196,8 +192,6 @@ export interface ExtendedHookExecutionContext extends HookExecutionContext {
   userPrompt?: string; // User prompt text (UserPromptSubmit only)
   subagentType?: string; // Subagent type when hook is executed by a subagent
   worktreeName?: string; // Worktree name (WorktreeCreate only)
-  oldCwd?: string; // Previous working directory (CwdChanged only)
-  newCwd?: string; // New working directory (CwdChanged only)
   source?: SessionStartSource; // Session start source (SessionStart only)
   agentType?: string; // Agent type identifier (SessionStart only)
   endSource?: SessionEndSource; // Session end source (SessionEnd only)

package/src/utils/constants.ts

@@ -29,5 +29,5 @@ export const USER_MEMORY_FILE = path.join(DATA_DIRECTORY, "AGENTS.md");
 /**
  * AI related constants
  */
-export const DEFAULT_WAVE_MAX_INPUT_TOKENS = 96000; // Default token limit
-export const DEFAULT_WAVE_MAX_OUTPUT_TOKENS = 8192; // Default output token limit
+export const DEFAULT_WAVE_MAX_INPUT_TOKENS = 128000; // Default token limit
+export const DEFAULT_WAVE_MAX_OUTPUT_TOKENS = 16384; // Default output token limit

package/src/utils/convertMessagesForAPI.ts

@@ -2,7 +2,7 @@ import type { Message } from "../types/index.js";
 import { convertImageToBase64 } from "./messageOperations.js";
 import { taskNotificationToXml } from "./notificationXml.js";
 import { ChatCompletionMessageToolCall } from "openai/resources";
-import { stripAnsiColors } from "./stringUtils.js";
+import { recoverTruncatedJson, stripAnsiColors } from "./stringUtils.js";
 import {
   ChatCompletionContentPart,
   ChatCompletionMessageParam,
@@ -10,7 +10,8 @@ import {
 import { logger } from "./globalLogger.js";
 
 /**
- * Safely handle tool call parameters, ensuring a legal JSON string is returned
+ * Safely handle tool call parameters, ensuring a legal JSON string is returned.
+ * Attempts to recover truncated JSON (e.g., missing closing braces).
  * @param args Tool call parameters
  * @returns Legal JSON string
  */
@@ -23,12 +24,18 @@ function safeToolArguments(args: string): string {
     // Try to parse as JSON to validate format
     JSON.parse(args);
     return args;
-  } catch (error) {
-    logger.error(`Invalid tool arguments: ${args}`, error);
-    // If not valid JSON, return a fallback empty object with the original string as a comment or property
-    return JSON.stringify({
-      invalid_arguments: args,
-    });
+  } catch {
+    // Attempt to recover truncated JSON
+    const recovered = recoverTruncatedJson(args);
+    try {
+      JSON.parse(recovered);
+      return recovered;
+    } catch {
+      // Truly malformed JSON — return sanitized fallback
+      return JSON.stringify({
+        invalid_arguments: args,
+      });
+    }
   }
 }
 

package/src/utils/editUtils.ts

@@ -1,7 +1,6 @@
 /**
  * Utility functions for file editing tools
  */
-import { formatLineNumberPrefix } from "./stringUtils.js";
 
 /**
  * Escape regular expression special characters
@@ -11,77 +10,8 @@ export function escapeRegExp(string: string): string {
 }
 
 /**
- * Analyze why an edit failed by finding the best partial match and highlighting mismatches.
+ * Returns a generic error message when old_string is not found.
  */
-export function analyzeEditMismatch(
-  content: string,
-  searchString: string,
-): string {
-  const contentLines = content.split("\n");
-  const searchLines = searchString.split("\n");
-
-  if (searchLines.length === 0 || contentLines.length === 0) {
-    return "old_string not found in file (empty search or content)";
-  }
-
-  let bestMatchIndex = -1;
-  let bestMatchScore = -1;
-
-  // Sliding window to find the best partial match
-  for (let i = 0; i <= contentLines.length - searchLines.length; i++) {
-    let currentScore = 0;
-    for (let j = 0; j < searchLines.length; j++) {
-      if (contentLines[i + j] === searchLines[j]) {
-        currentScore++;
-      }
-    }
-
-    // Heuristic: prioritize matches where first or last lines match
-    if (contentLines[i] === searchLines[0]) currentScore += 0.5;
-    if (
-      contentLines[i + searchLines.length - 1] ===
-      searchLines[searchLines.length - 1]
-    )
-      currentScore += 0.5;
-
-    // Also consider trimmed matches to catch indentation issues
-    for (let j = 0; j < searchLines.length; j++) {
-      if (
-        contentLines[i + j].trim() === searchLines[j].trim() &&
-        contentLines[i + j] !== searchLines[j]
-      ) {
-        currentScore += 0.1;
-      }
-    }
-
-    if (currentScore > bestMatchScore) {
-      bestMatchScore = currentScore;
-      bestMatchIndex = i;
-    }
-  }
-
-  // If no decent match found (score <= 0), return generic message
-  if (bestMatchScore <= 0) {
-    return "old_string not found in file (no similar block found)";
-  }
-
-  // Generate detailed report
-  const reportLines: string[] = [
-    `old_string not found in file. Best partial match found at line ${bestMatchIndex + 1}:`,
-  ];
-
-  for (let j = 0; j < searchLines.length; j++) {
-    const lineNum = bestMatchIndex + j + 1;
-    const actualLine = contentLines[bestMatchIndex + j];
-    const expectedLine = searchLines[j];
-
-    if (actualLine === expectedLine) {
-      reportLines.push(`${formatLineNumberPrefix(lineNum)}${actualLine}`);
-    } else {
-      reportLines.push(`${formatLineNumberPrefix(lineNum)}- ${expectedLine}`);
-      reportLines.push(`${formatLineNumberPrefix(lineNum)}+ ${actualLine}`);
-    }
-  }
-
-  return reportLines.join("\n");
+export function analyzeEditMismatch(): string {
+  return "old_string not found in file";
 }

package/src/utils/markdownParser.ts

@@ -1,7 +1,13 @@
-import { readFileSync } from "fs";
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
 import { exec } from "child_process";
 import { promisify } from "util";
+import { join } from "path";
+import { tmpdir } from "os";
 import type { CustomSlashCommandConfig } from "../types/index.js";
+import {
+  SKILL_BASH_MAX_OUTPUT_CHARS,
+  PREVIEW_SIZE_BYTES,
+} from "../constants/toolLimits.js";
 
 const execAsync = promisify(exec);
 
@@ -138,17 +144,52 @@ export interface BashCommandResult {
   exitCode: number;
 }
 
+/**
+ * Block syntax pattern: ```! command ```
+ */
+const BLOCK_BASH_REGEX = /```!\s*\n?([\s\S]*?)\n?```/g;
+
+/**
+ * Inline syntax pattern: !`command`
+ */
+const INLINE_BASH_REGEX = /!`([^`]+)`/g;
+
 export function parseBashCommands(content: string): {
   commands: string[];
   processedContent: string;
 } {
-  const bashCommandRegex = /!`([^`]+)`/g;
+  // Performance gate: skip expensive regex if no bash pattern exists
+  // Covers the common case where 93% of skills have no bash substitution
+  if (!content.includes("!`") && !content.includes("```!")) {
+    return { commands: [], processedContent: content };
+  }
+
   const commands: string[] = [];
-  let match;
 
-  // Extract all bash commands
-  while ((match = bashCommandRegex.exec(content)) !== null) {
-    commands.push(match[1]);
+  // Extract block commands
+  let blockMatch;
+  const blockRegex = new RegExp(
+    BLOCK_BASH_REGEX.source,
+    BLOCK_BASH_REGEX.flags,
+  );
+  while ((blockMatch = blockRegex.exec(content)) !== null) {
+    const cmd = blockMatch[1].trim();
+    if (cmd) {
+      commands.push(cmd);
+    }
+  }
+
+  // Extract inline commands
+  let inlineMatch;
+  const inlineRegex = new RegExp(
+    INLINE_BASH_REGEX.source,
+    INLINE_BASH_REGEX.flags,
+  );
+  while ((inlineMatch = inlineRegex.exec(content)) !== null) {
+    const cmd = inlineMatch[1].trim();
+    if (cmd) {
+      commands.push(cmd);
+    }
   }
 
   // For now, return the content as-is. The actual command execution
@@ -160,22 +201,55 @@ export function parseBashCommands(content: string): {
 }
 
 /**
- * Replace bash command placeholders with their outputs
+ * Truncate output if it exceeds the size limit.
+ * Writes to a temp file and returns a preview + file path if truncated.
+ */
+export function truncateOutput(output: string): string {
+  if (output.length <= SKILL_BASH_MAX_OUTPUT_CHARS) {
+    return output;
+  }
+
+  const preview = output.slice(0, PREVIEW_SIZE_BYTES);
+  const tempDir = join(tmpdir(), "wave-skill-bash");
+  mkdirSync(tempDir, { recursive: true });
+
+  const tempFile = join(
+    tempDir,
+    `output-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.txt`,
+  );
+  writeFileSync(tempFile, output, "utf-8");
+
+  return `${preview}\n\n[Output truncated (${output.length} chars). Full output saved to: ${tempFile}]`;
+}
+
+/**
+ * Replace bash command placeholders with their outputs.
+ * Uses function replacer to avoid $$, $&, $' corruption in shell output.
+ * Handles both inline (!`cmd`) and block (```! cmd ```) syntax.
  */
 export function replaceBashCommandsWithOutput(
   content: string,
   results: BashCommandResult[],
 ): string {
-  const bashCommandRegex = /!`([^`]+)`/g;
   let processedContent = content;
   let commandIndex = 0;
 
-  processedContent = processedContent.replace(bashCommandRegex, (match) => {
+  // Replace block syntax first: ```! command ```
+  processedContent = processedContent.replace(BLOCK_BASH_REGEX, () => {
+    if (commandIndex < results.length) {
+      const result = results[commandIndex++];
+      return truncateOutput(result.output);
+    }
+    return "";
+  });
+
+  // Replace inline syntax: !`command`
+  processedContent = processedContent.replace(INLINE_BASH_REGEX, () => {
     if (commandIndex < results.length) {
       const result = results[commandIndex++];
-      return result.output;
+      return truncateOutput(result.output);
     }
-    return match;
+    return "";
   });
 
   return processedContent;

package/src/utils/openaiClient.ts

@@ -177,28 +177,17 @@ export class OpenAIClient {
       error.body = errorBody;
 
       if (response.status === 429 && attempt < maxRetries) {
-        const responseHeaders: Record<string, string> = {};
-        response.headers.forEach((value, key) => {
-          responseHeaders[key] = value;
-        });
         logger.warn("OpenAI API 429 Too Many Requests, retrying...", {
           attempt: attempt + 1,
           status: response.status,
-          responseHeaders,
         });
         lastError = error;
         continue;
       }
 
-      const responseHeaders: Record<string, string> = {};
-      response.headers.forEach((value, key) => {
-        responseHeaders[key] = value;
-      });
       logger.error("OpenAI API Error:", {
         status: response.status,
         statusText: response.statusText,
-        requestHeaders: headers,
-        responseHeaders,
         errorBody,
       });
       throw error;

package/src/utils/stringUtils.ts

@@ -92,6 +92,49 @@ export function formatLineNumberPrefix(lineNumber: number): string {
   return `${lineNumber.toString().padStart(6)}\t`;
 }
 
+/**
+ * Attempt to recover truncated JSON (e.g., missing closing braces due to max tokens).
+ * Tracks brace depth and only recovers if there are unclosed `{` braces.
+ * Will NOT recover if there are unclosed `[` brackets (can't guess the content).
+ * @param jsonStr Potentially truncated JSON string
+ * @returns Recovered JSON string, or the original if unrecoverable
+ */
+export function recoverTruncatedJson(jsonStr: string): string {
+  let braceDepth = 0;
+  let bracketDepth = 0;
+  let inString = false;
+  let escaped = false;
+
+  for (const ch of jsonStr) {
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\" && inString) {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (!inString) {
+      if (ch === "{") braceDepth++;
+      if (ch === "}") braceDepth--;
+      if (ch === "[") bracketDepth++;
+      if (ch === "]") bracketDepth--;
+    }
+  }
+
+  // Build recovery suffix
+  let suffix = "";
+  if (inString) suffix += '"'; // Close unclosed string
+  if (braceDepth > 0 && bracketDepth === 0) {
+    suffix += "}".repeat(braceDepth);
+  }
+  return suffix ? jsonStr + suffix : jsonStr;
+}
+
 /**
  * Efficiently get the last N lines of a string without splitting the whole string.
  */