wave-agent-sdk 0.6.4 → 0.7.0

package/src/managers/skillManager.ts

@@ -9,28 +9,31 @@ import type {
   SkillDiscoveryResult,
   SkillToolArgs,
   SkillInvocationContext,
-  Logger,
 } from "../types/index.js";
 import { parseSkillFile, formatSkillError } from "../utils/skillParser.js";
 
+import { Container } from "../utils/container.js";
+import { logger } from "../utils/globalLogger.js";
+
 /**
  * Manages skill discovery and loading
  */
 export class SkillManager {
   private personalSkillsPath: string;
   private scanTimeout: number;
-  private logger?: Logger;
   private workdir: string;
 
   private skillMetadata = new Map<string, SkillMetadata>();
   private skillContent = new Map<string, Skill>();
   private initialized = false;
 
-  constructor(options: SkillManagerOptions = {}) {
+  constructor(
+    private container: Container,
+    options: SkillManagerOptions = {},
+  ) {
     this.personalSkillsPath =
       options.personalSkillsPath || join(homedir(), ".wave", "skills");
     this.scanTimeout = options.scanTimeout || 5000;
-    this.logger = options.logger;
     this.workdir = options.workdir || process.cwd();
   }
 
@@ -38,7 +41,7 @@ export class SkillManager {
    * Initialize the skill manager by discovering available skills
    */
   async initialize(): Promise<void> {
-    this.logger?.debug("Initializing SkillManager...");
+    logger?.debug("Initializing SkillManager...");
 
     try {
       // Clear existing data before discovery
@@ -57,22 +60,18 @@ export class SkillManager {
 
       // Log any discovery errors
       if (discovery.errors.length > 0) {
-        this.logger?.warn(
-          `Found ${discovery.errors.length} skill discovery errors`,
-        );
+        logger?.warn(`Found ${discovery.errors.length} skill discovery errors`);
         discovery.errors.forEach((error) => {
-          this.logger?.warn(
-            `Skill error in ${error.skillPath}: ${error.message}`,
-          );
+          logger?.warn(`Skill error in ${error.skillPath}: ${error.message}`);
         });
       }
 
       this.initialized = true;
-      this.logger?.debug(
+      logger?.debug(
         `SkillManager initialized with ${this.skillMetadata.size} skills`,
       );
     } catch (error) {
-      this.logger?.error("Failed to initialize SkillManager:", error);
+      logger?.error("Failed to initialize SkillManager:", error);
       throw error;
     }
   }
@@ -107,11 +106,11 @@ export class SkillManager {
     // Return skill content that was loaded during initialization
     const skill = this.skillContent.get(skillName);
     if (skill) {
-      this.logger?.debug(`Skill '${skillName}' retrieved from loaded content`);
+      logger?.debug(`Skill '${skillName}' retrieved from loaded content`);
       return skill;
     }
 
-    this.logger?.debug(`Skill '${skillName}' not found`);
+    logger?.debug(`Skill '${skillName}' not found`);
     return null;
   }
 
@@ -155,7 +154,7 @@ export class SkillManager {
 
     try {
       const skillDirs = await this.findSkillDirectories(skillsPath);
-      this.logger?.debug(
+      logger?.debug(
         `Found ${skillDirs.length} potential skill directories in ${skillsPath}`,
       );
 
@@ -211,7 +210,7 @@ export class SkillManager {
         }
       }
     } catch (error) {
-      this.logger?.debug(
+      logger?.debug(
         `Could not scan ${skillsPath}: ${error instanceof Error ? error.message : String(error)}`,
       );
       // Not an error - the directory might not exist yet
@@ -249,7 +248,7 @@ export class SkillManager {
   ): Promise<{ content: string; context?: SkillInvocationContext }> {
     const { skill_name } = args;
 
-    this.logger?.debug(`Invoking skill: ${skill_name}`);
+    logger?.debug(`Invoking skill: ${skill_name}`);
 
     try {
       // Load the skill
@@ -276,7 +275,7 @@ export class SkillManager {
         },
       };
     } catch (error) {
-      this.logger?.error(`Failed to execute skill '${skill_name}':`, error);
+      logger?.error(`Failed to execute skill '${skill_name}':`, error);
       return {
         content: `❌ **Error executing skill**: ${error instanceof Error ? error.message : String(error)}`,
       };
@@ -328,7 +327,7 @@ export class SkillManager {
       });
       this.skillContent.set(skill.name, skill);
     }
-    this.logger?.debug(
+    logger?.debug(
       `Registered ${skills.length} plugin skills. Total skills: ${this.skillMetadata.size}`,
     );
   }

package/src/managers/slashCommandManager.ts

@@ -2,11 +2,7 @@ import type { MessageManager } from "./messageManager.js";
 import type { AIManager } from "./aiManager.js";
 import type { BackgroundTaskManager } from "./backgroundTaskManager.js";
 import type { TaskManager } from "../services/taskManager.js";
-import type {
-  SlashCommand,
-  CustomSlashCommand,
-  Logger,
-} from "../types/index.js";
+import type { SlashCommand, CustomSlashCommand } from "../types/index.js";
 import { loadCustomSlashCommands } from "../utils/customCommands.js";
 
 import {
@@ -14,6 +10,7 @@ import {
   parseSlashCommandInput,
   hasParameterPlaceholders,
 } from "../utils/commandArgumentParser.js";
+import { Container } from "../utils/container.js";
 import {
   BashCommandResult,
   parseBashCommands,
@@ -25,37 +22,45 @@ import { INIT_PROMPT } from "../prompts/index.js";
 
 const execAsync = promisify(exec);
 
+import { logger } from "../utils/globalLogger.js";
+
 export interface SlashCommandManagerOptions {
-  messageManager: MessageManager;
-  aiManager: AIManager;
-  backgroundTaskManager: BackgroundTaskManager;
-  taskManager: TaskManager;
   workdir: string;
-  logger?: Logger;
 }
 
 export class SlashCommandManager {
   private commands = new Map<string, SlashCommand>();
   private customCommands = new Map<string, CustomSlashCommand>();
-  private messageManager: MessageManager;
-  private aiManager: AIManager;
-  private backgroundTaskManager: BackgroundTaskManager;
-  private taskManager: TaskManager;
   private workdir: string;
-  private logger?: Logger;
 
-  constructor(options: SlashCommandManagerOptions) {
-    this.messageManager = options.messageManager;
-    this.aiManager = options.aiManager;
-    this.backgroundTaskManager = options.backgroundTaskManager;
-    this.taskManager = options.taskManager;
+  constructor(
+    private container: Container,
+    options: SlashCommandManagerOptions,
+  ) {
     this.workdir = options.workdir;
-    this.logger = options.logger;
+  }
 
+  public initialize(): void {
     this.initializeBuiltinCommands();
     this.loadCustomCommands();
   }
 
+  private get messageManager(): MessageManager {
+    return this.container.get<MessageManager>("MessageManager")!;
+  }
+
+  private get aiManager(): AIManager {
+    return this.container.get<AIManager>("AIManager")!;
+  }
+
+  private get backgroundTaskManager(): BackgroundTaskManager {
+    return this.container.get<BackgroundTaskManager>("BackgroundTaskManager")!;
+  }
+
+  private get taskManager(): TaskManager {
+    return this.container.get<TaskManager>("TaskManager")!;
+  }
+
   private initializeBuiltinCommands(): void {
     // Register built-in clear command
     this.registerCommand({
@@ -148,9 +153,9 @@ export class SlashCommandManager {
         });
       }
 
-      this.logger?.debug(`Loaded ${customCommands.length} custom commands`);
+      logger?.debug(`Loaded ${customCommands.length} custom commands`);
     } catch (error) {
-      this.logger?.warn("Failed to load custom commands:", error);
+      logger?.warn("Failed to load custom commands:", error);
     }
   }
 
@@ -211,7 +216,7 @@ export class SlashCommandManager {
       });
     }
 
-    this.logger?.debug(
+    logger?.debug(
       `Registered ${commands.length} commands from plugin '${pluginName}'`,
     );
   }
@@ -387,7 +392,7 @@ export class SlashCommandManager {
         allowedRules: config?.allowedTools,
       });
     } catch (error) {
-      this.logger?.error(
+      logger?.error(
         `Failed to execute custom command '${commandName}':`,
         error,
       );

package/src/managers/subagentManager.ts

@@ -1,9 +1,7 @@
 import { randomUUID } from "crypto";
-import type { MemoryRuleManager } from "./MemoryRuleManager.js";
 import type { SubagentConfiguration } from "../utils/subagentParser.js";
 import type {
   Message,
-  Logger,
   GatewayConfig,
   ModelConfig,
   Usage,
@@ -11,7 +9,6 @@ import type {
 import { AIManager } from "./aiManager.js";
 import { MessageManager } from "./messageManager.js";
 import { ToolManager } from "./toolManager.js";
-import { HookManager } from "./hookManager.js";
 import {
   addConsolidatedAbortListener,
   createAbortPromise,
@@ -22,6 +19,8 @@ import {
   type AgentToolBlockUpdateParams,
 } from "../utils/messageOperations.js";
 
+import { Container } from "../utils/container.js";
+
 export interface SubagentManagerCallbacks {
   // Granular subagent message callbacks (015-subagent-message-callbacks)
   /** Triggered when subagent adds user message */
@@ -67,24 +66,20 @@ export interface SubagentInstance {
   messages: Message[];
   lastTools: string[]; // Track last two tool names
   subagentType: string; // Store the subagent type for hook context
+  description: string; // Store the AI-generated description
   backgroundTaskId?: string; // ID of the background task if transitioned
   onUpdate?: () => void; // Optional callback for real-time updates
 }
 
 export interface SubagentManagerOptions {
   workdir: string;
-  parentToolManager: ToolManager;
-  taskManager: import("../services/taskManager.js").TaskManager;
   callbacks?: SubagentManagerCallbacks; // Use SubagentManagerCallbacks instead of parentCallbacks
-  logger?: Logger;
   getGatewayConfig: () => GatewayConfig;
   getModelConfig: () => ModelConfig;
   getMaxInputTokens: () => number;
   getLanguage: () => string | undefined;
-  hookManager?: HookManager;
+  getEnvironmentVars?: () => Record<string, string>;
   onUsageAdded?: (usage: Usage) => void;
-  backgroundTaskManager?: BackgroundTaskManager;
-  memoryRuleManager?: MemoryRuleManager;
 }
 
 export class SubagentManager {
@@ -92,33 +87,25 @@ export class SubagentManager {
   private cachedConfigurations: SubagentConfiguration[] | null = null;
 
   private workdir: string;
-  private parentToolManager: ToolManager;
-  private taskManager: import("../services/taskManager.js").TaskManager;
   private callbacks?: SubagentManagerCallbacks; // Use SubagentManagerCallbacks instead of parentCallbacks
-  private logger?: Logger;
   private getGatewayConfig: () => GatewayConfig;
   private getModelConfig: () => ModelConfig;
   private getMaxInputTokens: () => number;
   private getLanguage: () => string | undefined;
-  private hookManager?: HookManager;
+  private getEnvironmentVars?: () => Record<string, string>;
   private onUsageAdded?: (usage: Usage) => void;
-  private backgroundTaskManager?: BackgroundTaskManager;
-  private memoryRuleManager?: MemoryRuleManager;
+  private container: Container;
 
-  constructor(options: SubagentManagerOptions) {
+  constructor(container: Container, options: SubagentManagerOptions) {
+    this.container = container;
     this.workdir = options.workdir;
-    this.parentToolManager = options.parentToolManager;
-    this.taskManager = options.taskManager;
     this.callbacks = options.callbacks; // Store SubagentManagerCallbacks
-    this.logger = options.logger;
     this.getGatewayConfig = options.getGatewayConfig;
     this.getModelConfig = options.getModelConfig;
     this.getMaxInputTokens = options.getMaxInputTokens;
     this.getLanguage = options.getLanguage;
-    this.hookManager = options.hookManager;
+    this.getEnvironmentVars = options.getEnvironmentVars;
     this.onUsageAdded = options.onUsageAdded;
-    this.backgroundTaskManager = options.backgroundTaskManager;
-    this.memoryRuleManager = options.memoryRuleManager;
   }
 
   /**
@@ -176,40 +163,38 @@ export class SubagentManager {
     runInBackground?: boolean,
     onUpdate?: () => void,
   ): Promise<SubagentInstance> {
-    if (!this.parentToolManager) {
+    const parentToolManager = this.container.get<ToolManager>("ToolManager");
+
+    if (!parentToolManager) {
       throw new Error(
-        "SubagentManager not properly initialized - call initialize() first",
+        "SubagentManager not properly initialized - ToolManager not found in container",
       );
     }
 
     const subagentId = randomUUID();
 
+    // Create a child container for the subagent to isolate its managers
+    const subagentContainer = this.container.createChild();
+
     // Create isolated MessageManager for the subagent
     const subagentCallbacks = this.createSubagentCallbacks(subagentId);
 
-    const messageManager = new MessageManager({
+    const messageManager = new MessageManager(subagentContainer, {
       callbacks: subagentCallbacks,
       workdir: this.workdir,
-      logger: this.logger,
       sessionType: "subagent",
       subagentType: parameters.subagent_type,
-      memoryRuleManager: this.memoryRuleManager,
     });
+    subagentContainer.register("MessageManager", messageManager);
 
     // Use the parent tool manager directly - tool restrictions will be handled by allowedTools parameter
-    const toolManager = this.parentToolManager;
+    const toolManager = parentToolManager;
 
     // Create isolated AIManager for the subagent
-    const aiManager = new AIManager({
-      messageManager,
-      toolManager,
-      taskManager: this.taskManager,
-      logger: this.logger,
+    const aiManager = new AIManager(subagentContainer, {
       workdir: this.workdir,
       systemPrompt: configuration.systemPrompt,
       subagentType: parameters.subagent_type, // Pass subagent type for hook context
-      hookManager: this.hookManager,
-      permissionManager: this.parentToolManager.getPermissionManager(),
       getGatewayConfig: this.getGatewayConfig,
       getModelConfig: () => {
         // Determine model dynamically each time
@@ -234,10 +219,12 @@ export class SubagentManager {
       },
       getMaxInputTokens: this.getMaxInputTokens,
       getLanguage: this.getLanguage,
+      getEnvironmentVars: this.getEnvironmentVars,
       callbacks: {
         onUsageAdded: this.onUsageAdded,
       },
     });
+    subagentContainer.register("AIManager", aiManager);
 
     const instance: SubagentInstance = {
       subagentId,
@@ -249,6 +236,7 @@ export class SubagentManager {
       messages: [],
       lastTools: [], // Initialize lastTools
       subagentType: parameters.subagent_type, // Store the subagent type
+      description: parameters.description, // Store the AI-generated description
       onUpdate,
     };
 
@@ -278,16 +266,20 @@ export class SubagentManager {
       // Set status to active and update parent
       this.updateInstanceStatus(instance.subagentId, "active");
 
-      if (runInBackground && this.backgroundTaskManager) {
-        const taskId = this.backgroundTaskManager.generateId();
+      const backgroundTaskManager = this.container.has("BackgroundTaskManager")
+        ? this.container.get<BackgroundTaskManager>("BackgroundTaskManager")
+        : undefined;
+
+      if (runInBackground && backgroundTaskManager) {
+        const taskId = backgroundTaskManager.generateId();
         const startTime = Date.now();
 
-        this.backgroundTaskManager.addTask({
+        backgroundTaskManager.addTask({
           id: taskId,
           type: "subagent",
           status: "running",
           startTime,
-          description: instance.configuration.description,
+          description: instance.description,
           stdout: "",
           stderr: "",
           subagentId: instance.subagentId,
@@ -307,7 +299,7 @@ export class SubagentManager {
               prompt,
               abortSignal,
             );
-            const task = this.backgroundTaskManager?.getTask(taskId);
+            const task = backgroundTaskManager?.getTask(taskId);
             if (task) {
               task.status = "completed";
               task.stdout = result;
@@ -315,7 +307,7 @@ export class SubagentManager {
               task.runtime = task.endTime - startTime;
             }
           } catch (error) {
-            const task = this.backgroundTaskManager?.getTask(taskId);
+            const task = backgroundTaskManager?.getTask(taskId);
             if (task) {
               task.status = "failed";
               task.stderr =
@@ -342,19 +334,23 @@ export class SubagentManager {
       throw new Error(`Subagent instance ${subagentId} not found`);
     }
 
-    if (!this.backgroundTaskManager) {
+    const backgroundTaskManager = this.container.has("BackgroundTaskManager")
+      ? this.container.get<BackgroundTaskManager>("BackgroundTaskManager")
+      : undefined;
+
+    if (!backgroundTaskManager) {
       throw new Error("BackgroundTaskManager not available");
     }
 
-    const taskId = this.backgroundTaskManager.generateId();
+    const taskId = backgroundTaskManager.generateId();
     const startTime = Date.now();
 
-    this.backgroundTaskManager.addTask({
+    backgroundTaskManager.addTask({
       id: taskId,
       type: "subagent",
       status: "running",
       startTime,
-      description: instance.configuration.description,
+      description: instance.description,
       stdout: "",
       stderr: "",
       subagentId: instance.subagentId,
@@ -461,11 +457,13 @@ export class SubagentManager {
       // Update status to completed and update parent
       this.updateInstanceStatus(instance.subagentId, "completed");
 
+      const backgroundTaskManager = this.container.has("BackgroundTaskManager")
+        ? this.container.get<BackgroundTaskManager>("BackgroundTaskManager")
+        : undefined;
+
       // If this was transitioned to background, update the background task
-      if (instance.backgroundTaskId && this.backgroundTaskManager) {
-        const task = this.backgroundTaskManager.getTask(
-          instance.backgroundTaskId,
-        );
+      if (instance.backgroundTaskId && backgroundTaskManager) {
+        const task = backgroundTaskManager.getTask(instance.backgroundTaskId);
         if (task) {
           task.status = "completed";
           task.stdout = response || "Task completed with no text response";
@@ -478,11 +476,13 @@ export class SubagentManager {
 
       return response || "Task completed with no text response";
     } catch (error) {
+      const backgroundTaskManager = this.container.has("BackgroundTaskManager")
+        ? this.container.get<BackgroundTaskManager>("BackgroundTaskManager")
+        : undefined;
+
       // If this was transitioned to background, update the background task with error
-      if (instance.backgroundTaskId && this.backgroundTaskManager) {
-        const task = this.backgroundTaskManager.getTask(
-          instance.backgroundTaskId,
-        );
+      if (instance.backgroundTaskId && backgroundTaskManager) {
+        const task = backgroundTaskManager.getTask(instance.backgroundTaskId);
         if (task) {
           task.status = "failed";
           task.stderr = error instanceof Error ? error.message : String(error);