wave-agent-sdk 0.8.3 → 0.9.0

package/src/tools/{taskTool.ts → agentTool.ts}

@@ -1,6 +1,6 @@
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import { EXPLORE_SUBAGENT_TYPE } from "../constants/subagents.js";
-import { TASK_TOOL_NAME } from "../constants/tools.js";
+import { AGENT_TOOL_NAME } from "../constants/tools.js";
 import type { SubagentConfiguration } from "../utils/subagentParser.js";
 import {
   countToolBlocks,
@@ -8,16 +8,16 @@ import {
 } from "../utils/messageOperations.js";
 
 /**
- * Task tool plugin for delegating tasks to specialized subagents
+ * Agent tool plugin for launching specialized agents to handle complex tasks
  */
-export const taskTool: ToolPlugin = {
-  name: TASK_TOOL_NAME,
+export const agentTool: ToolPlugin = {
+  name: AGENT_TOOL_NAME,
   config: {
     type: "function" as const,
     function: {
-      name: TASK_TOOL_NAME,
+      name: AGENT_TOOL_NAME,
       description:
-        "Delegate a task to a specialized subagent. Use this when you need specialized expertise or want to break down complex work into focused subtasks.",
+        "Launch a new agent to handle complex, multi-step tasks autonomously.",
       parameters: {
         type: "object",
         properties: {
@@ -47,19 +47,31 @@ export const taskTool: ToolPlugin = {
   prompt: (args?: { availableSubagents?: SubagentConfiguration[] }) => {
     const subagentList = args?.availableSubagents
       ? args.availableSubagents
-          .map((config) => `- ${config.name}: ${config.description}`)
+          .map((config) => {
+            let toolsStr = "";
+            if (config.tools && config.tools.length > 0) {
+              toolsStr = ` (Tools: ${config.tools.join(", ")})`;
+            } else {
+              toolsStr = " (Tools: *)";
+            }
+
+            return `- ${config.name}: ${config.description}${toolsStr}`;
+          })
           .join("\n")
       : "";
 
-    return `
-Delegate a task to a specialized subagent. Use this when you need specialized expertise or want to break down complex work into focused subtasks.
+    return `Launch a new agent to handle complex, multi-step tasks autonomously.
+
+The Agent tool launches specialized agents (subprocesses) that autonomously handle complex tasks. Each agent type has specific capabilities and tools available to it.
+
+Available agent types and the tools they have access to:
+${subagentList || "No agents configured"}
 
-Available subagents:
-${subagentList || "No subagents configured"}
+When using the Agent tool, you must specify a subagent_type parameter to select which agent type to use.
 
-- When doing file search, prefer to use the ${TASK_TOOL_NAME} tool in order to reduce context usage.
-- You should proactively use the ${TASK_TOOL_NAME} tool with specialized agents when the task at hand matches the agent's description.
-- VERY IMPORTANT: When exploring the codebase to gather context or to answer a question that is not a needle query for a specific file/class/function, it is CRITICAL that you use the ${TASK_TOOL_NAME} tool with subagent_type=${EXPLORE_SUBAGENT_TYPE} instead of running search commands directly.`;
+- When doing file search, prefer to use the ${AGENT_TOOL_NAME} tool in order to reduce context usage.
+- You should proactively use the ${AGENT_TOOL_NAME} tool with specialized agents when the task at hand matches the agent's description.
+- VERY IMPORTANT: When exploring the codebase to gather context or to answer a question that is not a needle query for a specific file/class/function, it is CRITICAL that you use the ${AGENT_TOOL_NAME} tool with subagent_type=${EXPLORE_SUBAGENT_TYPE} instead of running search commands directly.`;
   },
 
   execute: async (
@@ -72,7 +84,7 @@ ${subagentList || "No subagents configured"}
         success: false,
         content: "",
         error: "Subagent manager not available in tool context",
-        shortResult: "Task delegation failed",
+        shortResult: "Agent delegation failed",
       };
     }
 
@@ -87,7 +99,7 @@ ${subagentList || "No subagents configured"}
         success: false,
         content: "",
         error: "description parameter is required and must be a string",
-        shortResult: "Task delegation failed",
+        shortResult: "Agent delegation failed",
       };
     }
 
@@ -96,7 +108,7 @@ ${subagentList || "No subagents configured"}
         success: false,
         content: "",
         error: "prompt parameter is required and must be a string",
-        shortResult: "Task delegation failed",
+        shortResult: "Agent delegation failed",
       };
     }
 
@@ -105,7 +117,7 @@ ${subagentList || "No subagents configured"}
         success: false,
         content: "",
         error: "subagent_type parameter is required and must be a string",
-        shortResult: "Task delegation failed",
+        shortResult: "Agent delegation failed",
       };
     }
 
@@ -121,14 +133,14 @@ ${subagentList || "No subagents configured"}
         return {
           success: false,
           content: "",
-          error: `No subagent found matching "${subagent_type}". Available subagents: ${availableNames || "none"}`,
-          shortResult: "Subagent not found",
+          error: `No agent found matching "${subagent_type}". Available agents: ${availableNames || "none"}`,
+          shortResult: "Agent not found",
         };
       }
 
       let isBackgrounded = false;
 
