wave-agent-sdk 0.6.5 → 0.7.0

package/src/tools/types.ts

@@ -8,6 +8,9 @@ import type {
   PermissionCallback,
 } from "../types/permissions.js";
 
+import type { SubagentConfiguration } from "../utils/subagentParser.js";
+import type { SkillMetadata } from "../types/skills.js";
+
 export interface ToolPlugin {
   name: string;
   config: ChatCompletionFunctionTool;
@@ -22,7 +25,11 @@ export interface ToolPlugin {
   /**
    * Optional function to provide a prompt to be added to the system prompt
    */
-  prompt?: () => string;
+  prompt?: (args?: {
+    availableSubagents?: SubagentConfiguration[];
+    availableSkills?: SkillMetadata[];
+    workdir?: string;
+  }) => string;
 }
 
 export interface ToolResult {
@@ -65,6 +72,10 @@ 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 */
+  subagentManager?: import("../managers/subagentManager.js").SubagentManager;
+  /** Skill manager instance for skill invocation */
+  skillManager?: import("../managers/skillManager.js").SkillManager;
   /** Current session ID */
   sessionId?: string;
   /** Callback to update the short result of the current tool block */

package/src/tools/writeTool.ts

@@ -3,6 +3,7 @@ import { dirname } from "path";
 import { logger } from "../utils/globalLogger.js";
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import { resolvePath, getDisplayPath } from "../utils/path.js";
+import { READ_TOOL_NAME } from "../constants/tools.js";
 
 /**
  * File Write Tool Plugin
@@ -32,10 +33,11 @@ export const writeTool: ToolPlugin = {
       },
     },
   },
-  prompt: () => `
+  prompt: () => `Writes a file to the local filesystem.
+
 Usage:
 - This tool will overwrite the existing file if there is one at the provided path.
-- If this is an existing file, you MUST use the Read tool first to read the file's contents. This tool will fail if you did not read the file first.
+- If this is an existing file, you MUST use the \`${READ_TOOL_NAME}\` tool first to read the file's contents. This tool will fail if you did not read the file first.
 - ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
 - NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
 - Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.

package/src/types/marketplace.ts

@@ -11,6 +11,15 @@ export interface MarketplacePluginEntry {
   description: string;
 }
 
+export interface MarketplacePluginStatus extends MarketplacePluginEntry {
+  marketplace: string;
+  installed: boolean;
+  version?: string;
+  cachePath?: string;
+  projectPath?: string;
+  scope?: Scope;
+}
+
 export interface MarketplaceManifest {
   name: string;
   owner: MarketplaceOwner;

package/src/types/permissions.ts

@@ -10,8 +10,6 @@ import {
 } from "./tools.js";
 import {
   EDIT_TOOL_NAME,
-  MULTI_EDIT_TOOL_NAME,
-  DELETE_FILE_TOOL_NAME,
   BASH_TOOL_NAME,
   WRITE_TOOL_NAME,
   EXIT_PLAN_MODE_TOOL_NAME,
@@ -61,8 +59,6 @@ export interface ToolPermissionContext {
 /** List of tools that require permission checks in default mode */
 export const RESTRICTED_TOOLS = [
   EDIT_TOOL_NAME,
-  MULTI_EDIT_TOOL_NAME,
-  DELETE_FILE_TOOL_NAME,
   BASH_TOOL_NAME,
   WRITE_TOOL_NAME,
   EXIT_PLAN_MODE_TOOL_NAME,

package/src/types/skills.ts

@@ -3,8 +3,6 @@
  * Dependencies: Core (Logger)
  */
 
-import type { Logger } from "./core.js";
-
 export interface SkillMetadata {
   name: string;
   description: string;
@@ -60,7 +58,6 @@ export interface SkillToolArgs {
 export interface SkillManagerOptions {
   personalSkillsPath?: string;
   scanTimeout?: number;
-  logger?: Logger;
   workdir?: string;
 }
 

package/src/types/tools.ts

@@ -33,15 +33,6 @@ export interface WriteToolParameters {
   content: string;
 }
 
-/**
- * Parameters for a single edit operation in the Edit tool
- */
-export interface EditOperation {
-  old_string: string;
-  new_string: string;
-  replace_all?: boolean;
-}
-
 /**
  * Parameters for the Edit tool
  */
@@ -51,11 +42,3 @@ export interface EditToolParameters {
   new_string: string;
   replace_all?: boolean;
 }
-
-/**
- * Parameters for the MultiEdit tool
- */
-export interface MultiEditToolParameters {
-  file_path: string;
-  edits: EditOperation[];
-}

package/src/utils/container.ts

@@ -0,0 +1,92 @@
+/**
+ * A simple Dependency Injection container to manage late-binding dependencies
+ * and resolve circular references.
+ */
+export class Container {
+  private services = new Map<string, unknown>();
+  private factories = new Map<string, () => unknown>();
+  private parent?: Container;
+
+  constructor(parent?: Container) {
+    this.parent = parent;
+  }
+
+  /**
+   * Create a child container that inherits from this container
+   */
+  createChild(): Container {
+    return new Container(this);
+  }
+
+  /**
+   * Register a singleton instance
+   */
+  register<T>(token: string, instance: T): void {
+    this.services.set(token, instance);
+  }
+
+  /**
+   * Register a factory function for lazy resolution
+   */
+  provide<T>(token: string, factory: () => T): void {
+    this.factories.set(token, factory);
+  }
+
+  /**
+   * Resolve a service by token
+   */
+  get<T>(token: string): T | undefined {
+    if (this.services.has(token)) {
+      return this.services.get(token) as T;
+    }
+
+    const factory = this.factories.get(token);
+    if (factory) {
+      const instance = factory() as T;
+      this.services.set(token, instance);
+      return instance;
+    }
+
+    if (this.parent) {
+      return this.parent.get<T>(token);
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Check if a service exists
+   */
+  has(token: string): boolean {
+    return (
+      this.services.has(token) ||
+      this.factories.has(token) ||
+      (this.parent ? this.parent.has(token) : false)
+    );
+  }
+}
+
+// Example usage for ToolManager:
+/*
+const container = new Container();
+
+// 1. Provide managers lazily
+container.provide('SubagentManager', () => new SubagentManager(...));
+container.provide('SkillManager', () => new SkillManager(...));
+
+// 2. ToolManager can now resolve them only when needed (e.g., in execute)
+class ToolManager {
+  constructor(private container: Container) {}
+
+  async execute(name: string, args: any, context: any) {
+    const enhancedContext = {
+      ...context,
+      subagentManager: this.container.has('SubagentManager') 
+        ? this.container.get('SubagentManager') 
+        : undefined,
+      // ...
+    };
+    // ...
+  }
+}
+*/

package/src/utils/containerSetup.ts

@@ -0,0 +1,256 @@
+import { Container } from "./container.js";
+import { ForegroundTaskManager } from "../managers/foregroundTaskManager.js";
+import { BackgroundTaskManager } from "../managers/backgroundTaskManager.js";
+import { TaskManager } from "../services/taskManager.js";
+import { MessageManager } from "../managers/messageManager.js";
+import { AIManager } from "../managers/aiManager.js";
+import { ToolManager } from "../managers/toolManager.js";
+import { McpManager } from "../managers/mcpManager.js";
+import { LspManager } from "../managers/lspManager.js";
+import { PermissionManager } from "../managers/permissionManager.js";
+import { PlanManager } from "../managers/planManager.js";
+import { HookManager } from "../managers/hookManager.js";
+import { SkillManager } from "../managers/skillManager.js";
+import { SlashCommandManager } from "../managers/slashCommandManager.js";
+import { PluginManager } from "../managers/pluginManager.js";
+import { BashManager } from "../managers/bashManager.js";
+import { MemoryRuleManager } from "../managers/MemoryRuleManager.js";
+import { ReversionManager } from "../managers/reversionManager.js";
+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 type { AgentOptions } from "../agent.js";
+import type {
+  PermissionMode,
+  Usage,
+  Task,
+  BackgroundTask,
+  ToolPermissionContext,
+} from "../types/index.js";
+import type { GatewayConfig, ModelConfig } from "../types/config.js";
+
+import { logger } from "./globalLogger.js";
+
+export interface AgentContainerSetupOptions {
+  options: AgentOptions;
+  workdir: string;
+  configurationService: ConfigurationService;
+  systemPrompt?: string;
+  stream: boolean;
+
+  // Callbacks to Agent methods
+  onSessionIdChange: (sessionId: string) => void;
+  onTasksChange: (tasks: BackgroundTask[]) => void;
+  onSessionTasksChange: (tasks: Task[]) => void;
+  onPermissionModeChange: (mode: PermissionMode) => void;
+  handlePlanModeTransition: (mode: PermissionMode) => void;
+  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(
+  setupOptions: AgentContainerSetupOptions,
+): Container {
+  const {
+    options,
+    workdir,
+    configurationService,
+    systemPrompt,
+    stream,
+    onSessionIdChange,
+    onTasksChange,
+    onSessionTasksChange,
+    onPermissionModeChange,
+    handlePlanModeTransition,
+    setPermissionMode,
+    addPermissionRule,
+    addUsage,
+    getGatewayConfig,
+    getModelConfig,
+    getMaxInputTokens,
+    getLanguage,
+  } = setupOptions;
+
+  const callbacks = options.callbacks || {};
+  const container = new Container();
+
+  const foregroundTaskManager = new ForegroundTaskManager(container);
+  container.register("ForegroundTaskManager", foregroundTaskManager);
+  container.register("ConfigurationService", configurationService);
+
+  const memoryRuleManager = new MemoryRuleManager(container, { workdir });
+  container.register("MemoryRuleManager", memoryRuleManager);
+
+  const messageManager = new MessageManager(container, {
+    callbacks: {
+      ...callbacks,
+      onSessionIdChange: (sessionId) => {
+        onSessionIdChange(sessionId);
+        callbacks.onSessionIdChange?.(sessionId);
+      },
+    },
+    workdir,
+  });
+  container.register("MessageManager", messageManager);
+
+  const resolvedTaskListId =
+    configurationService.getEnvironmentVars().WAVE_TASK_LIST_ID ||
+    process.env.WAVE_TASK_LIST_ID ||
+    messageManager.getRootSessionId();
+
+  const taskManager = new TaskManager(container, resolvedTaskListId);
+  container.register("TaskManager", taskManager);
+  taskManager.on("tasksChange", async () => {
+    const tasks = await taskManager.listTasks();
+    onSessionTasksChange(tasks);
+  });
+
+  const backgroundTaskManager = new BackgroundTaskManager(container, {
+    callbacks: {
+      ...callbacks,
+      onTasksChange: (tasks) => {
+        onTasksChange(tasks);
+        callbacks.onTasksChange?.(tasks);
+      },
+    },
+    workdir,
+  });
+  container.register("BackgroundTaskManager", backgroundTaskManager);
+
+  const mcpManager = new McpManager(container, { callbacks });
+  container.register("McpManager", mcpManager);
+
+  const lspManager = options.lspManager || new LspManager(container);
+  container.register("LspManager", lspManager);
+
+  const permissionManager = new PermissionManager(container, { workdir });
+  container.register("PermissionManager", permissionManager);
+  permissionManager.setOnConfiguredDefaultModeChange((mode) => {
+    handlePlanModeTransition(mode);
+    onPermissionModeChange(mode);
+  });
+
+  const planManager = new PlanManager(container);
+  container.register("PlanManager", planManager);
+
+  const hookManager = new HookManager(container, workdir);
+  container.register("HookManager", hookManager);
+
+  const skillManager = new SkillManager(container, { workdir });
+  container.register("SkillManager", skillManager);
+
+  container.register(
+    "ReversionService",
+    new ReversionService(messageManager.getTranscriptPath()),
+  );
+  const reversionManager = new ReversionManager(container);
+  container.register("ReversionManager", reversionManager);
+
+  const canUseToolWithNotification = options.canUseTool
+    ? async (context: ToolPermissionContext) => {
+        try {
+          const notificationMessage = `Claude needs your permission to use ${context.toolName}`;
+          await hookManager.executeHooks("Notification", {
+            event: "Notification",
+            projectDir: workdir,
+            timestamp: new Date(),
+            sessionId: messageManager.getSessionId(),
+            transcriptPath: messageManager.getTranscriptPath(),
+            cwd: workdir,
+            message: notificationMessage,
+            notificationType: "permission_prompt",
+            env: configurationService.getEnvironmentVars(),
+          });
+        } catch (error) {
+          logger.warn("Failed to execute notification hooks", {
+            toolName: context.toolName,
+            error: error instanceof Error ? error.message : String(error),
+          });
+        }
+
+        const decision = await options.canUseTool!(context);
+
+        if (decision.newPermissionMode) {
+          setPermissionMode(decision.newPermissionMode);
+        }
+
+        if (decision.newPermissionRule) {
+          await addPermissionRule(decision.newPermissionRule);
+        }
+
+        return decision;
+      }
+    : undefined;
+
+  const toolManager = new ToolManager({
+    container,
+    tools: options.tools,
+  });
+  container.register("ToolManager", toolManager);
+
+  container.register("PermissionMode", options.permissionMode);
+  container.register("CanUseToolCallback", canUseToolWithNotification);
+
+  const liveConfigManager = new LiveConfigManager(container, { workdir });
+  container.register("LiveConfigManager", liveConfigManager);
+
+  const subagentManager = new SubagentManager(container, {
+    workdir,
+    callbacks: {
+      onSubagentUserMessageAdded: callbacks.onSubagentUserMessageAdded,
+      onSubagentAssistantMessageAdded:
+        callbacks.onSubagentAssistantMessageAdded,
+      onSubagentAssistantContentUpdated:
+        callbacks.onSubagentAssistantContentUpdated,
+      onSubagentAssistantReasoningUpdated:
+        callbacks.onSubagentAssistantReasoningUpdated,
+      onSubagentToolBlockUpdated: callbacks.onSubagentToolBlockUpdated,
+      onSubagentMessagesChange: callbacks.onSubagentMessagesChange,
+      onSubagentLatestTotalTokensChange:
+        callbacks.onSubagentLatestTotalTokensChange,
+    },
+    getGatewayConfig,
+    getModelConfig,
+    getMaxInputTokens,
+    getLanguage,
+    getEnvironmentVars: () => configurationService.getEnvironmentVars(),
+    onUsageAdded: (usage: Usage) => addUsage(usage),
+  });
+  container.register("SubagentManager", subagentManager);
+
+  const aiManager = new AIManager(container, {
+    callbacks: {
+      ...callbacks,
+      onUsageAdded: (usage: Usage) => addUsage(usage),
+    },
+    workdir,
+    systemPrompt,
+    stream,
+    getGatewayConfig,
+    getModelConfig,
+    getMaxInputTokens,
+    getLanguage,
+    getEnvironmentVars: () => configurationService.getEnvironmentVars(),
+  });
+  container.register("AIManager", aiManager);
+
+  const slashCommandManager = new SlashCommandManager(container, { workdir });
+  container.register("SlashCommandManager", slashCommandManager);
+  slashCommandManager.initialize();
+
+  const pluginManager = new PluginManager(container, { workdir });
+  container.register("PluginManager", pluginManager);
+
+  const bashManager = new BashManager(container, { workdir });
+  container.register("BashManager", bashManager);
+
+  return container;
+}

package/src/utils/editUtils.ts

@@ -1,6 +1,7 @@
 /**
  * Utility functions for file editing tools
  */
+import { formatLineNumberPrefix } from "./stringUtils.js";
 
 /**
  * Escape regular expression special characters
@@ -75,10 +76,10 @@ export function analyzeEditMismatch(
     const expectedLine = searchLines[j];
 
     if (actualLine === expectedLine) {
-      reportLines.push(`${lineNum.toString().padStart(4)} | ${actualLine}`);
+      reportLines.push(`${formatLineNumberPrefix(lineNum)}${actualLine}`);
     } else {
-      reportLines.push(`${lineNum.toString().padStart(4)} | - ${expectedLine}`);
-      reportLines.push(`${lineNum.toString().padStart(4)} | + ${actualLine}`);
+      reportLines.push(`${formatLineNumberPrefix(lineNum)}- ${expectedLine}`);
+      reportLines.push(`${formatLineNumberPrefix(lineNum)}+ ${actualLine}`);
     }
   }
 

package/src/utils/hookMatcher.ts

@@ -131,8 +131,8 @@ export class HookMatcher {
    * Get all tool names that would match this pattern from a given list
    * Useful for testing and validation
    */
-  getMatches(pattern: string, toolNames: string[]): string[] {
-    return toolNames.filter((toolName) => this.matches(pattern, toolName));
+  getMatches(pattern: string, tools: string[]): string[] {
+    return tools.filter((toolName) => this.matches(pattern, toolName));
   }
 
   /**

package/src/utils/openaiClient.ts

@@ -86,8 +86,8 @@ export class OpenAIClient {
 
     const fetchFn = (customFetch as typeof fetch) || fetch;
     let lastError: (Error & { status?: number; body?: unknown }) | undefined;
-    const maxRetries = 3;
-    const initialDelay = 1000;
+    const maxRetries = 5;
+    const initialDelay = 2000;
 
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
       if (attempt > 0) {

package/src/utils/stringUtils.ts

@@ -82,3 +82,12 @@ export const stripAnsiColors = (text: string): string => {
   const ansiEscapeRegex = new RegExp(`${escapeChar}\\[[0-9;]*[a-zA-Z]`, "g");
   return text.replace(ansiEscapeRegex, "");
 };
+
+/**
+ * Format a line number prefix in cat -n style (padStart(6) + tab)
+ * @param lineNumber The line number
+ * @returns Formatted line number prefix
+ */
+export function formatLineNumberPrefix(lineNumber: number): string {
+  return `${lineNumber.toString().padStart(6)}\t`;
+}

package/dist/tools/deleteFileTool.d.ts

@@ -1,6 +0,0 @@
-import type { ToolPlugin } from "./types.js";
-/**
- * Delete file tool plugin
- */
-export declare const deleteFileTool: ToolPlugin;
-//# sourceMappingURL=deleteFileTool.d.ts.map

package/dist/tools/deleteFileTool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deleteFileTool.d.ts","sourceRoot":"","sources":["../../src/tools/deleteFileTool.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAItE;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,UAqH5B,CAAC"}

package/dist/tools/deleteFileTool.js

@@ -1,100 +0,0 @@
-import { unlink } from "fs/promises";
-import { logger } from "../utils/globalLogger.js";
-import { resolvePath, getDisplayPath } from "../utils/path.js";
-import { DELETE_FILE_TOOL_NAME } from "../constants/tools.js";
-/**
- * Delete file tool plugin
- */
-export const deleteFileTool = {
-    name: DELETE_FILE_TOOL_NAME,
-    config: {
-        type: "function",
-        function: {
-            name: DELETE_FILE_TOOL_NAME,
-            description: `Deletes a file at the specified path. The operation will fail gracefully if:
-    - The file doesn't exist
-    - The operation is rejected for security reasons
-    - The file cannot be deleted`,
-            parameters: {
-                type: "object",
-                properties: {
-                    target_file: {
-                        type: "string",
-                        description: "The path of the file to delete, relative to the workspace root.",
-                    },
-                },
-                required: ["target_file"],
-            },
-        },
-    },
-    execute: async (args, context) => {
-        const targetFile = args.target_file;
-        if (!targetFile || typeof targetFile !== "string") {
-            return {
-                success: false,
-                content: "",
-                error: "target_file parameter is required and must be a string",
-            };
-        }
-        try {
-            const filePath = resolvePath(targetFile, context.workdir);
-            // Permission check after validation but before real operation
-            // Permission check after validation but before real operation
-            if (context.permissionManager) {
-                try {
-                    const permissionContext = context.permissionManager.createContext(DELETE_FILE_TOOL_NAME, context.permissionMode || "default", context.canUseToolCallback, { target_file: targetFile });
-                    const permissionResult = await context.permissionManager.checkPermission(permissionContext);
-                    if (permissionResult.behavior === "deny") {
-                        return {
-                            success: false,
-                            content: "",
-                            error: `${DELETE_FILE_TOOL_NAME} operation denied, reason: ${permissionResult.message || "No reason provided"}`,
-                        };
-                    }
-                }
-                catch {
-                    return {
-                        success: false,
-                        content: "",
-                        error: "Permission check failed",
-                    };
-                }
-            }
-            // Record snapshot for reversion
-            let snapshotId;
-            if (context.reversionManager && context.messageId) {
-                snapshotId = await context.reversionManager.recordSnapshot(context.messageId, filePath, "delete");
-            }
-            // Delete file
-            await unlink(filePath);
-            // Commit snapshot on success
-            if (context.reversionManager && snapshotId) {
-                await context.reversionManager.commitSnapshot(snapshotId);
-            }
-            logger.debug(`Successfully deleted file: ${filePath}`);
-            return {
-                success: true,
-                content: `Successfully deleted file: ${targetFile}`,
-                shortResult: "File deleted",
-            };
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                return {
-                    success: false,
-                    content: "",
-                    error: `File does not exist: ${targetFile}`,
-                };
-            }
-            return {
-                success: false,
-                content: "",
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    },
-    formatCompactParams: (params, context) => {
-        const targetFile = params.target_file;
-        return getDisplayPath(targetFile || "", context.workdir);
-    },
-};

package/dist/tools/multiEditTool.d.ts

@@ -1,6 +0,0 @@
-import type { ToolPlugin } from "./types.js";
-/**
- * Multi-edit tool plugin
- */
-export declare const multiEditTool: ToolPlugin;
-//# sourceMappingURL=multiEditTool.d.ts.map

package/dist/tools/multiEditTool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"multiEditTool.d.ts","sourceRoot":"","sources":["../../src/tools/multiEditTool.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AA6BtE;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,UA+Q3B,CAAC"}