wave-agent-sdk 0.0.4 → 0.0.6

package/dist/managers/aiManager.js

@@ -83,7 +83,7 @@ export class AIManager {
         this.messageManager.setlatestTotalTokens(usage.total_tokens);
         // Check if token limit exceeded - use injected configuration
         if (usage.total_tokens > this.tokenLimit) {
-            this.logger?.info(`Token usage exceeded ${this.tokenLimit}, compressing messages...`);
+            this.logger?.debug(`Token usage exceeded ${this.tokenLimit}, compressing messages...`);
             // Check if messages need compression
             const { messagesToCompress, insertIndex } = getMessagesToCompress(this.messageManager.getMessages(), 7);
             // If there are messages to compress, perform compression
@@ -91,15 +91,29 @@ export class AIManager {
                 const recentChatMessages = convertMessagesForAPI(messagesToCompress);
                 this.setIsCompressing(true);
                 try {
-                    const compressedContent = await compressMessages({
+                    const compressionResult = await compressMessages({
                         gatewayConfig: this.gatewayConfig,
                         modelConfig: this.modelConfig,
                         messages: recentChatMessages,
                         abortSignal: abortController.signal,
                     });
                     // Execute message reconstruction and sessionId update after compression
-                    this.messageManager.compressMessagesAndUpdateSession(insertIndex, compressedContent);
-                    this.logger?.info(`Successfully compressed ${messagesToCompress.length} messages and updated session`);
+                    this.messageManager.compressMessagesAndUpdateSession(insertIndex, compressionResult.content);
+                    // Handle usage tracking for compression operations
+                    if (compressionResult.usage) {
+                        const usage = {
+                            prompt_tokens: compressionResult.usage.prompt_tokens,
+                            completion_tokens: compressionResult.usage.completion_tokens,
+                            total_tokens: compressionResult.usage.total_tokens,
+                            model: this.modelConfig.fastModel,
+                            operation_type: "compress",
+                        };
+                        // Notify Agent to add to usage tracking
+                        if (this.callbacks?.onUsageAdded) {
+                            this.callbacks.onUsageAdded(usage);
+                        }
+                    }
+                    this.logger?.debug(`Successfully compressed ${messagesToCompress.length} messages and updated session`);
                 }
                 catch (compressError) {
                     this.logger?.error("Failed to compress messages:", compressError);
@@ -125,12 +139,22 @@ export class AIManager {
         if (recursionDepth === 0 && this.isLoading) {
             return;
         }
-        // Create new AbortController
-        const abortController = new AbortController();
-        this.abortController = abortController;
-        // Create separate AbortController for tool execution
-        const toolAbortController = new AbortController();
-        this.toolAbortController = toolAbortController;
+        // Only create new AbortControllers for the initial call (recursionDepth === 0)
+        // For recursive calls, reuse existing controllers to maintain abort signal
+        let abortController;
+        let toolAbortController;
+        if (recursionDepth === 0) {
+            // Create new AbortControllers for initial call
+            abortController = new AbortController();
+            this.abortController = abortController;
+            toolAbortController = new AbortController();
+            this.toolAbortController = toolAbortController;
+        }
+        else {
+            // Reuse existing controllers for recursive calls
+            abortController = this.abortController;
+            toolAbortController = this.toolAbortController;
+        }
         // Only set loading state for the initial call
         if (recursionDepth === 0) {
             this.setIsLoading(true);
@@ -163,12 +187,29 @@ export class AIManager {
                     }
                 }
             }
-            // Add assistant message at once (including content and tool calls)
-            this.messageManager.addAssistantMessage(content, toolCalls);
+            // Handle usage tracking for agent operations
+            let usage;
+            if (result.usage) {
+                usage = {
+                    prompt_tokens: result.usage.prompt_tokens,
+                    completion_tokens: result.usage.completion_tokens,
+                    total_tokens: result.usage.total_tokens,
+                    model: model || this.modelConfig.agentModel,
+                    operation_type: "agent",
+                };
+            }
+            // Add assistant message at once (including content, tool calls, and usage)
+            this.messageManager.addAssistantMessage(content, toolCalls, usage);
+            // Notify Agent to add to usage tracking
+            if (usage) {
+                if (this.callbacks?.onUsageAdded) {
+                    this.callbacks.onUsageAdded(usage);
+                }
+            }
             if (toolCalls.length > 0) {
-                for (const functionToolCall of toolCalls) {
+                // Execute all tools in parallel using Promise.all
+                const toolExecutionPromises = toolCalls.map(async (functionToolCall) => {
                     const toolId = functionToolCall.id || "";
-                    // Execute tool
                     try {
                         // Check if already interrupted, skip tool execution if so
                         if (abortController.signal.aborted ||
@@ -205,7 +246,12 @@ export class AIManager {
                         });
                         try {
                             // Execute PreToolUse hooks before tool execution
-                            await this.executePreToolUseHooks(toolName, toolArgs);
+                            const shouldExecuteTool = await this.executePreToolUseHooks(toolName, toolArgs, toolId);
+                            // If PreToolUse hooks blocked execution, skip tool execution
+                            if (!shouldExecuteTool) {
+                                this.logger?.info(`Tool ${toolName} execution blocked by PreToolUse hooks`);
+                                return; // Skip this tool and return from this map function
+                            }
                             // Create tool execution context
                             const context = {
                                 abortSignal: toolAbortController.signal,
@@ -234,7 +280,7 @@ export class AIManager {
                                 this.messageManager.addDiffBlock(toolResult.filePath, toolResult.diffResult);
                             }
                             // Execute PostToolUse hooks after successful tool completion
-                            await this.executePostToolUseHooks(toolName, toolArgs, toolResult);
+                            await this.executePostToolUseHooks(toolId, toolName, toolArgs, toolResult);
                         }
                         catch (toolError) {
                             const errorMessage = toolError instanceof Error
@@ -253,19 +299,14 @@ export class AIManager {
                         }
                     }
                     catch (parseError) {
-                        // Check if it's a parsing error due to interruption
-                        const isAborted = abortController.signal.aborted ||
-                            toolAbortController.signal.aborted;
-                        if (isAborted) {
-                            // If interrupted, return directly without showing error
-                            return;
-                        }
                         const errorMessage = parseError instanceof Error
                             ? parseError.message
                             : String(parseError);
                         this.messageManager.addErrorBlock(`Failed to parse tool arguments for ${functionToolCall.function?.name}: ${errorMessage}`);
                     }
-                }
+                });
+                // Wait for all tools to complete execution in parallel
+                await Promise.all(toolExecutionPromises);
             }
             // Handle token statistics and message compression
             await this.handleTokenUsageAndCompression(result.usage, abortController);
@@ -273,10 +314,6 @@ export class AIManager {
             if (toolCalls.length > 0) {
                 // Check interruption status
                 const isCurrentlyAborted = abortController.signal.aborted || toolAbortController.signal.aborted;
-                // AI service call ends, clear abort controller
-                this.abortController = null;
-                // Clear tool AbortController after tool execution completes
-                this.toolAbortController = null;
                 if (!isCurrentlyAborted) {
                     // Recursively call AI service, increment recursion depth, and pass same configuration
                     await this.sendAIMessage({
@@ -286,42 +323,47 @@ export class AIManager {
                     });
                 }
             }
-            else {
-                // Clear abort controller when no tool operations
-                this.abortController = null;
-                this.toolAbortController = null;
-            }
         }
         catch (error) {
-            // Check if error is due to user interrupt operation
-            const isAborted = abortController.signal.aborted ||
-                toolAbortController.signal.aborted ||
-                (error instanceof Error &&
-                    (error.name === "AbortError" || error.message.includes("aborted")));
-            if (!isAborted) {
-                this.messageManager.addErrorBlock(error instanceof Error ? error.message : "Unknown error occurred");
-            }
-            // Reset abort controller on error
-            this.abortController = null;
-            this.toolAbortController = null;
+            this.messageManager.addErrorBlock(error instanceof Error ? error.message : "Unknown error occurred");
         }
         finally {
-            // Only clear loading state for the initial call
+            // Only execute Stop hooks for the initial call
             if (recursionDepth === 0) {
-                this.setIsLoading(false);
-                // Save session before executing Stop hooks
+                // Execute Stop hooks only if the operation was not aborted
+                const isCurrentlyAborted = abortController.signal.aborted || toolAbortController.signal.aborted;
+                if (!isCurrentlyAborted) {
+                    const shouldContinue = await this.executeStopHooks();
+                    // If Stop hooks indicate we should continue (due to blocking errors),
+                    // restart the AI conversation cycle
+                    if (shouldContinue) {
+                        this.logger?.info("Stop hooks indicate issues need fixing, continuing conversation...");
+                        // Restart the conversation to let AI fix the issues
+                        // Use recursionDepth = 1 to prevent Stop hooks from running again in continuation
+                        await this.sendAIMessage({
+                            recursionDepth: 1,
+                            model,
+                            allowedTools,
+                        });
+                    }
+                }
+                // Save session after all operations (including continuation) are complete
                 await this.messageManager.saveSession();
-                // Execute Stop hooks when AI response cycle completes
-                await this.executeStopHooks();
+                // Clear abort controllers and loading state after all operations are complete
+                this.abortController = null;
+                this.toolAbortController = null;
+                // Set loading to false at the very end, after all operations including continuation
+                this.setIsLoading(false);
             }
         }
     }
     /**
      * Execute Stop hooks when AI response cycle completes
+     * @returns Promise<boolean> - true if should continue conversation, false if should stop
      */
     async executeStopHooks() {
         if (!this.hookManager)
-            return;
+            return false;
         try {
             const context = {
                 event: "Stop",
@@ -333,6 +375,16 @@ export class AIManager {
                 // Stop hooks don't need toolName, toolInput, toolResponse, or userPrompt
             };
             const results = await this.hookManager.executeHooks("Stop", context);
+            // Process hook results to handle exit codes and appropriate responses
+            let shouldContinue = false;
+            if (results.length > 0) {
+                const processResult = this.hookManager.processHookResults("Stop", results, this.messageManager);
+                // If hook processing indicates we should block (exit code 2), continue conversation
+                if (processResult.shouldBlock) {
+                    this.logger?.info("Stop hook blocked stopping with error:", processResult.errorMessage);
+                    shouldContinue = true;
+                }
+            }
             // Log hook execution results for debugging
             if (results.length > 0) {
                 this.logger?.debug(`Executed ${results.length} Stop hook(s):`, results.map((r) => ({
@@ -343,18 +395,21 @@ export class AIManager {
                     stderr: r.stderr,
                 })));
             }
+            return shouldContinue;
         }
         catch (error) {
             // Hook execution errors should not interrupt the main workflow
             this.logger?.error("Stop hook execution failed:", error);
+            return false;
         }
     }
     /**
      * Execute PreToolUse hooks before tool execution
+     * Returns true if hooks allow tool execution, false if blocked
      */
-    async executePreToolUseHooks(toolName, toolInput) {
+    async executePreToolUseHooks(toolName, toolInput, toolId) {
         if (!this.hookManager)
-            return;
+            return true;
         try {
             const context = {
                 event: "PreToolUse",
@@ -367,6 +422,12 @@ export class AIManager {
                 toolInput,
             };
             const results = await this.hookManager.executeHooks("PreToolUse", context);
+            // Process hook results to handle exit codes and determine if tool should be blocked
+            let shouldContinue = true;
+            if (results.length > 0) {
+                const processResult = this.hookManager.processHookResults("PreToolUse", results, this.messageManager, toolId);
+                shouldContinue = !processResult.shouldBlock;
+            }
             // Log hook execution results for debugging
             if (results.length > 0) {
                 this.logger?.debug(`Executed ${results.length} PreToolUse hook(s) for ${toolName}:`, results.map((r) => ({
@@ -377,16 +438,18 @@ export class AIManager {
                     stderr: r.stderr,
                 })));
             }
+            return shouldContinue;
         }
         catch (error) {
             // Hook execution errors should not interrupt the main workflow
             this.logger?.error("PreToolUse hook execution failed:", error);
+            return true; // Allow tool execution on hook errors
         }
     }
     /**
      * Execute PostToolUse hooks after tool completion
      */
-    async executePostToolUseHooks(toolName, toolInput, toolResponse) {
+    async executePostToolUseHooks(toolId, toolName, toolInput, toolResponse) {
         if (!this.hookManager)
             return;
         try {
@@ -402,6 +465,11 @@ export class AIManager {
                 toolResponse,
             };
             const results = await this.hookManager.executeHooks("PostToolUse", context);
+            // Process hook results to handle exit codes and update tool results
+            if (results.length > 0) {
+                const originalToolResult = toolResponse?.content || "";
+                this.hookManager.processHookResults("PostToolUse", results, this.messageManager, toolId, originalToolResult);
+            }
             // Log hook execution results for debugging
             if (results.length > 0) {
                 this.logger?.debug(`Executed ${results.length} PostToolUse hook(s) for ${toolName}:`, results.map((r) => ({

package/dist/managers/backgroundBashManager.d.ts

@@ -1,4 +1,4 @@
-import type { BackgroundShell } from "../types.js";
+import type { BackgroundShell } from "../types/index.js";
 export interface BackgroundBashManagerCallbacks {
     onShellsChange?: (shells: BackgroundShell[]) => void;
 }

package/dist/managers/backgroundBashManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"backgroundBashManager.d.ts","sourceRoot":"","sources":["../../src/managers/backgroundBashManager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,MAAM,WAAW,8BAA8B;IAC7C,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,EAAE,KAAK,IAAI,CAAC;CACtD;AAED,MAAM,WAAW,4BAA4B;IAC3C,SAAS,CAAC,EAAE,8BAA8B,CAAC;IAC3C,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,qBAAqB;IAChC,OAAO,CAAC,MAAM,CAAsC;IACpD,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,SAAS,CAAiC;IAClD,OAAO,CAAC,OAAO,CAAS;gBAEZ,OAAO,EAAE,4BAA4B;IAKjD,OAAO,CAAC,kBAAkB;IAInB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM;IAsErD,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAIjD,YAAY,IAAI,eAAe,EAAE;IAIjC,SAAS,CACd,EAAE,EAAE,MAAM,EACV,MAAM,CAAC,EAAE,MAAM,GACd;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAiCrD,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAmD9B,OAAO,IAAI,IAAI;CAUvB"}
+{"version":3,"file":"backgroundBashManager.d.ts","sourceRoot":"","sources":["../../src/managers/backgroundBashManager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,MAAM,WAAW,8BAA8B;IAC7C,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,EAAE,KAAK,IAAI,CAAC;CACtD;AAED,MAAM,WAAW,4BAA4B;IAC3C,SAAS,CAAC,EAAE,8BAA8B,CAAC;IAC3C,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,qBAAqB;IAChC,OAAO,CAAC,MAAM,CAAsC;IACpD,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,SAAS,CAAiC;IAClD,OAAO,CAAC,OAAO,CAAS;gBAEZ,OAAO,EAAE,4BAA4B;IAKjD,OAAO,CAAC,kBAAkB;IAInB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM;IAsErD,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAIjD,YAAY,IAAI,eAAe,EAAE;IAIjC,SAAS,CACd,EAAE,EAAE,MAAM,EACV,MAAM,CAAC,EAAE,MAAM,GACd;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAiCrD,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAmD9B,OAAO,IAAI,IAAI;CAUvB"}

package/dist/{hooks/manager.d.ts → managers/hookManager.d.ts}

@@ -4,10 +4,10 @@
  * Central orchestrator for the hooks system. Handles configuration loading,
  * validation, and hook execution across all supported events.
  */
-import { type HookEvent, type HookConfiguration, type PartialHookConfiguration, type HookExecutionContext, type ExtendedHookExecutionContext, type HookExecutionResult, type ValidationResult } from "./types.js";
-import { type IHookMatcher } from "./matcher.js";
-import { type IHookExecutor } from "./executor.js";
-import type { Logger } from "../types.js";
+import { type HookEvent, type HookConfiguration, type PartialHookConfiguration, type HookExecutionContext, type ExtendedHookExecutionContext, type HookExecutionResult, type ValidationResult } from "../types/hooks.js";
+import { type IHookMatcher } from "../utils/hookMatcher.js";
+import type { Logger } from "../types/index.js";
+import type { MessageManager } from "./messageManager.js";
 export interface IHookManager {
     loadConfiguration(userHooks?: PartialHookConfiguration, projectHooks?: PartialHookConfiguration): void;
     loadConfigurationFromSettings(): void;
@@ -19,10 +19,9 @@ export interface IHookManager {
 export declare class HookManager implements IHookManager {
     private configuration;
     private readonly matcher;
-    private readonly executor;
     private readonly logger?;
     private readonly workdir;
-    constructor(workdir: string, matcher?: IHookMatcher, executor?: IHookExecutor, logger?: Logger);
+    constructor(workdir: string, matcher?: IHookMatcher, logger?: Logger);
     /**
      * Load and merge hook configurations from user and project settings
      * Project settings take precedence over user settings
@@ -37,6 +36,26 @@ export declare class HookManager implements IHookManager {
      * Execute hooks for a specific event
      */
     executeHooks(event: HookEvent, context: HookExecutionContext | ExtendedHookExecutionContext): Promise<HookExecutionResult[]>;
+    /**
+     * 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;
+    };
+    /**
+     * Handle successful hook execution (exit code 0)
+     */
+    private handleHookSuccess;
+    /**
+     * Handle blocking error (exit code 2) - behavior varies by hook type
+     */
+    private handleBlockingError;
+    /**
+     * Handle non-blocking error (other exit codes)
+     */
+    private handleNonBlockingError;
     /**
      * Check if hooks are configured for an event/tool combination
      */
@@ -87,4 +106,4 @@ export declare class HookManager implements IHookManager {
         eventBreakdown: Record<HookEvent, number>;
     };
 }
-//# sourceMappingURL=manager.d.ts.map
+//# sourceMappingURL=hookManager.d.ts.map

package/dist/managers/hookManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hookManager.d.ts","sourceRoot":"","sources":["../../src/managers/hookManager.ts"],"names":[],"mappings":"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"}

package/dist/{hooks/manager.js → managers/hookManager.js}

@@ -4,18 +4,13 @@
  * Central orchestrator for the hooks system. Handles configuration loading,
  * validation, and hook execution across all supported events.
  */
-import { HookConfigurationError, isValidHookEvent, isValidHookEventConfig, } from "./types.js";
-import { HookMatcher } from "./matcher.js";
-import { HookExecutor } from "./executor.js";
-import { loadMergedHooksConfig } from "./settings.js";
+import { HookConfigurationError, isValidHookEvent, isValidHookEventConfig, } from "../types/hooks.js";
+import { HookMatcher } from "../utils/hookMatcher.js";
+import { executeCommand, isCommandSafe, loadMergedHooksConfig, } from "../services/hook.js";
 export class HookManager {
-    constructor(workdir, matcher = new HookMatcher(), executor, logger) {
+    constructor(workdir, matcher = new HookMatcher(), 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;
     }
     /**
@@ -48,13 +43,15 @@ export class HookManager {
             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`);
+            this.logger?.debug(`[HookManager] Configuration loaded successfully with ${Object.keys(mergedConfig || {}).length} event types`);
         }
         catch (error) {
             // If loading fails, start with undefined configuration (no hooks)
@@ -110,7 +107,7 @@ export class HookManager {
                 const hookCommand = config.hooks[commandIndex];
                 try {
                     this.logger?.debug(`[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
                     if (result.success) {
@@ -138,9 +135,102 @@ export class HookManager {
         // Generate execution summary
         const totalDuration = Date.now() - startTime;
         const summary = this.generateExecutionSummary(event, 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, results, messageManager, toolId, originalToolResult) {
+        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)
+     */
+    handleHookSuccess(event, result, messageManager) {
+        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
+     */
+    handleBlockingError(event, result, messageManager, toolId, originalToolResult) {
+        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)
+     */
+    handleNonBlockingError(result, messageManager) {
+        const errorMessage = result.stderr?.trim() || "Hook execution failed";
+        messageManager.addErrorBlock(errorMessage);
+    }
     /**
      * Check if hooks are configured for an event/tool combination
      */
@@ -347,7 +437,7 @@ export class HookManager {
         }
         // 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/dist/managers/mcpManager.d.ts

@@ -1,6 +1,6 @@
 import { ChatCompletionFunctionTool } from "openai/resources.js";
 import type { ToolPlugin, ToolResult, ToolContext } from "../tools/types.js";
-import type { Logger, McpServerConfig, McpConfig, McpTool, McpServerStatus } from "../types.js";
+import type { Logger, McpServerConfig, McpConfig, McpTool, McpServerStatus } from "../types/index.js";
 export interface McpManagerCallbacks {
     onServersChange?: (servers: McpServerStatus[]) => void;
 }

package/dist/managers/mcpManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcpManager.d.ts","sourceRoot":"","sources":["../../src/managers/mcpManager.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AAEjE,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC7E,OAAO,KAAK,EACV,MAAM,EACN,eAAe,EACf,SAAS,EACT,OAAO,EACP,eAAe,EAChB,MAAM,aAAa,CAAC;AAQrB,MAAM,WAAW,mBAAmB;IAClC,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,eAAe,EAAE,KAAK,IAAI,CAAC;CACxD;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,CAAC,EAAE,mBAAmB,CAAC;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,OAAO,CAA2C;IAC1D,OAAO,CAAC,WAAW,CAAyC;IAC5D,OAAO,CAAC,UAAU,CAAc;IAChC,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,SAAS,CAAsB;IACvC,OAAO,CAAC,MAAM,CAAC,CAAS;gBAEZ,OAAO,GAAE,iBAAsB;IAK3C;;OAEG;IACG,UAAU,CACd,OAAO,EAAE,MAAM,EACf,WAAW,GAAE,OAAe,GAC3B,OAAO,CAAC,IAAI,CAAC;IA4CV,kBAAkB,IAAI,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAO/C,UAAU,IAAI,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IA0CvC,UAAU,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC;IAWrD,SAAS,IAAI,SAAS,GAAG,IAAI;IAI7B,aAAa,IAAI,eAAe,EAAE;IAIlC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAIpD,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,IAAI;IASzE,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,GAAG,OAAO;IAyBzD,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAgB7B,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA4F7C,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA2BtD,oBAAoB,IAAI,OAAO,EAAE;IAW3B,cAAc,CAClB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,MAAM,CAAC,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,SAAS,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KACtD,CAAC;IAoEI,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAS9B;;OAEG;IACH,iBAAiB,IAAI,UAAU,EAAE;IAuBjC;;OAEG;IACH,iBAAiB,IAAI,0BAA0B,EAAE;IAIjD;;OAEG;IACG,wBAAwB,CAC5B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,UAAU,CAAC;IActB;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAIjC"}
+{"version":3,"file":"mcpManager.d.ts","sourceRoot":"","sources":["../../src/managers/mcpManager.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AAEjE,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC7E,OAAO,KAAK,EACV,MAAM,EACN,eAAe,EACf,SAAS,EACT,OAAO,EACP,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAQ3B,MAAM,WAAW,mBAAmB;IAClC,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,eAAe,EAAE,KAAK,IAAI,CAAC;CACxD;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,CAAC,EAAE,mBAAmB,CAAC;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,OAAO,CAA2C;IAC1D,OAAO,CAAC,WAAW,CAAyC;IAC5D,OAAO,CAAC,UAAU,CAAc;IAChC,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,SAAS,CAAsB;IACvC,OAAO,CAAC,MAAM,CAAC,CAAS;gBAEZ,OAAO,GAAE,iBAAsB;IAK3C;;OAEG;IACG,UAAU,CACd,OAAO,EAAE,MAAM,EACf,WAAW,GAAE,OAAe,GAC3B,OAAO,CAAC,IAAI,CAAC;IA4CV,kBAAkB,IAAI,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAO/C,UAAU,IAAI,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IA0CvC,UAAU,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC;IAWrD,SAAS,IAAI,SAAS,GAAG,IAAI;IAI7B,aAAa,IAAI,eAAe,EAAE;IAIlC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAIpD,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,IAAI;IASzE,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,GAAG,OAAO;IAyBzD,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAgB7B,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA4F7C,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA2BtD,oBAAoB,IAAI,OAAO,EAAE;IAW3B,cAAc,CAClB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,MAAM,CAAC,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,SAAS,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KACtD,CAAC;IAoEI,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAS9B;;OAEG;IACH,iBAAiB,IAAI,UAAU,EAAE;IAuBjC;;OAEG;IACH,iBAAiB,IAAI,0BAA0B,EAAE;IAIjD;;OAEG;IACG,wBAAwB,CAC5B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,UAAU,CAAC;IActB;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAIjC"}

package/dist/managers/mcpManager.js

@@ -20,17 +20,17 @@ export class McpManager {
         this.configPath = join(workdir, ".mcp.json");
         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();
             if (config && config.mcpServers) {
                 // Connect to all configured servers
                 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(`Successfully connected to MCP server: ${serverName}`);
+                            this.logger?.debug(`Successfully connected to MCP server: ${serverName}`);
                         }
                         else {
                             this.logger?.warn(`Failed to connect to MCP server: ${serverName}`);
@@ -43,7 +43,7 @@ export class McpManager {
                 // Wait for all connection attempts to complete
                 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());
         }
@@ -188,7 +188,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",