wave-agent-sdk 0.10.3 → 0.11.0

package/src/utils/containerSetup.ts

@@ -14,6 +14,7 @@ import { SkillManager } from "../managers/skillManager.js";
 import { SlashCommandManager } from "../managers/slashCommandManager.js";
 import { PluginManager } from "../managers/pluginManager.js";
 import { BangManager } from "../managers/bangManager.js";
+import { CronManager } from "../managers/cronManager.js";
 import { MemoryRuleManager } from "../managers/MemoryRuleManager.js";
 import { ReversionManager } from "../managers/reversionManager.js";
 import { SubagentManager } from "../managers/subagentManager.js";
@@ -21,6 +22,7 @@ import { LiveConfigManager } from "../managers/liveConfigManager.js";
 import { ConfigurationService } from "../services/configurationService.js";
 import { ReversionService } from "../services/reversionService.js";
 import { MemoryService } from "../services/memory.js";
+import { getGitMainRepoRoot } from "./gitUtils.js";
 import type { AgentOptions } from "../types/index.js";
 import type {
   PermissionMode,
@@ -69,11 +71,17 @@ export function setupAgentContainer(
 
   const callbacks = options.callbacks || {};
   const container = new Container();
+  container.register("AgentOptions", options);
 
   const foregroundTaskManager = new ForegroundTaskManager(container);
   container.register("ForegroundTaskManager", foregroundTaskManager);
   container.register("ConfigurationService", configurationService);
 
+  if (options.worktreeName) {
+    container.register("WorktreeName", options.worktreeName);
+    container.register("MainRepoRoot", getGitMainRepoRoot(workdir));
+  }
+
   const memoryService = new MemoryService(container);
   container.register("MemoryService", memoryService);
 
@@ -130,13 +138,17 @@ export function setupAgentContainer(
   const lspManager = options.lspManager || new LspManager(container);
   container.register("LspManager", lspManager);
 
-  const permissionManager = new PermissionManager(container, { workdir });
+  const permissionManager = new PermissionManager(container, {
+    workdir,
+    instanceAllowedRules: options.allowedTools,
+    instanceDeniedRules: options.disallowedTools,
+  });
   if (configurationService.resolveAutoMemoryEnabled()) {
     const autoMemoryDir = memoryService.getAutoMemoryDirectory(workdir);
     permissionManager.addSystemAdditionalDirectory(autoMemoryDir);
   }
   container.register("PermissionManager", permissionManager);
-  permissionManager.setOnConfiguredDefaultModeChange((mode) => {
+  permissionManager.setOnConfiguredPermissionModeChange((mode) => {
     handlePlanModeTransition(mode);
     onPermissionModeChange(mode);
   });
@@ -153,30 +165,45 @@ export function setupAgentContainer(
   });
   container.register("SkillManager", skillManager);
 
-  container.register(
-    "ReversionService",
-    new ReversionService(messageManager.getTranscriptPath()),
-  );
+  const rootSessionId = messageManager.getRootSessionId();
+
+  container.register("ReversionService", new ReversionService(rootSessionId));
   const reversionManager = new ReversionManager(container);
   container.register("ReversionManager", reversionManager);
 
-  const canUseToolWithNotification = options.canUseTool
+  const canUseToolWithPermissionRequest = options.canUseTool
     ? async (context: ToolPermissionContext) => {
         try {
-          const notificationMessage = `Claude needs your permission to use ${context.toolName}`;
-          await hookManager.executeHooks("Notification", {
-            event: "Notification",
+          const results = await hookManager.executeHooks("PermissionRequest", {
+            event: "PermissionRequest",
             projectDir: workdir,
             timestamp: new Date(),
             sessionId: messageManager.getSessionId(),
             transcriptPath: messageManager.getTranscriptPath(),
             cwd: workdir,
-            message: notificationMessage,
-            notificationType: "permission_prompt",
+            toolName: context.toolName,
+            toolInput: context.toolInput,
             env: configurationService.getEnvironmentVars(),
           });
+
+          if (results.length > 0) {
+            const processResult = hookManager.processHookResults(
+              "PermissionRequest",
+              results,
+              messageManager,
+            );
+
+            if (processResult.shouldBlock) {
+              return {
+                behavior: "deny",
+                message:
+                  processResult.errorMessage ||
+                  "Permission denied by hook execution",
+              };
+            }
+          }
         } catch (error) {
-          logger.warn("Failed to execute notification hooks", {
+          logger.warn("Failed to execute permission request hooks", {
             toolName: context.toolName,
             error: error instanceof Error ? error.message : String(error),
           });
@@ -215,9 +242,9 @@ export function setupAgentContainer(
 
   container.register("PermissionMode", options.permissionMode);
   logger.info("Registering CanUseToolCallback", {
-    hasCallback: !!canUseToolWithNotification,
+    hasCallback: !!canUseToolWithPermissionRequest,
   });
-  container.register("CanUseToolCallback", canUseToolWithNotification);
+  container.register("CanUseToolCallback", canUseToolWithPermissionRequest);
 
   const liveConfigManager = new LiveConfigManager(container, { workdir });
   container.register("LiveConfigManager", liveConfigManager);
@@ -233,11 +260,14 @@ export function setupAgentContainer(
       onSubagentAssistantReasoningUpdated:
         callbacks.onSubagentAssistantReasoningUpdated,
       onSubagentToolBlockUpdated: callbacks.onSubagentToolBlockUpdated,
-      onSubagentMessagesChange: callbacks.onSubagentMessagesChange,
+      onSubagentMessagesChange: (subagentId, messages) => {
+        callbacks.onSubagentMessagesChange?.(subagentId, messages);
+      },
       onSubagentLatestTotalTokensChange:
         callbacks.onSubagentLatestTotalTokensChange,
     },
     onUsageAdded: (usage: Usage) => addUsage(usage),
+    stream,
   });
   container.register("SubagentManager", subagentManager);
 
@@ -262,5 +292,9 @@ export function setupAgentContainer(
   const bangManager = new BangManager(container, { workdir });
   container.register("BangManager", bangManager);
 
+  const cronManager = new CronManager(container);
+  container.register("CronManager", cronManager);
+  cronManager.start();
+
   return container;
 }

package/src/utils/mcpUtils.ts

@@ -79,6 +79,7 @@ export function createMcpToolPlugin(
   executeTool: (
     name: string,
     args: Record<string, unknown>,
+    context?: ToolContext,
   ) => Promise<{
     success: boolean;
     content: string;
@@ -95,11 +96,7 @@ export function createMcpToolPlugin(
       context?: ToolContext,
     ): Promise<ToolResult> {
       try {
-        // Context is available for future use when MCP tools need execution context
-        if (context) {
-          // Future: Could pass working directory or other context to MCP tools
-        }
-        const result = await executeTool(prefixedName, args);
+        const result = await executeTool(prefixedName, args, context);
         return {
           success: true,
           content: result.content || `Executed ${mcpTool.name}`,

package/dist/builtin-skills/settings/HOOKS.md

@@ -1,95 +0,0 @@
-# Wave Hooks Configuration
-
-Hooks allow you to automate tasks when certain events occur in Wave. This document provides detailed guidance on how to configure complex hooks in `settings.json`.
-
-## Hook Events
-
-Wave supports the following hook events:
-
-- `WorktreeCreate`: Triggered when a new worktree is created.
-- `TaskStart`: Triggered when a task starts.
-- `TaskComplete`: Triggered when a task is completed.
-- `TaskError`: Triggered when a task fails.
-- `SessionStart`: Triggered when a new session starts.
-- `SessionEnd`: Triggered when a session ends.
-
-## Hook Configuration Structure
-
-Hooks are configured in the `hooks` field of `settings.json`. Each event can have multiple hook configurations.
-
-```json
-{
-  "hooks": {
-    "WorktreeCreate": [
-      {
-        "command": "pnpm install",
-        "description": "Install dependencies in new worktree",
-        "blocking": true,
-        "timeout": 300000
-      }
-    ],
-    "TaskComplete": [
-      {
-        "command": "pnpm test",
-        "description": "Run tests after task completion",
-        "blocking": false
-      }
-    ]
-  }
-}
-```
-
-## Hook Configuration Fields
-
-- `command`: The shell command to execute.
-- `description`: A brief description of the hook's purpose.
-- `blocking`: (Optional) Whether the hook should block the main agent's execution (default: `false`).
-- `timeout`: (Optional) Maximum execution time in milliseconds (default: `60000`).
-- `env`: (Optional) Environment variables specific to this hook.
-- `cwd`: (Optional) Working directory for the hook command.
-
-## Advanced Hook Examples
-
-### 1. Conditional Hooks
-You can use shell logic within the `command` field to create conditional hooks.
-```json
-{
-  "hooks": {
-    "TaskComplete": [
-      {
-        "command": "if [ \"$WAVE_TASK_STATUS\" = \"completed\" ]; then pnpm lint; fi",
-        "description": "Run linting only on successful task completion"
-      }
-    ]
-  }
-}
-```
-
-### 2. Hook Chaining
-You can chain multiple commands in a single hook or define multiple hooks for the same event.
-```json
-{
-  "hooks": {
-    "WorktreeCreate": [
-      {
-        "command": "pnpm install && pnpm build",
-        "description": "Install and build in new worktree"
-      }
-    ]
-  }
-}
-```
-
-### 3. Using Environment Variables
-Wave provides several environment variables to hooks:
-- `WAVE_PROJECT_DIR`: The root directory of the project.
-- `WAVE_SESSION_ID`: The current session ID.
-- `WAVE_TASK_ID`: The current task ID (if applicable).
-- `WAVE_TASK_STATUS`: The status of the task (for `TaskComplete` and `TaskError`).
-
-## Best Practices
-
-- **Keep hooks fast**: Long-running hooks can slow down your workflow, especially if they are `blocking`.
-- **Use descriptive names**: Help yourself and others understand what each hook does.
-- **Test your hooks**: Run the commands manually first to ensure they work as expected.
-- **Use local overrides**: For machine-specific hooks, use `.wave/settings.local.json`.