wave-agent-sdk 0.0.5 → 0.0.6

package/src/{hooks/manager.ts → managers/hookManager.ts}

@@ -17,11 +17,15 @@ import {
   HookConfigurationError,
   isValidHookEvent,
   isValidHookEventConfig,
-} from "./types.js";
-import { type IHookMatcher, HookMatcher } from "./matcher.js";
-import { type IHookExecutor, HookExecutor } from "./executor.js";
-import { loadMergedHooksConfig } from "./settings.js";
-import type { Logger } from "../types.js";
+} from "../types/hooks.js";
+import { type IHookMatcher, HookMatcher } from "../utils/hookMatcher.js";
+import {
+  executeCommand,
+  isCommandSafe,
+  loadMergedHooksConfig,
+} from "../services/hook.js";
+import type { Logger } from "../types/index.js";
+import type { MessageManager } from "./messageManager.js";
 
 export interface IHookManager {
   // Load configuration from settings
@@ -52,22 +56,16 @@ export interface IHookManager {
 export class HookManager implements IHookManager {
   private configuration: PartialHookConfiguration | undefined;
   private readonly matcher: IHookMatcher;
-  private readonly executor: IHookExecutor;
   private readonly logger?: Logger;
   private readonly workdir: string;
 
   constructor(
     workdir: string,
     matcher: IHookMatcher = new HookMatcher(),
-    executor?: IHookExecutor,
     logger?: Logger,
   ) {
     this.workdir = workdir;
     this.matcher = matcher;
-    // Create executor with logger if provided, or use passed executor, or create default
-    this.executor = logger
-      ? new HookExecutor(logger)
-      : executor || new HookExecutor();
     this.logger = logger;
   }
 
@@ -112,19 +110,21 @@ export class HookManager implements IHookManager {
       this.logger?.debug(`[HookManager] Loading configuration...`);
       const mergedConfig = loadMergedHooksConfig(this.workdir);
       this.logger?.debug(`[HookManager] Merged config result:`, mergedConfig);
-      this.configuration = mergedConfig;
-
-      // Validate the loaded configuration
-      const validation = this.validatePartialConfiguration(mergedConfig);
-      if (!validation.valid) {
-        throw new HookConfigurationError(
-          "filesystem settings",
-          validation.errors,
-        );
+      this.configuration = mergedConfig || undefined;
+
+      // Validate the loaded configuration if it exists
+      if (mergedConfig) {
+        const validation = this.validatePartialConfiguration(mergedConfig);
+        if (!validation.valid) {
+          throw new HookConfigurationError(
+            "filesystem settings",
+            validation.errors,
+          );
+        }
       }
 
       this.logger?.debug(
-        `[HookManager] Configuration loaded successfully with ${Object.keys(mergedConfig).length} event types`,
+        `[HookManager] Configuration loaded successfully with ${Object.keys(mergedConfig || {}).length} event types`,
       );
     } catch (error) {
       // If loading fails, start with undefined configuration (no hooks)
@@ -219,10 +219,7 @@ export class HookManager implements IHookManager {
             `[HookManager] Executing command ${commandIndex + 1}/${config.hooks.length} in configuration ${configIndex + 1}`,
           );
 
-          const result = await this.executor.executeCommand(
-            hookCommand.command,
-            context,
-          );
+          const result = await executeCommand(hookCommand.command, context);
           results.push(result);
 
           // Report individual command result
@@ -268,6 +265,142 @@ export class HookManager implements IHookManager {
     return results;
   }
 
+  /**
+   * Process hook execution results and determine appropriate actions
+   * based on exit codes and hook event type
+   */
+  processHookResults(
+    event: HookEvent,
+    results: HookExecutionResult[],
+    messageManager?: MessageManager,
+    toolId?: string,
+    originalToolResult?: string,
+  ): {
+    shouldBlock: boolean;
+    errorMessage?: string;
+  } {
+    if (!messageManager || results.length === 0) {
+      return { shouldBlock: false };
+    }
+
+    // First pass: Check for any blocking errors (exit code 2)
+    // Blocking errors take precedence and stop all processing
+    for (const result of results) {
+      if (result.exitCode === 2) {
+        // Handle blocking error immediately and return
+        return this.handleBlockingError(
+          event,
+          result,
+          messageManager,
+          toolId,
+          originalToolResult,
+        );
+      }
+    }
+
+    // Second pass: Process all non-blocking results
+    for (const result of results) {
+      if (result.exitCode === undefined) {
+        continue; // Skip results without exit codes
+      }
+
+      // Handle exit code interpretation
+      if (result.exitCode === 0) {
+        // Success case - handle stdout based on hook type
+        this.handleHookSuccess(event, result, messageManager);
+      } else {
+        // Non-blocking error case (any exit code except 0 and 2)
+        this.handleNonBlockingError(result, messageManager);
+      }
+    }
+
+    return { shouldBlock: false };
+  }
+
+  /**
+   * Handle successful hook execution (exit code 0)
+   */
+  private handleHookSuccess(
+    event: HookEvent,
+    result: HookExecutionResult,
+    messageManager: MessageManager,
+  ): void {
+    if (event === "UserPromptSubmit" && result.stdout?.trim()) {
+      // Inject stdout as user message context for UserPromptSubmit
+      messageManager.addUserMessage(result.stdout.trim());
+    }
+    // For other hook types (PreToolUse, PostToolUse, Stop), ignore stdout
+  }
+
+  /**
+   * Handle blocking error (exit code 2) - behavior varies by hook type
+   */
+  private handleBlockingError(
+    event: HookEvent,
+    result: HookExecutionResult,
+    messageManager: MessageManager,
+    toolId?: string,
+    originalToolResult?: string,
+  ): {
+    shouldBlock: boolean;
+    errorMessage?: string;
+  } {
+    const errorMessage = result.stderr?.trim() || "Hook execution failed";
+
+    switch (event) {
+      case "UserPromptSubmit":
+        // Block prompt processing, show error to user, erase prompt
+        messageManager.addErrorBlock(errorMessage);
+        messageManager.removeLastUserMessage();
+        return {
+          shouldBlock: true,
+          errorMessage,
+        };
+
+      case "PreToolUse":
+        // Block tool execution and show error to Wave Agent via tool block
+        if (toolId) {
+          messageManager.updateToolBlock({
+            toolId,
+            result: errorMessage,
+            success: false,
+            error: "Hook blocked tool execution",
+          });
+        }
+        return { shouldBlock: true };
+
+      case "PostToolUse":
+        // Show error to Wave Agent via tool block, execution continues
+        if (toolId && originalToolResult !== undefined) {
+          messageManager.updateToolBlock({
+            toolId,
+            result: `${originalToolResult}\n\nHook feedback: ${errorMessage}`,
+            success: false,
+          });
+        }
+        return { shouldBlock: false };
+
+      case "Stop":
+        // Show error to Wave Agent via user message and block stopping to continue conversation
+        messageManager.addUserMessage(errorMessage);
+        return { shouldBlock: true, errorMessage };
+
+      default:
+        return { shouldBlock: false };
+    }
+  }
+
+  /**
+   * Handle non-blocking error (other exit codes)
+   */
+  private handleNonBlockingError(
+    result: HookExecutionResult,
+    messageManager: MessageManager,
+  ): void {
+    const errorMessage = result.stderr?.trim() || "Hook execution failed";
+    messageManager.addErrorBlock(errorMessage);
+  }
+
   /**
    * Check if hooks are configured for an event/tool combination
    */
@@ -556,7 +689,7 @@ export class HookManager implements IHookManager {
 
     // Validate commands
     config.hooks.forEach((hookCommand, cmdIndex) => {
-      if (!this.executor.isCommandSafe(hookCommand.command)) {
+      if (!isCommandSafe(hookCommand.command)) {
         errors.push(
           `${prefix}.hooks[${cmdIndex}]: Command may be unsafe: ${hookCommand.command}`,
         );

package/src/managers/mcpManager.ts

@@ -11,7 +11,7 @@ import type {
   McpConfig,
   McpTool,
   McpServerStatus,
-} from "../types.js";
+} from "../types/index.js";
 
 interface McpConnection {
   client: Client;

package/src/managers/messageManager.ts

@@ -12,11 +12,12 @@ import {
   completeCommandInMessage,
   addSubagentBlockToMessage,
   updateSubagentBlockInMessage,
+  removeLastUserMessage,
   type AddSubagentBlockParams,
   type UpdateSubagentBlockParams,
   type AgentToolBlockUpdateParams,
 } from "../utils/messageOperations.js";
-import type { Logger, Message, Usage } from "../types.js";
+import type { Logger, Message, Usage } from "../types/index.js";
 import {
   cleanupExpiredSessions,
   getLatestSession,
@@ -64,8 +65,19 @@ export interface MessageManagerCallbacks {
   onUpdateCommandOutputMessage?: (command: string, output: string) => void;
   onCompleteCommandMessage?: (command: string, exitCode: number) => void;
   // Subagent callbacks
-  onSubAgentBlockAdded?: (subagentId: string) => void;
-  onSubAgentBlockUpdated?: (subagentId: string, messages: Message[]) => void;
+  onSubAgentBlockAdded?: (
+    subagentId: string,
+    parameters: {
+      description: string;
+      prompt: string;
+      subagent_type: string;
+    },
+  ) => void;
+  onSubAgentBlockUpdated?: (
+    subagentId: string,
+    messages: Message[],
+    status: "active" | "completed" | "error" | "aborted",
+  ) => void;
 }
 
 export interface MessageManagerOptions {
@@ -168,7 +180,7 @@ export class MessageManager {
     try {
       await cleanupExpiredSessions(this.workdir, this.sessionDir);
     } catch (error) {
-      console.warn("Failed to cleanup expired sessions:", error);
+      this.logger?.warn("Failed to cleanup expired sessions:", error);
     }
 
     if (!restoreSessionId && !continueLastSession) {
@@ -448,6 +460,11 @@ export class MessageManager {
     subagentName: string,
     status: "active" | "completed" | "error" = "active",
     subagentMessages: Message[] = [],
+    parameters: {
+      description: string;
+      prompt: string;
+      subagent_type: string;
+    },
   ): void {
     const params: AddSubagentBlockParams = {
       messages: this.messages,
@@ -458,7 +475,7 @@ export class MessageManager {
     };
     const updatedMessages = addSubagentBlockToMessage(params);
     this.setMessages(updatedMessages);
-    this.callbacks.onSubAgentBlockAdded?.(params.subagentId);
+    this.callbacks.onSubAgentBlockAdded?.(params.subagentId, parameters);
   }
 
   public updateSubagentBlock(
@@ -480,7 +497,11 @@ export class MessageManager {
       status: updates.status || "active",
       subagentMessages: updates.messages || [],
     };
-    this.callbacks.onSubAgentBlockUpdated?.(params.subagentId, params.messages);
+    this.callbacks.onSubAgentBlockUpdated?.(
+      params.subagentId,
+      params.messages,
+      params.status,
+    );
   }
 
   /**
@@ -495,4 +516,13 @@ export class MessageManager {
     }
     this.callbacks.onUsagesChange?.(usages);
   }
+
+  /**
+   * Remove the last user message from the conversation
+   * Used for hook error handling when the user prompt needs to be erased
+   */
+  public removeLastUserMessage(): void {
+    const newMessages = removeLastUserMessage(this.messages);
+    this.setMessages(newMessages);
+  }
 }

package/src/managers/skillManager.ts

@@ -10,7 +10,7 @@ import type {
   SkillToolArgs,
   SkillInvocationContext,
   Logger,
-} from "../types.js";
+} from "../types/index.js";
 import { parseSkillFile, formatSkillError } from "../utils/skillParser.js";
 
 /**

package/src/managers/slashCommandManager.ts

@@ -1,6 +1,10 @@
 import type { MessageManager } from "./messageManager.js";
 import type { AIManager } from "./aiManager.js";
-import type { SlashCommand, CustomSlashCommand, Logger } from "../types.js";
+import type {
+  SlashCommand,
+  CustomSlashCommand,
+  Logger,
+} from "../types/index.js";
 import { loadCustomSlashCommands } from "../utils/customCommands.js";
 
 import {

package/src/managers/subagentManager.ts

@@ -6,7 +6,7 @@ import type {
   GatewayConfig,
   ModelConfig,
   Usage,
-} from "../types.js";
+} from "../types/index.js";
 import { AIManager } from "./aiManager.js";
 import {
   MessageManager,
@@ -21,7 +21,6 @@ export interface SubagentInstance {
   messageManager: MessageManager;
   toolManager: ToolManager;
   status: "initializing" | "active" | "completed" | "error" | "aborted";
-  taskDescription: string;
   messages: Message[];
 }
 
@@ -107,7 +106,11 @@ export class SubagentManager {
    */
   async createInstance(
     configuration: SubagentConfiguration,
-    taskDescription: string,
+    parameters: {
+      description: string;
+      prompt: string;
+      subagent_type: string;
+    },
   ): Promise<SubagentInstance> {
     if (
       !this.parentToolManager ||
@@ -177,7 +180,6 @@ export class SubagentManager {
       messageManager,
       toolManager,
       status: "initializing",
-      taskDescription,
       messages: [],
     };
 
@@ -189,6 +191,7 @@ export class SubagentManager {
       configuration.name,
       "active",
       [],
+      parameters,
     );
 
     return instance;
@@ -203,14 +206,31 @@ export class SubagentManager {
   async executeTask(
     instance: SubagentInstance,
     prompt: string,
+    abortSignal?: AbortSignal,
   ): Promise<string> {
     try {
+      // Check if already aborted before starting
+      if (abortSignal?.aborted) {
+        throw new Error("Task was aborted before execution started");
+      }
+
       // Set status to active and update parent
       this.updateInstanceStatus(instance.subagentId, "active");
       this.parentMessageManager.updateSubagentBlock(instance.subagentId, {
         status: "active",
       });
 
+      // Set up abort handler
+      if (abortSignal) {
+        abortSignal.addEventListener("abort", () => {
+          this.updateInstanceStatus(instance.subagentId, "aborted");
+          this.parentMessageManager.updateSubagentBlock(instance.subagentId, {
+            status: "aborted",
+            messages: instance.messages,
+          });
+        });
+      }
+
       // Add the user's prompt as a message
       instance.messageManager.addUserMessage(prompt);
 
@@ -227,7 +247,9 @@ export class SubagentManager {
       }
 
       // Execute the AI request with tool restrictions
-      await instance.aiManager.sendAIMessage({
+      // The AIManager will handle abort signals through its own abort controllers
+      // We need to abort the AI execution if the external abort signal is triggered
+      const executeAI = instance.aiManager.sendAIMessage({
         allowedTools,
         model:
           instance.configuration.model !== "inherit"
@@ -235,6 +257,25 @@ export class SubagentManager {
             : undefined,
       });
 
+      // If we have an abort signal, race against it
+      if (abortSignal) {
+        await Promise.race([
+          executeAI,
+          new Promise<never>((_, reject) => {
+            if (abortSignal.aborted) {
+              reject(new Error("Task was aborted"));
+            }
+            abortSignal.addEventListener("abort", () => {
+              // Abort the AI execution
+              instance.aiManager.abortAIMessage();
+              reject(new Error("Task was aborted"));
+            });
+          }),
+        ]);
+      } else {
+        await executeAI;
+      }
+
       // Get the latest messages to extract the response
       const messages = instance.messageManager.getMessages();
       const lastAssistantMessage = messages
@@ -298,52 +339,6 @@ export class SubagentManager {
     }
   }
 
-  /**
-   * Abort a running subagent instance
-   */
-  abortInstance(subagentId: string): boolean {
-    const instance = this.instances.get(subagentId);
-    if (!instance) {
-      return false;
-    }
-
-    // Only abort active or initializing instances
-    if (instance.status !== "active" && instance.status !== "initializing") {
-      return false;
-    }
-
-    try {
-      // Abort the AI manager operations
-      instance.aiManager.abortAIMessage();
-
-      // Update status
-      this.updateInstanceStatus(subagentId, "aborted");
-      this.parentMessageManager.updateSubagentBlock(subagentId, {
-        status: "aborted",
-        messages: instance.messages,
-      });
-
-      this.logger?.debug(`Aborted subagent instance: ${subagentId}`);
-      return true;
-    } catch (error) {
-      this.logger?.error(
-        `Failed to abort subagent instance ${subagentId}:`,
-        error,
-      );
-      return false;
-    }
-  }
-
-  /**
-   * Abort all active subagent instances
-   */
-  abortAllInstances(): void {
-    const activeInstances = this.getActiveInstances();
-    for (const instance of activeInstances) {
-      this.abortInstance(instance.subagentId);
-    }
-  }
-
   /**
    * Clean up completed, errored, or aborted instances
    */
@@ -373,8 +368,6 @@ export class SubagentManager {
    * Clean up all instances (for session end)
    */
   cleanup(): void {
-    // Abort all active instances before cleanup
-    this.abortAllInstances();
     this.instances.clear();
   }
 }

package/src/managers/toolManager.ts

@@ -14,7 +14,7 @@ import { createTaskTool } from "../tools/taskTool.js";
 import { createSkillTool } from "../tools/skillTool.js";
 import { McpManager } from "./mcpManager.js";
 import { ChatCompletionFunctionTool } from "openai/resources.js";
-import type { Logger } from "../types.js";
+import type { Logger } from "../types/index.js";
 import type { SubagentManager } from "./subagentManager.js";
 import type { SkillManager } from "./skillManager.js";
 

package/src/services/aiService.ts

@@ -5,7 +5,7 @@ import {
   ChatCompletionMessageParam,
   ChatCompletionFunctionTool,
 } from "openai/resources.js";
-import type { GatewayConfig, ModelConfig } from "../types.js";
+import type { GatewayConfig, ModelConfig } from "../types/index.js";
 import * as os from "os";
 import * as fs from "fs";
 import * as path from "path";
@@ -116,7 +116,14 @@ export async function callAgent(
     // Build system prompt content
     let systemContent =
       systemPrompt ||
-      `You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.`;
+      `You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
+      
+# Tool usage policy
+- When doing file search, prefer to use the Task tool in order to reduce context usage.
+- You should proactively use the Task tool with specialized agents when the task at hand matches the agent's description.
+- You have the capability to call multiple tools in a single response. When multiple independent pieces of information are requested, batch your tool calls together for optimal performance. When making multiple bash tool calls, you MUST send a single message with multiple tools calls to run the calls in parallel. For example, if you need to run "git status" and "git diff", send a single message with two tool calls to run the calls in parallel.
+
+      `;
 
     // Always add environment information
     systemContent += `