wave-agent-sdk 0.6.4 → 0.7.0

package/src/agent.ts

@@ -20,7 +20,6 @@ import { SlashCommandManager } from "./managers/slashCommandManager.js";
 import { PluginManager } from "./managers/pluginManager.js";
 import { HookManager } from "./managers/hookManager.js";
 import { ReversionManager } from "./managers/reversionManager.js";
-import { ReversionService } from "./services/reversionService.js";
 import { PermissionManager } from "./managers/permissionManager.js";
 import { PlanManager } from "./managers/planManager.js";
 import type {
@@ -57,6 +56,9 @@ import path from "path";
 import os from "os";
 import { ClientOptions } from "openai";
 
+import { Container } from "./utils/container.js";
+import { setupAgentContainer } from "./utils/containerSetup.js";
+
 /**
  * Configuration options for Agent instances
  *
@@ -98,6 +100,13 @@ export interface AgentOptions {
   lspManager?: ILspManager;
   /**Optional local plugins to load */
   plugins?: PluginConfig[];
+  /**
+   * Optional list of tool names to enable.
+   * - undefined: Enable all built-in tools and plugins (default).
+   * - []: Disable all tools.
+   * - string[]: Enable only the tools with the specified names.
+   */
+  tools?: string[];
 }
 
 export interface AgentCallbacks
