wave-agent-sdk 0.0.4 → 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)
@@ -174,7 +174,9 @@ export class HookManager implements IHookManager {
 
     const eventConfigs = this.configuration[event];
     if (!eventConfigs || eventConfigs.length === 0) {
-      this.logger?.debug(`[HookManager] No hooks configured for ${event} event`);
+      this.logger?.debug(
+        `[HookManager] No hooks configured for ${event} event`,
+      );
       return [];
     }
 
@@ -217,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
@@ -261,11 +260,147 @@ export class HookManager implements IHookManager {
       results,
       totalDuration,
     );
-    this.logger?.info(`[HookManager] ${event} execution summary: ${summary}`);
+    this.logger?.debug(`[HookManager] ${event} execution summary: ${summary}`);
 
     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
    */
@@ -554,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;
@@ -53,7 +53,7 @@ export class McpManager {
     this.workdir = workdir;
 
     if (autoConnect) {
-      this.logger?.info("Initializing MCP servers...");
+      this.logger?.debug("Initializing MCP servers...");
 
       // Ensure MCP configuration is loaded
       const config = await this.ensureConfigLoaded();
@@ -63,10 +63,10 @@ export class McpManager {
         const connectionPromises = Object.keys(config.mcpServers).map(
           async (serverName) => {
             try {
-              this.logger?.info(`Connecting to MCP server: ${serverName}`);
+              this.logger?.debug(`Connecting to MCP server: ${serverName}`);
               const success = await this.connectServer(serverName);
               if (success) {
-                this.logger?.info(
+                this.logger?.debug(
                   `Successfully connected to MCP server: ${serverName}`,
                 );
               } else {
@@ -86,7 +86,7 @@ export class McpManager {
         await Promise.all(connectionPromises);
       }
 
-      this.logger?.info("MCP servers initialization completed");
+      this.logger?.debug("MCP servers initialization completed");
       // Trigger state change callback after initialization
       this.callbacks.onServersChange?.(this.getAllServers());
     }
@@ -255,7 +255,7 @@ export class McpManager {
       };
 
       transport.onclose = () => {
-        this.logger?.info(`MCP Server ${name} transport closed`);
+        this.logger?.debug(`MCP Server ${name} transport closed`);
         this.connections.delete(name);
         this.updateServerStatus(name, {
           status: "disconnected",

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 } from "../types.js";
+import type { Logger, Message, Usage } from "../types/index.js";
 import {
   cleanupExpiredSessions,
   getLatestSession,
@@ -32,6 +33,7 @@ export interface MessageManagerCallbacks {
   onSessionIdChange?: (sessionId: string) => void;
   onLatestTotalTokensChange?: (latestTotalTokens: number) => void;
   onUserInputHistoryChange?: (history: string[]) => void;
+  onUsagesChange?: (usages: Usage[]) => void;
   // Incremental callback
   onUserMessageAdded?: (
     content: string,
@@ -63,14 +65,32 @@ 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 {
   callbacks: MessageManagerCallbacks;
   workdir: string;
   logger?: Logger;
+
+  // New: Optional session directory override
+  /**
+   * Custom session directory path
+   * @default join(homedir(), ".wave", "sessions")
+   */
+  sessionDir?: string;
 }
 
 export class MessageManager {
@@ -83,6 +103,7 @@ export class MessageManager {
   private workdir: string;
   private logger?: Logger; // Add optional logger property
   private callbacks: MessageManagerCallbacks;
+  private sessionDir?: string; // Add session directory property
 
   constructor(options: MessageManagerOptions) {
     this.sessionId = randomUUID();
@@ -93,6 +114,7 @@ export class MessageManager {
     this.workdir = options.workdir;
     this.callbacks = options.callbacks;
     this.logger = options.logger;
+    this.sessionDir = options.sessionDir;
   }
 
   // Getter methods
@@ -113,7 +135,7 @@ export class MessageManager {
   }
 
   public getTranscriptPath(): string {
-    return getSessionFilePath(this.sessionId);
+    return getSessionFilePath(this.sessionId, this.sessionDir);
   }
 
   // Setter methods, will trigger callbacks
@@ -140,6 +162,7 @@ export class MessageManager {
         this.workdir,
         this.latestTotalTokens,
         this.sessionStartTime,
+        this.sessionDir,
       );
     } catch (error) {
       this.logger?.error("Failed to save session:", error);
@@ -155,9 +178,9 @@ export class MessageManager {
   ): Promise<void> {
     // Clean up expired sessions first
     try {
-      await cleanupExpiredSessions(this.workdir);
+      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) {
@@ -168,13 +191,16 @@ export class MessageManager {
       let sessionToRestore: SessionData | null = null;
 
       if (restoreSessionId) {
-        sessionToRestore = await loadSession(restoreSessionId);
+        sessionToRestore = await loadSession(restoreSessionId, this.sessionDir);
         if (!sessionToRestore) {
           console.error(`Session not found: ${restoreSessionId}`);
           process.exit(1);
         }
       } else if (continueLastSession) {
-        sessionToRestore = await getLatestSession(this.workdir);
+        sessionToRestore = await getLatestSession(
+          this.workdir,
+          this.sessionDir,
+        );
         if (!sessionToRestore) {
           console.error(
             `No previous session found for workdir: ${this.workdir}`,
@@ -290,11 +316,13 @@ export class MessageManager {
   public addAssistantMessage(
     content?: string,
     toolCalls?: ChatCompletionMessageFunctionToolCall[],
+    usage?: Usage,
   ): void {
     const newMessages = addAssistantMessageToMessages(
       this.messages,
       content,
       toolCalls,
+      usage,
     );
     this.setMessages(newMessages);
     this.callbacks.onAssistantMessageAdded?.(content, toolCalls);
@@ -432,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,
@@ -442,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(
@@ -464,6 +497,32 @@ 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,
+    );
+  }
+
+  /**
+   * Trigger usage change callback with all usage data from assistant messages
+   */
+  public triggerUsageChange(): void {
+    const usages: Usage[] = [];
+    for (const message of this.messages) {
+      if (message.role === "assistant" && message.usage) {
+        usages.push(message.usage);
+      }
+    }
+    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";
 
 /**
@@ -36,7 +36,7 @@ export class SkillManager {
    * Initialize the skill manager by discovering available skills
    */
   async initialize(): Promise<void> {
-    this.logger?.info("Initializing SkillManager...");
+    this.logger?.debug("Initializing SkillManager...");
 
     try {
       // Clear existing data before discovery
@@ -66,7 +66,7 @@ export class SkillManager {
       }
 
       this.initialized = true;
-      this.logger?.info(
+      this.logger?.debug(
         `SkillManager initialized with ${this.skillMetadata.size} skills`,
       );
     } catch (error) {
@@ -247,7 +247,7 @@ export class SkillManager {
   ): Promise<{ content: string; context?: SkillInvocationContext }> {
     const { skill_name } = args;
 
-    this.logger?.info(`Invoking skill: ${skill_name}`);
+    this.logger?.debug(`Invoking skill: ${skill_name}`);
 
     try {
       // Load the skill

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 {
@@ -92,7 +96,7 @@ export class SlashCommandManager {
         });
       }
 
-      this.logger?.info(`Loaded ${customCommands.length} custom commands`);
+      this.logger?.debug(`Loaded ${customCommands.length} custom commands`);
     } catch (error) {
       this.logger?.warn("Failed to load custom commands:", error);
     }