wave-agent-sdk 0.0.5 → 0.0.7

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

@@ -17,57 +17,30 @@ 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";
-
-export interface IHookManager {
-  // Load configuration from settings
-  loadConfiguration(
-    userHooks?: PartialHookConfiguration,
-    projectHooks?: PartialHookConfiguration,
-  ): void;
-
-  // Load configuration from filesystem settings
-  loadConfigurationFromSettings(): void;
-
-  // Execute hooks for specific event
-  executeHooks(
-    event: HookEvent,
-    context: HookExecutionContext | ExtendedHookExecutionContext,
-  ): Promise<HookExecutionResult[]>;
-
-  // Check if hooks are configured for event
-  hasHooks(event: HookEvent, toolName?: string): boolean;
-
-  // Validate hook configuration
-  validateConfiguration(config: HookConfiguration): ValidationResult;
-
-  // Get current configuration
-  getConfiguration(): PartialHookConfiguration | undefined;
-}
-
-export class HookManager implements IHookManager {
+} from "../types/hooks.js";
+import { HookMatcher } from "../utils/hookMatcher.js";
+import {
+  executeCommand,
+  isCommandSafe,
+  loadMergedHooksConfig,
+} from "../services/hook.js";
+import type { Logger } from "../types/index.js";
+import { MessageSource } from "../types/index.js";
+import type { MessageManager } from "./messageManager.js";
+
+export class HookManager {
   private configuration: PartialHookConfiguration | undefined;
-  private readonly matcher: IHookMatcher;
-  private readonly executor: IHookExecutor;
+  private readonly matcher: HookMatcher;
   private readonly logger?: Logger;
   private readonly workdir: string;
 
   constructor(
     workdir: string,
-    matcher: IHookMatcher = new HookMatcher(),
-    executor?: IHookExecutor,
+    matcher: HookMatcher = new HookMatcher(),
     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 +85,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 +194,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 +240,146 @@ 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,
+    toolParameters?: 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,
+          toolParameters,
+        );
+      }
+    }
+
+    // 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({
+        content: result.stdout.trim(),
+        source: MessageSource.HOOK,
+      });
+    }
+    // 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,
+    toolParameters?: 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({
+            id: toolId,
+            parameters: toolParameters || "",
+            result: errorMessage,
+            success: false,
+            error: "Hook blocked tool execution",
+          });
+        }
+        return { shouldBlock: true };
+
+      case "PostToolUse":
+        // Show error to Wave Agent via user message and allow AI to continue
+        messageManager.addUserMessage({
+          content: errorMessage,
+          source: MessageSource.HOOK,
+        });
+        return { shouldBlock: false };
+
+      case "Stop":
+        // Show error to Wave Agent via user message and block stopping to continue conversation
+        messageManager.addUserMessage({
+          content: errorMessage,
+          source: MessageSource.HOOK,
+        });
+        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 +668,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,13 @@ import {
   completeCommandInMessage,
   addSubagentBlockToMessage,
   updateSubagentBlockInMessage,
+  removeLastUserMessage,
+  UserMessageParams,
   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,
@@ -34,10 +36,7 @@ export interface MessageManagerCallbacks {
   onUserInputHistoryChange?: (history: string[]) => void;
   onUsagesChange?: (usages: Usage[]) => void;
   // Incremental callback
-  onUserMessageAdded?: (
-    content: string,
-    images?: Array<{ path: string; mimeType: string }>,
-  ) => void;
+  onUserMessageAdded?: (params: UserMessageParams) => void;
   onAssistantMessageAdded?: (
     content?: string,
     toolCalls?: ChatCompletionMessageFunctionToolCall[],
@@ -53,19 +52,24 @@ export interface MessageManagerCallbacks {
     type: "project" | "user",
     storagePath: string,
   ) => void;
-  // Custom command callback
-  onCustomCommandAdded?: (
-    commandName: string,
-    content: string,
-    originalInput?: string,
-  ) => void;
   // Bash command callback
   onAddCommandOutputMessage?: (command: string) => void;
   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 +172,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) {
@@ -269,36 +273,13 @@ export class MessageManager {
   }
 
   // Encapsulated message operation functions
-  public addUserMessage(
-    content: string,
-    images?: Array<{ path: string; mimeType: string }>,
-  ): void {
-    const newMessages = addUserMessageToMessages({
-      messages: this.messages,
-      content,
-      images,
-    });
-    this.setMessages(newMessages);
-    this.callbacks.onUserMessageAdded?.(content, images);
-  }
-
-  public addCustomCommandMessage(
-    commandName: string,
-    content: string,
-    originalInput?: string,
-  ): void {
+  public addUserMessage(params: UserMessageParams): void {
     const newMessages = addUserMessageToMessages({
       messages: this.messages,
-      content: "", // Empty content, as we will use CustomCommandBlock
-      customCommandBlock: {
-        type: "custom_command",
-        commandName,
-        content,
-        originalInput,
-      },
+      ...params,
     });
     this.setMessages(newMessages);
-    this.callbacks.onCustomCommandAdded?.(commandName, content, originalInput);
+    this.callbacks.onUserMessageAdded?.(params);
   }
 
   public addAssistantMessage(
@@ -319,14 +300,15 @@ export class MessageManager {
   public updateToolBlock(params: AgentToolBlockUpdateParams): void {
     const newMessages = updateToolBlockInMessage({
       messages: this.messages,
-      id: params.toolId,
-      parameters: params.args || "",
+      id: params.id,
+      parameters: params.parameters,
       result: params.result,
       success: params.success,
       error: params.error,
       isRunning: params.isRunning,
       name: params.name,
       shortResult: params.shortResult,
+      images: params.images,
       compactParams: params.compactParams,
     });
     this.setMessages(newMessages);
@@ -448,6 +430,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 +445,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 +467,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 +486,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 {
@@ -253,15 +257,14 @@ export class SlashCommandManager {
           ? replaceBashCommandsWithOutput(processedContent, bashResults)
           : processedContent;
 
-      // Add custom command block to show the command being executed
+      // Add custom command message to show the command being executed
       const originalInput = args
         ? `/${commandName} ${args}`
         : `/${commandName}`;
-      this.messageManager.addCustomCommandMessage(
-        commandName,
-        finalContent,
-        originalInput,
-      );
+      this.messageManager.addUserMessage({
+        content: originalInput,
+        customCommandContent: finalContent,
+      });
 
       // Execute the AI conversation with custom configuration
       await this.aiManager.sendAIMessage({

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,16 +206,33 @@ 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);
+      instance.messageManager.addUserMessage({ content: prompt });
 
       // Create allowed tools list - always exclude Task tool to prevent subagent recursion
       let allowedTools = instance.configuration.tools;
@@ -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";