@@ -137,6 +146,7 @@ export class Agent {
   private liveConfigManager: LiveConfigManager; // Add live configuration manager
   private taskManager: TaskManager;
   private foregroundTaskManager: ForegroundTaskManager;
+  private container: Container;
   private configurationService: ConfigurationService; // Add configuration service
   private workdir: string; // Working directory
   private systemPrompt?: string; // Custom system prompt
@@ -190,13 +200,7 @@ export class Agent {
    * @param options - Configuration options for the Agent instance
    */
   private constructor(options: AgentOptions) {
-    const {
-      callbacks = {},
-      logger,
-      workdir,
-      systemPrompt,
-      stream = true,
-    } = options;
+    const { logger, workdir, systemPrompt, stream = true } = options;
 
     // Set working directory early as we need it for loading configuration
     this.workdir = workdir || process.cwd();
@@ -211,232 +215,58 @@ export class Agent {
     // Store options for dynamic configuration resolution
     this.options = options;
 
-    this.foregroundTaskManager = new ForegroundTaskManager();
-
-    // Initialize memory rule manager
-    this.memoryRuleManager = new MemoryRuleManager({
+    this.container = setupAgentContainer({
+      options,
       workdir: this.workdir,
-    });
-
-    // Initialize MessageManager
-    this.messageManager = new MessageManager({
-      callbacks: {
-        ...callbacks,
-        onSessionIdChange: (sessionId) => {
-          // When session ID changes (e.g. due to compression),
-          // we update the task manager to use the root session ID
-          // to ensure the task list remains consistent.
-          this.taskManager.setTaskListId(
-            this.messageManager.getRootSessionId(),
-          );
-          callbacks.onSessionIdChange?.(sessionId);
-        },
+      configurationService: this.configurationService,
+      systemPrompt: this.systemPrompt,
+      stream: this.stream,
+      onSessionIdChange: () => {
+        this.taskManager.setTaskListId(this.messageManager.getRootSessionId());
       },
-      workdir: this.workdir,
-      logger: this.logger,
-      memoryRuleManager: this.memoryRuleManager,
-    });
-
-    // Resolve taskListId once during construction to ensure stability
-    const resolvedTaskListId =
-      this.configurationService.getEnvironmentVars().WAVE_TASK_LIST_ID ||
-      process.env.WAVE_TASK_LIST_ID ||
-      this.messageManager.getRootSessionId();
-
-    this.taskManager = new TaskManager(resolvedTaskListId);
-    this.taskManager.on("tasksChange", async () => {
-      const tasks = await this.taskManager.listTasks();
-      this.options.callbacks?.onSessionTasksChange?.(tasks);
-    });
-
-    // Initialize BackgroundTaskManager
-    this.backgroundTaskManager = new BackgroundTaskManager({
-      callbacks: {
-        ...callbacks,
-        onTasksChange: (tasks) => {
-          callbacks.onTasksChange?.(tasks);
-        },
+      onSessionTasksChange: (tasks) => {
+        this.options.callbacks?.onSessionTasksChange?.(tasks);
       },
-      workdir: this.workdir,
-    });
-    this.mcpManager = new McpManager({ callbacks, logger: this.logger }); // Initialize MCP manager
-    this.lspManager =
-      options.lspManager || new LspManager({ logger: this.logger }); // Initialize LSP manager
-
-    // Initialize permission manager
-    this.permissionManager = new PermissionManager({
-      logger: this.logger,
-      workdir: this.workdir,
-    });
-    this.permissionManager.setOnConfiguredDefaultModeChange((mode) => {
-      this.handlePlanModeTransition(mode);
-      this.options.callbacks?.onPermissionModeChange?.(mode);
-    });
-
-    // Initialize plan manager
-    this.planManager = new PlanManager(this.logger);
-
-    // Initialize configuration service and hooks manager
-    this.hookManager = new HookManager(this.workdir, undefined, this.logger); // Initialize hooks manager
-
-    // Initialize skill manager
-    this.skillManager = new SkillManager({
-      logger: this.logger,
-      workdir: this.workdir,
-    });
-
-    // ReversionManager depends on MessageManager
-    this.reversionManager = new ReversionManager(
-      new ReversionService(this.messageManager.getTranscriptPath()),
-    );
-
-    // Create a wrapper for canUseTool that triggers notification hooks
-    const canUseToolWithNotification: PermissionCallback | undefined =
-      options.canUseTool
-        ? async (context) => {
-            try {
-              // Trigger notification hooks before calling the original callback
-              const notificationMessage = `Claude needs your permission to use ${context.toolName}`;
-              await this.hookManager.executeHooks("Notification", {
-                event: "Notification",
-                projectDir: this.workdir,
-                timestamp: new Date(),
-                sessionId: this.sessionId,
-                transcriptPath: this.messageManager.getTranscriptPath(),
-                cwd: this.workdir,
-                message: notificationMessage,
-                notificationType: "permission_prompt",
-                env: this.configurationService.getEnvironmentVars(), // Include configuration environment variables
-              });
-            } catch (error) {
-              this.logger?.warn("Failed to execute notification hooks", {
-                toolName: context.toolName,
-                error: error instanceof Error ? error.message : String(error),
-              });
-              // Continue with permission check even if hooks fail
-            }
-
-            // Call the original callback
-            const decision = await options.canUseTool!(context);
-
-            // Handle state changes from decision
-            if (decision.newPermissionMode) {
-              this.setPermissionMode(decision.newPermissionMode);
-            }
-
-            if (decision.newPermissionRule) {
-              await this.addPermissionRule(decision.newPermissionRule);
-            }
-
-            return decision;
-          }
-        : undefined;
-
-    // Initialize tool manager with permission context
-    this.toolManager = new ToolManager({
-      mcpManager: this.mcpManager,
-      lspManager: this.lspManager,
-      logger: this.logger,
-      permissionManager: this.permissionManager,
-      reversionManager: this.reversionManager,
-      permissionMode: options.permissionMode, // Let PermissionManager handle defaultMode resolution
-      canUseToolCallback: canUseToolWithNotification,
-      taskManager: this.taskManager,
-      backgroundTaskManager: this.backgroundTaskManager,
-      foregroundTaskManager: this.foregroundTaskManager,
-    }); // Initialize tool registry with permission support
-    this.liveConfigManager = new LiveConfigManager({
-      workdir: this.workdir,
-      logger: this.logger,
-      hookManager: this.hookManager,
-      permissionManager: this.permissionManager,
-      configurationService: this.configurationService,
-    }); // Initialize live configuration manager
-
-    // Initialize subagent manager with all dependencies in constructor
-    // IMPORTANT: Must be initialized AFTER MessageManager
-    this.subagentManager = new SubagentManager({
-      workdir: this.workdir,
-      parentToolManager: this.toolManager,
-      callbacks: {
-        onSubagentUserMessageAdded: callbacks.onSubagentUserMessageAdded,
-        onSubagentAssistantMessageAdded:
-          callbacks.onSubagentAssistantMessageAdded,
-        onSubagentAssistantContentUpdated:
-          callbacks.onSubagentAssistantContentUpdated,
-        onSubagentAssistantReasoningUpdated:
-          callbacks.onSubagentAssistantReasoningUpdated,
-        onSubagentToolBlockUpdated: callbacks.onSubagentToolBlockUpdated,
-        onSubagentMessagesChange: callbacks.onSubagentMessagesChange,
-        onSubagentLatestTotalTokensChange:
-          callbacks.onSubagentLatestTotalTokensChange,
-      }, // Pass subagent callbacks for forwarding
-      logger: this.logger,
-      getGatewayConfig: () => this.getGatewayConfig(),
-      getModelConfig: () => this.getModelConfig(),
-      getMaxInputTokens: () => this.getMaxInputTokens(),
-      getLanguage: () => this.getLanguage(),
-      hookManager: this.hookManager,
-      onUsageAdded: (usage) => this.addUsage(usage),
-      backgroundTaskManager: this.backgroundTaskManager,
-      taskManager: this.taskManager,
-      memoryRuleManager: this.memoryRuleManager,
-    });
-
-    // Initialize AI manager with resolved configuration
-    this.aiManager = new AIManager({
-      messageManager: this.messageManager,
-      toolManager: this.toolManager,
-      taskManager: this.taskManager,
-      logger: this.logger,
-      backgroundTaskManager: this.backgroundTaskManager,
-      hookManager: this.hookManager,
-      permissionManager: this.permissionManager,
-      callbacks: {
-        ...callbacks,
-        onUsageAdded: (usage: Usage) => {
-          this.addUsage(usage);
-        },
+      onTasksChange: (tasks) => {
+        this.options.callbacks?.onTasksChange?.(tasks);
       },
-      workdir: this.workdir,
-      systemPrompt: this.systemPrompt,
-      stream: this.stream, // Pass streaming mode flag
-      reversionManager: this.reversionManager,
+      onPermissionModeChange: (mode) => {
+        this.options.callbacks?.onPermissionModeChange?.(mode);
+      },
+      handlePlanModeTransition: (mode) => {
+        this.handlePlanModeTransition(mode);
+      },
+      setPermissionMode: (mode) => {
+        this.setPermissionMode(mode);
+      },
+      addPermissionRule: (rule) => this.addPermissionRule(rule),
+      addUsage: (usage) => this.addUsage(usage),
       getGatewayConfig: () => this.getGatewayConfig(),
       getModelConfig: () => this.getModelConfig(),
       getMaxInputTokens: () => this.getMaxInputTokens(),
       getLanguage: () => this.getLanguage(),
-      getEnvironmentVars: () => this.configurationService.getEnvironmentVars(), // Provide access to configuration environment variables
     });
 
-    // Initialize command manager
-    this.slashCommandManager = new SlashCommandManager({
-      messageManager: this.messageManager,
-      aiManager: this.aiManager,
-      backgroundTaskManager: this.backgroundTaskManager,
-      taskManager: this.taskManager,
-      workdir: this.workdir,
-      logger: this.logger,
-    });
-
-    // Initialize plugin manager
-    this.pluginManager = new PluginManager({
-      workdir: this.workdir,
-      logger: this.logger,
-      slashCommandManager: this.slashCommandManager,
-      mcpManager: this.mcpManager,
-      lspManager:
-        this.lspManager instanceof LspManager ? this.lspManager : undefined,
-      hookManager: this.hookManager,
-      skillManager: this.skillManager,
-      configurationService: this.configurationService,
-    });
-
-    // Initialize bash manager
-    this.bashManager = new BashManager({
-      messageManager: this.messageManager,
-      workdir: this.workdir,
-    });
+    // Retrieve managers from container
+    this.foregroundTaskManager = this.container.get("ForegroundTaskManager")!;
+    this.memoryRuleManager = this.container.get("MemoryRuleManager")!;
+    this.messageManager = this.container.get("MessageManager")!;
+    this.taskManager = this.container.get("TaskManager")!;
+    this.backgroundTaskManager = this.container.get("BackgroundTaskManager")!;
+    this.mcpManager = this.container.get("McpManager")!;
+    this.lspManager = this.container.get("LspManager")!;
+    this.permissionManager = this.container.get("PermissionManager")!;
+    this.planManager = this.container.get("PlanManager")!;
+    this.hookManager = this.container.get("HookManager")!;
+    this.skillManager = this.container.get("SkillManager")!;
+    this.reversionManager = this.container.get("ReversionManager")!;
+    this.toolManager = this.container.get("ToolManager")!;
+    this.liveConfigManager = this.container.get("LiveConfigManager")!;
+    this.subagentManager = this.container.get("SubagentManager")!;
+    this.aiManager = this.container.get("AIManager")!;
+    this.slashCommandManager = this.container.get("SlashCommandManager")!;
+    this.pluginManager = this.container.get("PluginManager")!;
+    this.bashManager = this.container.get("BashManager")!;
 
     // Set initial permission mode if provided
     if (options.permissionMode) {
@@ -635,11 +465,12 @@ export class Agent {
       // Initialize SubagentManager (load and cache configurations)
       await this.subagentManager.initialize();
 
-      // Initialize built-in tools with dependencies
-      this.toolManager.initializeBuiltInTools({
-        subagentManager: this.subagentManager,
-        skillManager: this.skillManager,
-      });
+      // Register managers in container for tool access
+      this.container.register("SubagentManager", this.subagentManager);
+      this.container.register("SkillManager", this.skillManager);
+
+      // Initialize built-in tools
+      this.toolManager.initializeBuiltInTools();
 
       // Initialize plugins
       await this.pluginManager.loadPlugins(this.options.plugins || []);
@@ -701,59 +532,6 @@ export class Agent {
       this.logger?.debug("Initializing live configuration reload...");
       await this.liveConfigManager.initialize();
       this.logger?.debug("Live configuration reload initialized successfully");
-
-      // Update permission manager with configuration-based defaultMode
-      const currentConfig = this.liveConfigManager.getCurrentConfiguration();
-      if (currentConfig?.permissions?.defaultMode) {
-        this.logger?.debug(
-          "Applying configured defaultMode to PermissionManager",
-          {
-            defaultMode: currentConfig.permissions.defaultMode,
-          },
-        );
-        this.permissionManager.updateConfiguredDefaultMode(
-          currentConfig.permissions.defaultMode,
-        );
-      }
-
-      // Update permission manager with configuration-based allowed rules
-      if (currentConfig?.permissions?.allow) {
-        this.logger?.debug(
-          "Applying configured allowed rules to PermissionManager",
-          {
-            count: currentConfig.permissions.allow.length,
-          },
-        );
-        this.permissionManager.updateAllowedRules(
-          currentConfig.permissions.allow,
-        );
-      }
-
-      // Update permission manager with configuration-based denied rules
-      if (currentConfig?.permissions?.deny) {
-        this.logger?.debug(
-          "Applying configured denied rules to PermissionManager",
-          {
-            count: currentConfig.permissions.deny.length,
-          },
-        );
-        this.permissionManager.updateDeniedRules(
-          currentConfig.permissions.deny,
-        );
-      }
-
-      // Update permission manager with configuration-based additionalDirectories
-      if (currentConfig?.permissions?.additionalDirectories) {
-        this.logger?.debug(
-          "Applying configured additionalDirectories to PermissionManager",
-          {
-            count: currentConfig.permissions.additionalDirectories.length,
-          },
-        );
-        this.permissionManager.updateAdditionalDirectories(
-          currentConfig.permissions.additionalDirectories,
-        );
-      }
     } catch (error) {
       this.logger?.error(
         "Failed to initialize live configuration reload:",

package/src/constants/tools.ts

@@ -2,14 +2,12 @@ export const ASK_USER_QUESTION_TOOL_NAME = "AskUserQuestion";
 export const BASH_TOOL_NAME = "Bash";
 export const TASK_OUTPUT_TOOL_NAME = "TaskOutput";
 export const TASK_STOP_TOOL_NAME = "TaskStop";
-export const DELETE_FILE_TOOL_NAME = "Delete";
 export const EDIT_TOOL_NAME = "Edit";
 export const EXIT_PLAN_MODE_TOOL_NAME = "ExitPlanMode";
 export const GLOB_TOOL_NAME = "Glob";
 export const GREP_TOOL_NAME = "Grep";
 export const LSP_TOOL_NAME = "LSP";
 export const LS_TOOL_NAME = "LS";
-export const MULTI_EDIT_TOOL_NAME = "MultiEdit";
 export const READ_TOOL_NAME = "Read";
 export const SKILL_TOOL_NAME = "Skill";
 export const TASK_TOOL_NAME = "Task";

package/src/core/plugin.ts

@@ -0,0 +1,224 @@
+import { Container } from "../utils/container.js";
+import { PluginManager } from "../managers/pluginManager.js";
+import { PluginScopeManager } from "../managers/pluginScopeManager.js";
+import { MarketplaceService } from "../services/MarketplaceService.js";
+import { ConfigurationService } from "../services/configurationService.js";
+import {
+  Scope,
+  InstalledPlugin,
+  KnownMarketplace,
+  MarketplaceManifest,
+  InstalledPluginsRegistry,
+  MarketplacePluginStatus,
+} from "../types/index.js";
+
+/**
+ * PluginCore
+ *
+ * Encapsulates plugin management logic, providing a high-level API for
+ * installing, uninstalling, enabling, and disabling plugins.
+ */
+export class PluginCore {
+  private container: Container;
+  private pluginManager: PluginManager;
+  private pluginScopeManager: PluginScopeManager;
+  private marketplaceService: MarketplaceService;
+  private configurationService: ConfigurationService;
+  private workdir: string;
+
+  constructor(workdir: string = process.cwd()) {
+    this.workdir = workdir;
+    this.container = new Container();
+    this.configurationService = new ConfigurationService();
+    this.marketplaceService = new MarketplaceService();
+
+    // Wire up ConfigurationService in the container for PluginManager to use
+    this.container.register("ConfigurationService", this.configurationService);
+
+    this.pluginManager = new PluginManager(this.container, {
+      workdir: this.workdir,
+    });
+
+    this.pluginScopeManager = new PluginScopeManager({
+      workdir: this.workdir,
+      configurationService: this.configurationService,
+      pluginManager: this.pluginManager,
+    });
+  }
+
+  /**
+   * Installs a plugin from a marketplace
+   */
+  async installPlugin(
+    pluginId: string,
+    scope?: Scope,
+  ): Promise<InstalledPlugin> {
+    const installedPlugin =
+      await this.marketplaceService.installPlugin(pluginId);
+    if (scope) {
+      await this.enablePlugin(pluginId, scope);
+    }
+    return installedPlugin;
+  }
+
+  /**
+   * Uninstalls a plugin and removes it from all configuration scopes
+   */
+  async uninstallPlugin(pluginId: string): Promise<void> {
+    await this.marketplaceService.uninstallPlugin(pluginId);
+    await this.pluginScopeManager.removePluginFromAllScopes(pluginId);
+  }
+
+  /**
+   * Enables a plugin in the specified scope. If no scope is provided, it tries to find
+   * the scope where the plugin is already configured, or defaults to "user".
+   */
+  async enablePlugin(pluginId: string, scope?: Scope): Promise<Scope> {
+    const targetScope = scope || this.findPluginScope(pluginId) || "user";
+    await this.pluginScopeManager.enablePlugin(targetScope, pluginId);
+    return targetScope;
+  }
+
+  /**
+   * Disables a plugin in the specified scope. If no scope is provided, it tries to find
+   * the scope where the plugin is already configured, or defaults to "user".
+   */
+  async disablePlugin(pluginId: string, scope?: Scope): Promise<Scope> {
+    const targetScope = scope || this.findPluginScope(pluginId) || "user";
+    await this.pluginScopeManager.disablePlugin(targetScope, pluginId);
+    return targetScope;
+  }
+
+  /**
+   * Updates an installed plugin to the latest version from its marketplace
+   */
+  async updatePlugin(pluginId: string): Promise<InstalledPlugin> {
+    return await this.marketplaceService.updatePlugin(pluginId);
+  }
+
+  /**
+   * Lists all plugins from all registered marketplaces with their installation and enabled status
+   */
+  async listPlugins(): Promise<{
+    plugins: MarketplacePluginStatus[];
+    mergedEnabled: Record<string, boolean>;
+  }> {
+    const installedPlugins =
+      await this.marketplaceService.getInstalledPlugins();
+    const marketplaces = await this.marketplaceService.listMarketplaces();
+    const mergedEnabled = this.configurationService.getMergedEnabledPlugins(
+      this.workdir,
+    );
+
+    const allMarketplacePlugins: MarketplacePluginStatus[] = [];
+
+    for (const m of marketplaces) {
+      try {
+        const manifest = await this.marketplaceService.loadMarketplaceManifest(
+          this.marketplaceService.getMarketplacePath(m),
+        );
+        manifest.plugins.forEach((p) => {
+          const pluginId = `${p.name}@${m.name}`;
+          const installed = installedPlugins.plugins.find(
+            (ip) => ip.name === p.name && ip.marketplace === m.name,
+          );
+          allMarketplacePlugins.push({
+            ...p,
+            marketplace: m.name,
+            installed: !!installed,
+            version: installed?.version,
+            cachePath: installed?.cachePath,
+            projectPath: installed?.projectPath,
+            scope:
+              this.pluginScopeManager.findPluginScope(pluginId) || undefined,
+          });
+        });
+      } catch {
+        // Skip marketplaces that fail to load
+      }
+    }
+
+    return {
+      plugins: allMarketplacePlugins,
+      mergedEnabled,
+    };
+  }
+
+  /**
+   * Adds a new marketplace
+   */
+  async addMarketplace(input: string): Promise<KnownMarketplace> {
+    return await this.marketplaceService.addMarketplace(input);
+  }
+
+  /**
+   * Removes a marketplace by name
+   */
+  async removeMarketplace(name: string): Promise<void> {
+    await this.marketplaceService.removeMarketplace(name);
+  }
+
+  /**
+   * Updates a specific marketplace or all marketplaces
+   */
+  async updateMarketplace(name?: string): Promise<void> {
+    await this.marketplaceService.updateMarketplace(name);
+  }
+
+  /**
+   * Lists all registered marketplaces
+   */
+  async listMarketplaces(): Promise<KnownMarketplace[]> {
+    return await this.marketplaceService.listMarketplaces();
+  }
+
+  /**
+   * Gets the registry of all installed plugins
+   */
+  async getInstalledPlugins(): Promise<InstalledPluginsRegistry> {
+    return await this.marketplaceService.getInstalledPlugins();
+  }
+
+  /**
+   * Gets the merged enabled state of all plugins across all scopes
+   */
+  getMergedEnabledPlugins(): Record<string, boolean> {
+    return this.configurationService.getMergedEnabledPlugins(this.workdir);
+  }
+
+  /**
+   * Loads a marketplace manifest from a local path
+   */
+  async loadMarketplaceManifest(
+    marketplacePath: string,
+  ): Promise<MarketplaceManifest> {
+    return await this.marketplaceService.loadMarketplaceManifest(
+      marketplacePath,
+    );
+  }
+
+  /**
+   * Resolves the local path for a marketplace
+   */
+  getMarketplacePath(marketplace: KnownMarketplace): string {
+    return this.marketplaceService.getMarketplacePath(marketplace);
+  }
+
+  /**
+   * Finds the scope where a plugin is currently enabled/disabled
+   */
+  findPluginScope(pluginId: string): Scope | null {
+    return this.pluginScopeManager.findPluginScope(pluginId);
+  }
+
+  /**
+   * Removes a plugin from the enabled plugins in the specified scope
+   */
+  async removeEnabledPlugin(scope: Scope, pluginId: string): Promise<void> {
+    await this.configurationService.removeEnabledPlugin(
+      this.workdir,
+      scope,
+      pluginId,
+    );
+  }
+}

package/src/index.ts

@@ -4,18 +4,13 @@ export * from "./services/memory.js";
 export * from "./services/session.js";
 export * from "./services/hook.js";
 export * from "./services/jsonlHandler.js";
-export * from "./services/configurationService.js"; // New configuration management service
-export * from "./services/MarketplaceService.js";
 
 // Export constants
 export * from "./constants/tools.js";
 
-// Export managers
-export * from "./managers/pluginManager.js";
-export * from "./managers/pluginScopeManager.js";
-
 // Export main agent
 export * from "./agent.js";
+export * from "./core/plugin.js";
 
 // Export all utilities
 export * from "./utils/bashParser.js";

package/src/managers/MemoryRuleManager.ts

@@ -5,6 +5,8 @@ import * as path from "node:path";
 import * as os from "node:os";
 import { logger } from "../utils/globalLogger.js";
 
+import { Container } from "../utils/container.js";
+
 export interface MemoryRuleRegistryState {
   /** All discovered rules, indexed by ID */
   rules: Record<string, MemoryRule>;
@@ -25,7 +27,10 @@ export class MemoryRuleManager {
   private workdir: string;
   private service: MemoryRuleService;
 
-  constructor(options: MemoryRuleManagerOptions) {
+  constructor(
+    private container: Container,
+    options: MemoryRuleManagerOptions,
+  ) {
     this.workdir = options.workdir;
     this.service = new MemoryRuleService();
   }