-      // Create subagent instance and execute task
+      // Create subagent instance and execute agent
       const instance = await subagentManager.createInstance(
         configuration,
         {
@@ -173,8 +185,8 @@ ${subagentList || "No subagents configured"}
                 await subagentManager.backgroundInstance(instance.subagentId);
                 resolve({
                   success: true,
-                  content: "Task backgrounded",
-                  shortResult: "Task backgrounded",
+                  content: "Agent backgrounded",
+                  shortResult: "Agent backgrounded",
                   isManuallyBackgrounded: true,
                 });
               },
@@ -182,7 +194,7 @@ ${subagentList || "No subagents configured"}
           }
 
           try {
-            const result = await subagentManager.executeTask(
+            const result = await subagentManager.executeAgent(
               instance,
               prompt,
               context.abortSignal,
@@ -196,13 +208,13 @@ ${subagentList || "No subagents configured"}
             if (run_in_background) {
               resolve({
                 success: true,
-                content: `Task started in background with ID: ${result}`,
-                shortResult: `Task started in background: ${result}`,
+                content: `Agent started in background with ID: ${result}`,
+                shortResult: `Agent started in background: ${result}`,
               });
               return;
             }
 
-            // Cleanup subagent instance after task completion
+            // Cleanup subagent instance after agent completion
             subagentManager.cleanupInstance(instance.subagentId);
 
             const messages = instance.messageManager.getMessages();
@@ -213,14 +225,14 @@ ${subagentList || "No subagents configured"}
             resolve({
               success: true,
               content: result,
-              shortResult: `Task completed${summary ? ` ${summary}` : ""}`,
+              shortResult: `Agent completed${summary ? ` ${summary}` : ""}`,
             });
           } catch (error) {
             if (!isBackgrounded) {
               resolve({
                 success: false,
                 content: "",
-                error: `Task delegation failed: ${error instanceof Error ? error.message : String(error)}`,
+                error: `Agent delegation failed: ${error instanceof Error ? error.message : String(error)}`,
                 shortResult: "Delegation error",
               });
             }
@@ -237,7 +249,7 @@ ${subagentList || "No subagents configured"}
       return {
         success: false,
         content: "",
-        error: `Task delegation failed: ${error instanceof Error ? error.message : String(error)}`,
+        error: `Agent delegation failed: ${error instanceof Error ? error.message : String(error)}`,
         shortResult: "Delegation error",
       };
     }

package/src/tools/grepTool.ts

@@ -6,7 +6,7 @@ import { getDisplayPath } from "../utils/path.js";
 import {
   GREP_TOOL_NAME,
   BASH_TOOL_NAME,
-  TASK_TOOL_NAME,
+  AGENT_TOOL_NAME,
 } from "../constants/tools.js";
 
 /**
@@ -94,7 +94,7 @@ export const grepTool: ToolPlugin = {
   - Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+")
   - Filter files with glob parameter (e.g., "*.js", "**/*.tsx") or type parameter (e.g., "js", "py", "rust")
   - Output modes: "content" shows matching lines, "files_with_matches" shows only file paths (default), "count" shows match counts
-  - Use ${TASK_TOOL_NAME} tool for open-ended searches requiring multiple rounds
+  - Use ${AGENT_TOOL_NAME} tool for open-ended searches requiring multiple rounds
   - Pattern syntax: Uses ripgrep (not grep) - literal braces need escaping (use \`interface\\{\\}\` to find \`interface{}\` in Go code)
   - Multiline matching: By default patterns match within single lines only. For cross-line patterns like \`struct \\{[\\s\\S]*?field\`, use \`multiline: true\`
 `,

package/src/tools/skillTool.ts

@@ -155,14 +155,14 @@ export const skillTool: ToolPlugin = {
         );
 
         try {
-          const result = await subagentManager.executeTask(
+          const result = await subagentManager.executeAgent(
             instance,
             skillResult.content,
             context.abortSignal,
             false,
           );
 
-          // Cleanup subagent instance after task completion
+          // Cleanup subagent instance after agent completion
           subagentManager.cleanupInstance(instance.subagentId);
 
           const messages = instance.messageManager.getMessages();

package/src/tools/types.ts

@@ -73,7 +73,7 @@ export interface ToolContext {
   foregroundTaskManager?: import("../types/processes.js").IForegroundTaskManager;
   /** Task manager instance for task management */
   taskManager: import("../services/taskManager.js").TaskManager;
-  /** Subagent manager instance for task delegation */
+  /** Subagent manager instance for agent delegation */
   subagentManager?: import("../managers/subagentManager.js").SubagentManager;
   /** Skill manager instance for skill invocation */
   skillManager?: import("../managers/skillManager.js").SkillManager;

package/src/types/configuration.ts

@@ -32,6 +32,8 @@ export interface WaveConfiguration {
   enabledPlugins?: Record<string, boolean>;
   /** Preferred language for agent communication */
   language?: string;
+  /** Whether auto-memory is enabled */
+  autoMemoryEnabled?: boolean;
 }
 
 /**

package/src/types/hooks.ts

@@ -26,6 +26,8 @@ export type HookEvent =
 export interface HookCommand {
   type: "command";
   command: string;
+  async?: boolean;
+  timeout?: number; // seconds
 }
 
 // Hook event configuration with optional pattern matching
@@ -104,15 +106,29 @@ export function isValidHookEvent(event: string): event is HookEvent {
 }
 
 export function isValidHookCommand(cmd: unknown): cmd is HookCommand {
-  return (
-    typeof cmd === "object" &&
-    cmd !== null &&
-    "type" in cmd &&
-    cmd.type === "command" &&
-    "command" in cmd &&
-    typeof cmd.command === "string" &&
-    cmd.command.length > 0
-  );
+  if (
+    typeof cmd !== "object" ||
+    cmd === null ||
+    !("type" in cmd) ||
+    cmd.type !== "command" ||
+    !("command" in cmd) ||
+    typeof cmd.command !== "string" ||
+    cmd.command.length === 0
+  ) {
+    return false;
+  }
+
+  const hookCmd = cmd as Record<string, unknown>;
+
+  if ("async" in hookCmd && typeof hookCmd.async !== "boolean") {
+    return false;
+  }
+
+  if ("timeout" in hookCmd && typeof hookCmd.timeout !== "number") {
+    return false;
+  }
+
+  return true;
 }
 
 export function isValidHookEventConfig(

package/src/utils/builtinSubagents.ts

@@ -15,7 +15,6 @@ import {
   GLOB_TOOL_NAME,
   GREP_TOOL_NAME,
   READ_TOOL_NAME,
-  LS_TOOL_NAME,
   LSP_TOOL_NAME,
 } from "../constants/tools.js";
 import type { SubagentConfiguration } from "./subagentParser.js";
@@ -79,7 +78,6 @@ function createExploreSubagent(): SubagentConfiguration {
     GREP_TOOL_NAME,
     READ_TOOL_NAME,
     BASH_TOOL_NAME,
-    LS_TOOL_NAME,
     LSP_TOOL_NAME,
   ];
 
@@ -107,7 +105,6 @@ function createPlanSubagent(): SubagentConfiguration {
     GREP_TOOL_NAME,
     READ_TOOL_NAME,
     BASH_TOOL_NAME,
-    LS_TOOL_NAME,
     LSP_TOOL_NAME,
   ];
 

package/src/utils/containerSetup.ts

@@ -21,6 +21,7 @@ import { SubagentManager } from "../managers/subagentManager.js";
 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 type { AgentOptions } from "../types/index.js";
 import type {
   PermissionMode,
@@ -29,7 +30,6 @@ import type {
   BackgroundTask,
   ToolPermissionContext,
 } from "../types/index.js";
-import type { GatewayConfig, ModelConfig } from "../types/config.js";
 
 import { logger } from "./globalLogger.js";
 
@@ -48,12 +48,6 @@ export interface AgentContainerSetupOptions {
   setPermissionMode: (mode: PermissionMode) => void;
   addPermissionRule: (rule: string) => Promise<void>;
   addUsage: (usage: Usage) => void;
-
-  // Getters
-  getGatewayConfig: () => GatewayConfig;
-  getModelConfig: () => ModelConfig;
-  getMaxInputTokens: () => number;
-  getLanguage: () => string | undefined;
 }
 
 export function setupAgentContainer(
@@ -72,10 +66,6 @@ export function setupAgentContainer(
     setPermissionMode,
     addPermissionRule,
     addUsage,
-    getGatewayConfig,
-    getModelConfig,
-    getMaxInputTokens,
-    getLanguage,
   } = setupOptions;
 
   const callbacks = options.callbacks || {};
@@ -85,6 +75,9 @@ export function setupAgentContainer(
   container.register("ForegroundTaskManager", foregroundTaskManager);
   container.register("ConfigurationService", configurationService);
 
+  const memoryService = new MemoryService(container);
+  container.register("MemoryService", memoryService);
+
   const memoryRuleManager = new MemoryRuleManager(container, { workdir });
   container.register("MemoryRuleManager", memoryRuleManager);
 
@@ -139,6 +132,10 @@ export function setupAgentContainer(
   container.register("LspManager", lspManager);
 
   const permissionManager = new PermissionManager(container, { workdir });
+  if (configurationService.resolveAutoMemoryEnabled()) {
+    const autoMemoryDir = memoryService.getAutoMemoryDirectory(workdir);
+    permissionManager.updateAdditionalDirectories([autoMemoryDir]);
+  }
   container.register("PermissionManager", permissionManager);
   permissionManager.setOnConfiguredDefaultModeChange((mode) => {
     handlePlanModeTransition(mode);
@@ -246,11 +243,6 @@ export function setupAgentContainer(
       onSubagentLatestTotalTokensChange:
         callbacks.onSubagentLatestTotalTokensChange,
     },
-    getGatewayConfig,
-    getModelConfig,
-    getMaxInputTokens,
-    getLanguage,
-    getEnvironmentVars: () => configurationService.getEnvironmentVars(),
     onUsageAdded: (usage: Usage) => addUsage(usage),
   });
   container.register("SubagentManager", subagentManager);
@@ -263,11 +255,6 @@ export function setupAgentContainer(
     workdir,
     systemPrompt,
     stream,
-    getGatewayConfig,
-    getModelConfig,
-    getMaxInputTokens,
-    getLanguage,
-    getEnvironmentVars: () => configurationService.getEnvironmentVars(),
   });
   container.register("AIManager", aiManager);
 

package/src/utils/fileSearch.ts

@@ -1,26 +1,78 @@
-import { globIterate, type Path } from "glob";
+import { spawn } from "child_process";
+import { rgPath } from "@vscode/ripgrep";
+import fuzzysort from "fuzzysort";
 import { getGlobIgnorePatterns } from "./fileFilter.js";
 import type { FileItem } from "../types/fileSearch.js";
+import { logger } from "./globalLogger.js";
 
 /**
- * Convert Path objects to FileItem objects
+ * Execute ripgrep to get all file paths
  */
-export const convertPathsToFileItems = (paths: Path[]): FileItem[] => {
-  return paths.map((pathObj) => {
-    const isDirectory = pathObj.isDirectory();
-    let path = pathObj.relative();
-    if (isDirectory && !path.endsWith("/")) {
-      path += "/";
-    }
-    return {
-      path,
-      type: isDirectory ? "directory" : "file",
-    };
+async function getAllFiles(workingDirectory: string): Promise<string[]> {
+  if (!rgPath) {
+    throw new Error("ripgrep is not available");
+  }
+
+  const ignorePatterns = getGlobIgnorePatterns(workingDirectory);
+  const rgArgs = ["--files", "--color=never", "--hidden"];
+  for (const pattern of ignorePatterns) {
+    rgArgs.push("--glob", `!${pattern}`);
+  }
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(rgPath, rgArgs, {
+      cwd: workingDirectory,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+
+    child.on("close", (code) => {
+      if (code !== 0 && code !== 1) {
+        reject(new Error(`ripgrep failed: ${stderr}`));
+        return;
+      }
+      const files = stdout
+        .trim()
+        .split("\n")
+        .filter((f) => f.length > 0)
+        .map((f) => f.replace(/\\/g, "/")); // Normalize to forward slashes
+      resolve(files);
+    });
+
+    child.on("error", (err) => {
+      reject(err);
+    });
   });
-};
+}
+
+/**
+ * Derive directory paths from file paths
+ */
+function deriveDirectories(files: string[]): string[] {
+  const dirs = new Set<string>();
+  for (const file of files) {
+    const parts = file.split("/");
+    // Add all parent directories
+    for (let i = 1; i < parts.length; i++) {
+      const dir = parts.slice(0, i).join("/") + "/";
+      dirs.add(dir);
+    }
+  }
+  return Array.from(dirs);
+}
 
 /**
- * Search files and directories using glob patterns
+ * Search files and directories using fuzzy matching
  */
 export const searchFiles = async (
   query: string,
@@ -32,83 +84,63 @@ export const searchFiles = async (
   const { maxResults = 10, workingDirectory = process.cwd() } = options || {};
 
   try {
-    const globOptions: import("glob").GlobOptionsWithFileTypesTrue = {
-      ignore: getGlobIgnorePatterns(workingDirectory),
-      maxDepth: 10,
-      nocase: true, // Case insensitive
-      dot: true, // Include hidden files and directories
-      cwd: workingDirectory, // Specify search root directory
-      withFileTypes: true, // Get Path objects instead of strings
-    };
-
-    // Build glob patterns based on query
-    let patterns: string[] = [];
+    const files = await getAllFiles(workingDirectory);
 
     if (!query.trim()) {
-      // When query is empty, show some common file types and directories
-      patterns = [
-        "**/*.{ts,tsx,js,jsx,json,py,java}", // Combine common file extensions
-        "*/", // First level directories
-      ];
-    } else {
-      // Build multiple glob patterns to support more flexible search
-      patterns = [
-        // Match files with filenames containing query
-        `**/*${query}*`,
-        // Match files with query in path (match directory names)
-        `**/${query}*/**/*`,
-        // Match directory names containing query
-        `**/*${query}*/`,
-        // Match directories containing query in path
-        `**/${query}*/`,
-      ];
-    }
+      // When query is empty, show some common file types and top-level directories
+      const commonExtensions = new Set([
+        "ts",
+        "tsx",
+        "js",
+        "jsx",
+        "json",
+        "py",
+        "java",
+      ]);
+      const results: FileItem[] = [];
+      const seenDirs = new Set<string>();
 
-    // Collect results until we reach maxResults
-    const collectedPaths: Path[] = [];
-    const seenPaths = new Set<string>();
-
-    // Process each pattern sequentially
-    for (const pattern of patterns) {
-      if (collectedPaths.length >= maxResults) {
-        break;
-      }
-
-      // Use globIterate to get results one by one
-      const iterator = globIterate(pattern, globOptions) as AsyncGenerator<
-        Path,
-        void,
-        void
-      >;
-
-      for await (const pathObj of iterator) {
-        if (collectedPaths.length >= maxResults) {
-          // Stop the iterator when we have enough results
-          break;
+      for (const file of files) {
+        const parts = file.split("/");
+        if (parts.length > 1) {
+          const topDir = parts[0] + "/";
+          if (!seenDirs.has(topDir)) {
+            seenDirs.add(topDir);
+            results.push({ path: topDir, type: "directory" });
+          }
         }
 
-        const relativePath = pathObj.relative();
-        if (!seenPaths.has(relativePath)) {
-          seenPaths.add(relativePath);
-          collectedPaths.push(pathObj);
+        const ext = file.split(".").pop();
+        if (ext && commonExtensions.has(ext)) {
+          results.push({ path: file, type: "file" });
         }
       }
+
+      // Sort: directories first, then files, then alphabetically
+      return results
+        .sort((a, b) => {
+          if (a.type === "directory" && b.type === "file") return -1;
+          if (a.type === "file" && b.type === "directory") return 1;
+          return a.path.localeCompare(b.path);
+        })
+        .slice(0, maxResults);
     }
 
-    // Sort collected paths: directories first, then files
-    collectedPaths.sort((a, b) => {
-      const aIsDir = a.isDirectory();
-      const bIsDir = b.isDirectory();
-      if (aIsDir && !bIsDir) return -1;
-      if (!aIsDir && bIsDir) return 1;
-      return a.relative().localeCompare(b.relative());
+    const directories = deriveDirectories(files);
+    const allItems: FileItem[] = [
+      ...files.map((f) => ({ path: f, type: "file" as const })),
+      ...directories.map((d) => ({ path: d, type: "directory" as const })),
+    ];
+
+    const fuzzyResults = fuzzysort.go(query, allItems, {
+      key: "path",
+      limit: maxResults,
+      threshold: 0,
     });
 
-    // Convert to FileItems
-    const fileItems = convertPathsToFileItems(collectedPaths);
-    return fileItems;
+    return fuzzyResults.map((res) => res.obj);
   } catch (error) {
-    console.error("Glob search error:", error);
+    logger.error("Fuzzy search error:", error);
     return [];
   }
 };