wave-agent-sdk 0.14.4 → 0.15.0

package/src/managers/hookManager.ts

@@ -669,7 +669,6 @@ export class HookManager {
       event === "Stop" ||
       event === "SubagentStop" ||
       event === "WorktreeCreate" ||
-      event === "CwdChanged" ||
       event === "SessionStart" ||
       event === "SessionEnd"
     ) {
@@ -773,7 +772,6 @@ export class HookManager {
           SubagentStop: 0,
           PermissionRequest: 0,
           WorktreeCreate: 0,
-          CwdChanged: 0,
           SessionStart: 0,
           SessionEnd: 0,
         },
@@ -788,7 +786,6 @@ export class HookManager {
       SubagentStop: 0,
       PermissionRequest: 0,
       WorktreeCreate: 0,
-      CwdChanged: 0,
       SessionStart: 0,
       SessionEnd: 0,
     };
@@ -815,35 +812,6 @@ export class HookManager {
     };
   }
 
-  /**
-   * Execute CwdChanged hooks.
-   */
-  async executeCwdChangedHooks(
-    oldCwd: string,
-    newCwd: string,
-    sessionId: string,
-    transcriptPath: string,
-    env: Record<string, string>,
-  ): Promise<HookExecutionResult[]> {
-    const context: ExtendedHookExecutionContext = {
-      event: "CwdChanged",
-      projectDir: this.workdir,
-      timestamp: new Date(),
-      sessionId,
-      transcriptPath,
-      cwd: newCwd,
-      oldCwd,
-      newCwd,
-      env,
-    };
-    const results = await this.executeHooks("CwdChanged", context);
-    if (results.length > 0) {
-      // For CwdChanged hooks, we don't block, just log errors
-      this.processHookResults("CwdChanged", results);
-    }
-    return results;
-  }
-
   /**
    * Register hooks provided by a plugin
    */

package/src/managers/permissionManager.ts

@@ -131,7 +131,7 @@ export class PermissionManager {
   private planFilePath?: string;
   private worktreeName?: string;
   private mainRepoRoot?: string;
-  private originalWorkdir?: string;
+  private workdir?: string;
   private onConfiguredPermissionModeChange?: (mode: PermissionMode) => void;
   private _logger?: Logger;
 
@@ -153,7 +153,7 @@ export class PermissionManager {
 
     this.worktreeName = this.container.get<string>("WorktreeName");
     this.mainRepoRoot = this.container.get<string>("MainRepoRoot");
-    this.originalWorkdir = this.container.get<string>("Workdir");
+    this.workdir = this.container.get<string>("Workdir");
   }
 
   /**
@@ -277,7 +277,7 @@ export class PermissionManager {
    * Update the additional directories (e.g., when configuration reloads)
    */
   updateAdditionalDirectories(directories: string[]): void {
-    const workdir = this.originalWorkdir;
+    const workdir = this.workdir;
     this.additionalDirectories = directories.map((dir) => {
       if (workdir && !path.isAbsolute(dir)) {
         return path.resolve(workdir, dir);
@@ -290,7 +290,7 @@ export class PermissionManager {
    * Add a system-level additional directory that is persistent across configuration reloads
    */
   public addSystemAdditionalDirectory(directory: string): void {
-    const workdir = this.originalWorkdir;
+    const workdir = this.workdir;
     const resolvedPath =
       workdir && !path.isAbsolute(directory)
         ? path.resolve(workdir, directory)
@@ -329,7 +329,7 @@ export class PermissionManager {
     targetPath: string,
     workdir?: string,
   ): { isInside: boolean; resolvedPath: string } {
-    const effectiveWorkdir = this.originalWorkdir || workdir;
+    const effectiveWorkdir = this.workdir || workdir;
 
     // Resolve the target path relative to effectiveWorkdir if it's not absolute
     const absolutePath =
@@ -1068,7 +1068,7 @@ export class PermissionManager {
    * @param rule - The rule to add (e.g., "Bash(ls)")
    */
   public async addPermissionRule(rule: string): Promise<void> {
-    const workdir = this.originalWorkdir;
+    const workdir = this.workdir;
     if (!workdir) {
       throw new Error("Working directory not set in PermissionManager");
     }

package/src/prompts/index.ts

@@ -238,7 +238,6 @@ export function buildSystemPrompt(
   tools: ToolPlugin[],
   options: {
     workdir?: string;
-    originalWorkdir?: string;
     memory?: string;
     language?: string;
     isSubagent?: boolean;
@@ -276,9 +275,8 @@ export function buildSystemPrompt(
     prompt += `\n\n${buildPlanModePrompt(options.planMode.planFilePath, options.planMode.planExists, options.isSubagent)}`;
   }
 
-  const workdirForPrompt = options.originalWorkdir || options.workdir;
-  if (workdirForPrompt) {
-    const isGitRepo = isGitRepository(workdirForPrompt);
+  if (options.workdir) {
+    const isGitRepo = isGitRepository(options.workdir);
     const platform = os.platform();
     const osVersion = `${os.type()} ${os.release()}`;
     const today = new Date().toISOString().split("T")[0];
@@ -293,7 +291,7 @@ export function buildSystemPrompt(
 
 Here is useful information about the environment you are running in:
 <env>
-Working directory: ${workdirForPrompt}
+Working directory: ${options.workdir}
 Is directory a git repo: ${isGitRepo}
 Platform: ${platform}
 Shell: ${shellName}

package/src/services/aiService.ts

@@ -377,10 +377,7 @@ export async function callAgent(
           result.content = finalContent;
         }
 
-        if (
-          typeof finalReasoningContent === "string" &&
-          finalReasoningContent.length > 0
-        ) {
+        if (typeof finalReasoningContent === "string") {
           result.reasoning_content = finalReasoningContent;
         }
 
@@ -544,6 +541,7 @@ async function processStreamingResponse(
 ): Promise<CallAgentResult> {
   let accumulatedContent = "";
   let accumulatedReasoningContent = "";
+  let hasReasoningContent = false;
   const toolCalls: {
     id: string;
     type: "function";
@@ -618,13 +616,13 @@ async function processStreamingResponse(
         }
       }
 
-      if (
-        typeof reasoning_content === "string" &&
-        reasoning_content.length > 0
-      ) {
-        accumulatedReasoningContent += reasoning_content;
-        if (onReasoningUpdate) {
-          onReasoningUpdate(accumulatedReasoningContent);
+      if (typeof reasoning_content === "string") {
+        hasReasoningContent = true;
+        if (reasoning_content.length > 0) {
+          accumulatedReasoningContent += reasoning_content;
+          if (onReasoningUpdate) {
+            onReasoningUpdate(accumulatedReasoningContent);
+          }
         }
       }
 
@@ -716,7 +714,7 @@ async function processStreamingResponse(
     result.content = accumulatedContent.trim();
   }
 
-  if (accumulatedReasoningContent) {
+  if (hasReasoningContent) {
     result.reasoning_content = accumulatedReasoningContent.trim();
   }
 

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/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;