wave-agent-sdk 0.10.4 → 0.11.0

package/src/tools/bashTool.ts

@@ -377,11 +377,12 @@ Usage notes:
             combinedOutput || `Command executed with exit code: ${exitCode}`;
           const content = processOutput(finalOutput);
 
-          const shortResult = combinedOutput
-            .trim()
-            .split("\n")
-            .slice(-3)
-            .join("\n");
+          const lines = combinedOutput.trim().split("\n");
+          const shortResult =
+            lines.length <= 3
+              ? lines.join("\n")
+              : lines.slice(0, 3).join("\n") +
+                `\n... +${lines.length - 3} lines`;
 
           resolve({
             success: exitCode === 0,

package/src/tools/cronCreateTool.ts

@@ -0,0 +1,73 @@
+import { ToolPlugin, ToolResult, ToolContext } from "./types.js";
+import { CRON_CREATE_TOOL_NAME } from "../constants/tools.js";
+
+export const cronCreateTool: ToolPlugin = {
+  name: CRON_CREATE_TOOL_NAME,
+  config: {
+    type: "function",
+    function: {
+      name: CRON_CREATE_TOOL_NAME,
+      description:
+        "Schedule a prompt to be enqueued at a future time. Use for both recurring schedules and one-shot reminders.",
+      parameters: {
+        type: "object",
+        properties: {
+          cron: {
+            type: "string",
+            description:
+              'Standard 5-field cron expression in local time: "M H DoM Mon DoW"',
+          },
+          prompt: {
+            type: "string",
+            description: "The prompt to enqueue at each fire time",
+          },
+          recurring: {
+            type: "boolean",
+            description:
+              "Default: true. true = fire on every cron match until deleted or auto-expired after 7 days. false = fire once at the next match, then auto-delete",
+            default: true,
+          },
+        },
+        required: ["cron", "prompt"],
+      },
+    },
+  },
+  execute: async (
+    args: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolResult> => {
+    const {
+      cron,
+      prompt,
+      recurring = true,
+    } = args as { cron: string; prompt: string; recurring?: boolean };
+
+    if (!context.cronManager) {
+      return {
+        success: false,
+        content: "",
+        error: "CronManager not available",
+      };
+    }
+
+    try {
+      const job = context.cronManager.createJob({
+        cron,
+        prompt,
+        recurring,
+      });
+
+      return {
+        success: true,
+        content: JSON.stringify({ id: job.id }, null, 2),
+        shortResult: `Scheduled job ${job.id}`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        content: "",
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  },
+};

package/src/tools/cronDeleteTool.ts

@@ -0,0 +1,47 @@
+import { ToolPlugin, ToolResult, ToolContext } from "./types.js";
+import { CRON_DELETE_TOOL_NAME } from "../constants/tools.js";
+
+export const cronDeleteTool: ToolPlugin = {
+  name: CRON_DELETE_TOOL_NAME,
+  config: {
+    type: "function",
+    function: {
+      name: CRON_DELETE_TOOL_NAME,
+      description:
+        "Cancel a cron job previously scheduled with CronCreate. Removes it from the in-memory session store.",
+      parameters: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: "Job ID returned by CronCreate",
+          },
+        },
+        required: ["id"],
+      },
+    },
+  },
+  execute: async (
+    args: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolResult> => {
+    const { id } = args as { id: string };
+
+    if (!context.cronManager) {
+      return {
+        success: false,
+        content: "",
+        error: "CronManager not available",
+      };
+    }
+
+    const success = context.cronManager.deleteJob(id);
+
+    return {
+      success,
+      content: JSON.stringify({ success }, null, 2),
+      shortResult: success ? `Deleted job ${id}` : `Job ${id} not found`,
+      error: success ? undefined : `Job ${id} not found`,
+    };
+  },
+};

package/src/tools/cronListTool.ts

@@ -0,0 +1,38 @@
+import { ToolPlugin, ToolResult, ToolContext } from "./types.js";
+import { CRON_LIST_TOOL_NAME } from "../constants/tools.js";
+
+export const cronListTool: ToolPlugin = {
+  name: CRON_LIST_TOOL_NAME,
+  config: {
+    type: "function",
+    function: {
+      name: CRON_LIST_TOOL_NAME,
+      description:
+        "List all cron jobs scheduled via CronCreate in this session.",
+      parameters: {
+        type: "object",
+        properties: {},
+      },
+    },
+  },
+  execute: async (
+    _args: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolResult> => {
+    if (!context.cronManager) {
+      return {
+        success: false,
+        content: "",
+        error: "CronManager not available",
+      };
+    }
+
+    const jobs = context.cronManager.listJobs();
+
+    return {
+      success: true,
+      content: JSON.stringify({ jobs }, null, 2),
+      shortResult: `Found ${jobs.length} jobs`,
+    };
+  },
+};

package/src/tools/skillTool.ts

@@ -11,14 +11,16 @@ import {
 /**
  * Skill tool plugin for invoking Wave skills
  */
+const SKILL_TOOL_DESCRIPTION =
+  "Execute a skill within the main conversation. When users ask you to perform tasks, check if any of the available skills match. Skills provide specialized capabilities and domain knowledge.";
+
 export const skillTool: ToolPlugin = {
   name: SKILL_TOOL_NAME,
   config: {
     type: "function" as const,
     function: {
       name: SKILL_TOOL_NAME,
-      description:
-        "Invoke a Wave skill by name. Skills are user-defined automation templates that can be personal or project-specific.",
+      description: SKILL_TOOL_DESCRIPTION,
       parameters: {
         type: "object",
         properties: {
@@ -41,7 +43,7 @@ export const skillTool: ToolPlugin = {
       (skill) => !skill.disableModelInvocation,
     );
     if (!availableSkills || availableSkills.length === 0) {
-      return "Invoke a Wave skill by name. Skills are user-defined automation templates that can be personal or project-specific. No skills are currently available.";
+      return `${SKILL_TOOL_DESCRIPTION} No skills are currently available.`;
     }
 
     const skillList = availableSkills
@@ -50,7 +52,7 @@ export const skillTool: ToolPlugin = {
       )
       .join("\n");
 
-    return `Invoke a Wave skill by name. Skills are user-defined automation templates that can be personal or project-specific.\n\nAvailable skills:\n${skillList}`;
+    return `${SKILL_TOOL_DESCRIPTION} Do not invoke the same skill repeatedly if it has already been called with the same arguments.\n\nAvailable skills:\n${skillList}`;
   },
 
   execute: async (

package/src/tools/taskOutputTool.ts

@@ -31,7 +31,7 @@ export const taskOutputTool: ToolPlugin = {
             description: "Max wait time in ms",
           },
         },
-        required: ["task_id"],
+        required: ["task_id", "block", "timeout"],
       },
     },
   },
@@ -87,8 +87,8 @@ export const taskOutputTool: ToolPlugin = {
 
       if (finalContent.length > MAX_OUTPUT_LENGTH) {
         processedContent =
-          finalContent.substring(0, MAX_OUTPUT_LENGTH) +
-          "\n\n... (output truncated)";
+          "\n\n... (output truncated)\n" +
+          finalContent.substring(finalContent.length - MAX_OUTPUT_LENGTH);
         isTruncated = true;
       }
 
@@ -155,11 +155,17 @@ export const taskOutputTool: ToolPlugin = {
             if (context.abortSignal) {
               context.abortSignal.removeEventListener("abort", onAbort);
             }
-            resolve({
-              success: true,
-              content: "Retrieval timed out",
-              shortResult: `${taskId}: timeout`,
-            });
+            const result = getResult();
+            if (result) {
+              result.shortResult = `${taskId}: timeout`;
+              resolve(result);
+            } else {
+              resolve({
+                success: true,
+                content: "Retrieval timed out",
+                shortResult: `${taskId}: timeout`,
+              });
+            }
             return;
           }
 

package/src/tools/types.ts

@@ -79,6 +79,8 @@ export interface ToolContext {
   subagentManager?: import("../managers/subagentManager.js").SubagentManager;
   /** Skill manager instance for skill invocation */
   skillManager?: import("../managers/skillManager.js").SkillManager;
+  /** Cron manager instance for scheduling tasks */
+  cronManager?: import("../managers/cronManager.js").CronManager;
   /** Current session ID */
   sessionId?: string;
   /** The ID of the current tool call */

package/src/types/agent.ts

@@ -67,6 +67,16 @@ export interface AgentOptions {
   isNewWorktree?: boolean;
   /**Whether to watch for skill changes - defaults to true */
   watchSkills?: boolean;
+  /**
+   * Optional list of tool names to always allow.
+   * These rules follow the standard permission rule syntax: `ToolName` or `ToolName(pattern)`.
+   */
+  allowedTools?: string[];
+  /**
+   * Optional list of tool names to always disallow.
+   * These rules follow the standard permission rule syntax: `ToolName` or `ToolName(pattern)`.
+   */
+  disallowedTools?: string[];
 }
 
 export interface AgentCallbacks

package/src/types/configuration.ts

@@ -21,7 +21,7 @@ export interface WaveConfiguration {
   permissions?: {
     allow?: string[];
     deny?: string[];
-    defaultMode?: PermissionMode; // Default permission mode for restricted tools
+    permissionMode?: PermissionMode; // Default permission mode for restricted tools
     /**
      * List of directories that are considered part of the Safe Zone.
      * File operations within these directories can be auto-accepted.

package/src/types/cron.ts

@@ -0,0 +1,9 @@
+export interface CronJob {
+  id: string;
+  cron: string;
+  prompt: string;
+  recurring: boolean;
+  createdAt: number;
+  nextRun: number;
+  periodMs: number;
+}

package/src/types/hooks.ts

@@ -19,7 +19,7 @@ export type HookEvent =
   | "UserPromptSubmit"
   | "Stop"
   | "SubagentStop"
-  | "Notification"
+  | "PermissionRequest"
   | "WorktreeCreate";
 
 // Individual hook command configuration
@@ -100,7 +100,7 @@ export function isValidHookEvent(event: string): event is HookEvent {
     "UserPromptSubmit",
     "Stop",
     "SubagentStop",
-    "Notification",
+    "PermissionRequest",
     "WorktreeCreate",
   ].includes(event);
 }
@@ -154,16 +154,14 @@ export interface HookJsonInput {
   session_id: string; // Format: "wave_session_{uuid}_{shortId}"
   transcript_path: string; // Format: "~/.wave/sessions/session_{shortId}.json"
   cwd: string; // Absolute path to current working directory
-  hook_event_name: HookEvent; // "PreToolUse" | "PostToolUse" | "UserPromptSubmit" | "Stop" | "SubagentStop" | "Notification"
+  hook_event_name: HookEvent; // "PreToolUse" | "PostToolUse" | "UserPromptSubmit" | "Stop" | "SubagentStop" | "PermissionRequest" | "WorktreeCreate"
 
   // Optional fields based on event type
-  tool_name?: string; // Present for PreToolUse, PostToolUse
-  tool_input?: unknown; // Present for PreToolUse, PostToolUse
+  tool_name?: string; // Present for PreToolUse, PostToolUse, PermissionRequest
+  tool_input?: unknown; // Present for PreToolUse, PostToolUse, PermissionRequest
   tool_response?: unknown; // Present for PostToolUse only
   user_prompt?: string; // Present for UserPromptSubmit only
   subagent_type?: string; // Present when hook is executed by a subagent
-  message?: string; // Present for Notification events
-  notification_type?: string; // Present for Notification events
   name?: string; // Present for WorktreeCreate events
 }
 
@@ -177,8 +175,6 @@ export interface ExtendedHookExecutionContext extends HookExecutionContext {
   env?: Record<string, string>; // Additional environment variables (from configuration)
   userPrompt?: string; // User prompt text (UserPromptSubmit only)
   subagentType?: string; // Subagent type when hook is executed by a subagent
-  message?: string; // Notification message (Notification only)
-  notificationType?: string; // Notification type (Notification only)
   worktreeName?: string; // Worktree name (WorktreeCreate only)
 }
 

package/src/types/index.ts

@@ -35,3 +35,4 @@ export * from "./memoryRule.js";
 export * from "./history.js";
 export * from "./tasks.js";
 export * from "./agent.js";
+export * from "./cron.js";

package/src/types/messaging.ts

@@ -11,7 +11,7 @@ export enum MessageSource {
 }
 
 export interface Message {
-  id?: string; // Unique identifier for the message
+  id: string; // Unique identifier for the message
   role: "user" | "assistant";
   blocks: MessageBlock[];
   usage?: Usage; // Usage data for this message's AI operation (assistant messages only)

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`.