wave-agent-sdk 0.6.4 → 0.7.0

package/src/managers/messageManager.ts

@@ -10,7 +10,7 @@ import {
   UserMessageParams,
   type AgentToolBlockUpdateParams,
 } from "../utils/messageOperations.js";
-import type { Logger, Message, Usage, SlashCommand } from "../types/index.js";
+import type { Message, Usage, SlashCommand } from "../types/index.js";
 import { join } from "path";
 import {
   appendMessages,
@@ -23,6 +23,8 @@ import { ChatCompletionMessageFunctionToolCall } from "openai/resources.js";
 import type { MemoryRuleManager } from "./MemoryRuleManager.js";
 import { pathEncoder } from "../utils/pathEncoder.js";
 
+import { Container } from "../utils/container.js";
+
 export interface MessageManagerCallbacks {
   onMessagesChange?: (messages: Message[]) => void;
   onSessionIdChange?: (sessionId: string) => void;
@@ -59,13 +61,13 @@ export interface MessageManagerCallbacks {
   ) => void;
 }
 
+import { logger } from "../utils/globalLogger.js";
+
 export interface MessageManagerOptions {
   callbacks: MessageManagerCallbacks;
   workdir: string;
-  logger?: Logger;
   sessionType?: "main" | "subagent";
   subagentType?: string;
-  memoryRuleManager?: MemoryRuleManager;
 }
 
 export class MessageManager {
@@ -77,16 +79,17 @@ export class MessageManager {
   private latestTotalTokens: number;
   private workdir: string;
   private encodedWorkdir: string; // Cached encoded workdir
-  private logger?: Logger; // Add optional logger property
   private callbacks: MessageManagerCallbacks;
   private transcriptPath: string; // Cached transcript path
   private savedMessageCount: number; // Track how many messages have been saved to prevent duplication
   private filesInContext: Set<string> = new Set(); // Track files mentioned in the conversation
-  private memoryRuleManager?: MemoryRuleManager;
   private sessionType: "main" | "subagent";
   private subagentType?: string;
 
-  constructor(options: MessageManagerOptions) {
+  constructor(
+    private container: Container,
+    options: MessageManagerOptions,
+  ) {
     this.sessionId = generateSessionId();
     this.rootSessionId = this.sessionId;
     this.messages = [];
@@ -94,16 +97,20 @@ export class MessageManager {
     this.workdir = options.workdir;
     this.encodedWorkdir = pathEncoder.encodeSync(this.workdir); // Cache encoded workdir
     this.callbacks = options.callbacks;
-    this.logger = options.logger;
     this.savedMessageCount = 0; // Initialize saved message count tracker
     this.sessionType = options.sessionType || "main";
     this.subagentType = options.subagentType;
-    this.memoryRuleManager = options.memoryRuleManager;
 
     // Compute and cache the transcript path
     this.transcriptPath = this.computeTranscriptPath();
   }
 
+  private get memoryRuleManager(): MemoryRuleManager | undefined {
+    return this.container.has("MemoryRuleManager")
+      ? this.container.get<MemoryRuleManager>("MemoryRuleManager")
+      : undefined;
+  }
+
   // Getter methods
   public getSessionId(): string {
     return this.sessionId;
@@ -155,7 +162,7 @@ export class MessageManager {
       const filesInContext = this.getFilesInContext();
       const activeRules = this.memoryRuleManager.getActiveRules(filesInContext);
       if (activeRules.length > 0) {
-        this.logger?.debug(
+        logger?.debug(
           `Active modular rules (${activeRules.length}): ${activeRules.map((r) => r.id).join(", ")}`,
         );
         if (combined) {
@@ -200,7 +207,7 @@ export class MessageManager {
     try {
       await createSession(this.sessionId, this.workdir, this.sessionType);
     } catch (error) {
-      this.logger?.error("Failed to create session:", error);
+      logger?.error("Failed to create session:", error);
     }
   }
 
@@ -242,7 +249,7 @@ export class MessageManager {
       // Update the saved message count
       this.savedMessageCount = this.messages.length;
     } catch (error) {
-      this.logger?.error("Failed to save session:", error);
+      logger?.error("Failed to save session:", error);
     }
   }
 
@@ -741,7 +748,7 @@ export class MessageManager {
 
       await writeFile(this.transcriptPath, content, "utf8");
     } catch (error) {
-      this.logger?.error("Failed to rewrite session file:", error);
+      logger?.error("Failed to rewrite session file:", error);
     }
   }
 

package/src/managers/permissionManager.ts

@@ -27,18 +27,17 @@ import { isPathInside } from "../utils/pathSafety.js";
 import {
   BASH_TOOL_NAME,
   EDIT_TOOL_NAME,
-  MULTI_EDIT_TOOL_NAME,
-  DELETE_FILE_TOOL_NAME,
   WRITE_TOOL_NAME,
   READ_TOOL_NAME,
   LS_TOOL_NAME,
 } from "../constants/tools.js";
+import { Container } from "../utils/container.js";
 
 const SAFE_COMMANDS = ["cd", "ls", "pwd", "true", "false"];
 
+import { logger } from "../utils/globalLogger.js";
+
 export interface PermissionManagerOptions {
-  /** Logger for debugging permission decisions */
-  logger?: Logger;
   /** Configured default permission mode from settings */
   configuredDefaultMode?: PermissionMode;
   /** Allowed rules from settings */
@@ -51,10 +50,11 @@ export interface PermissionManagerOptions {
   workdir?: string;
   /** Path to the current plan file */
   planFilePath?: string;
+  /** Optional logger */
+  logger?: Logger;
 }
 
 export class PermissionManager {
-  private logger?: Logger;
   private configuredDefaultMode?: PermissionMode;
   private allowedRules: string[] = [];
   private deniedRules: string[] = [];
@@ -63,14 +63,18 @@ export class PermissionManager {
   private workdir?: string;
   private planFilePath?: string;
   private onConfiguredDefaultModeChange?: (mode: PermissionMode) => void;
+  private _logger?: Logger;
 
-  constructor(options: PermissionManagerOptions = {}) {
-    this.logger = options.logger;
+  constructor(
+    private container: Container,
+    options: PermissionManagerOptions = {},
+  ) {
     this.configuredDefaultMode = options.configuredDefaultMode;
     this.allowedRules = options.allowedRules || [];
     this.deniedRules = options.deniedRules || [];
     this.workdir = options.workdir;
     this.planFilePath = options.planFilePath;
+    this._logger = options.logger;
     this.updateAdditionalDirectories(options.additionalDirectories || []);
   }
 
@@ -89,7 +93,7 @@ export class PermissionManager {
   updateConfiguredDefaultMode(defaultMode?: PermissionMode): void {
     const oldEffectiveMode = this.getCurrentEffectiveMode();
 
-    this.logger?.debug("Updating configured default permission mode", {
+    logger?.debug("Updating configured default permission mode", {
       previous: this.configuredDefaultMode,
       new: defaultMode,
     });
@@ -100,7 +104,7 @@ export class PermissionManager {
       oldEffectiveMode !== newEffectiveMode &&
       this.onConfiguredDefaultModeChange
     ) {
-      this.logger?.debug(
+      logger?.debug(
         "Effective permission mode changed due to configuration update",
         {
           oldMode: oldEffectiveMode,
@@ -122,7 +126,7 @@ export class PermissionManager {
    * Update the allowed rules (e.g., when configuration reloads)
    */
   updateAllowedRules(rules: string[]): void {
-    this.logger?.debug("Updating allowed permission rules", {
+    logger?.debug("Updating allowed permission rules", {
       count: rules.length,
     });
     this.allowedRules = rules;
@@ -132,7 +136,7 @@ export class PermissionManager {
    * Update the denied rules (e.g., when configuration reloads)
    */
   updateDeniedRules(rules: string[]): void {
-    this.logger?.debug("Updating denied permission rules", {
+    logger?.debug("Updating denied permission rules", {
       count: rules.length,
     });
     this.deniedRules = rules;
@@ -142,7 +146,7 @@ export class PermissionManager {
    * Add temporary rules for the current session
    */
   public addTemporaryRules(rules: string[]): void {
-    this.logger?.debug("Adding temporary permission rules", {
+    logger?.debug("Adding temporary permission rules", {
       count: rules.length,
       rules,
     });
@@ -153,7 +157,7 @@ export class PermissionManager {
    * Clear all temporary rules
    */
   public clearTemporaryRules(): void {
-    this.logger?.debug("Clearing temporary permission rules");
+    logger?.debug("Clearing temporary permission rules");
     this.temporaryRules = [];
   }
 
@@ -161,7 +165,7 @@ export class PermissionManager {
    * Update the additional directories (e.g., when configuration reloads)
    */
   updateAdditionalDirectories(directories: string[]): void {
-    this.logger?.debug("Updating additional directories", {
+    logger?.debug("Updating additional directories", {
       count: directories.length,
     });
     this.additionalDirectories = directories.map((dir) => {
@@ -176,7 +180,7 @@ export class PermissionManager {
    * Update the working directory
    */
   updateWorkdir(workdir: string): void {
-    this.logger?.debug("Updating working directory", {
+    logger?.debug("Updating working directory", {
       workdir,
     });
     this.workdir = workdir;
@@ -186,7 +190,7 @@ export class PermissionManager {
    * Set the current plan file path
    */
   public setPlanFilePath(path: string | undefined): void {
-    this.logger?.debug("Setting plan file path", { path });
+    logger?.debug("Setting plan file path", { path });
     this.planFilePath = path;
   }
 
@@ -224,7 +228,7 @@ export class PermissionManager {
       }
     }
 
-    this.logger?.debug("Path is outside Safe Zone", {
+    logger?.debug("Path is outside Safe Zone", {
       absolutePath,
       workdir: effectiveWorkdir,
       additionalDirectories: this.additionalDirectories,
@@ -248,7 +252,7 @@ export class PermissionManager {
   ): PermissionMode {
     // CLI override takes highest precedence
     if (cliPermissionMode !== undefined) {
-      this.logger?.debug("Using CLI permission mode override", {
+      logger?.debug("Using CLI permission mode override", {
         cliMode: cliPermissionMode,
         configuredDefault: this.configuredDefaultMode,
       });
@@ -257,14 +261,14 @@ export class PermissionManager {
 
     // Use configured default mode if available
     if (this.configuredDefaultMode !== undefined) {
-      this.logger?.debug("Using configured default permission mode", {
+      logger?.debug("Using configured default permission mode", {
         configuredDefault: this.configuredDefaultMode,
       });
       return this.configuredDefaultMode;
     }
 
     // Fall back to system default
-    this.logger?.debug("Using system default permission mode");
+    logger?.debug("Using system default permission mode");
     return "default";
   }
 
@@ -275,7 +279,7 @@ export class PermissionManager {
   async checkPermission(
     context: ToolPermissionContext,
   ): Promise<PermissionDecision> {
-    this.logger?.debug("Checking permission for tool", {
+    logger?.debug("Checking permission for tool", {
       toolName: context.toolName,
       permissionMode: context.permissionMode,
       hasCallback: !!context.canUseToolCallback,
@@ -284,7 +288,7 @@ export class PermissionManager {
     // 0. Check denied rules first - Deny always takes precedence
     for (const rule of this.deniedRules) {
       if (this.matchesRule(context, rule)) {
-        this.logger?.warn("Permission denied by rule", {
+        logger?.warn("Permission denied by rule", {
           toolName: context.toolName,
           rule,
         });
@@ -297,24 +301,18 @@ export class PermissionManager {
 
     // 1. If bypassPermissions mode, always allow
     if (context.permissionMode === "bypassPermissions") {
-      this.logger?.debug("Permission bypassed for tool", {
+      logger?.debug("Permission bypassed for tool", {
         toolName: context.toolName,
       });
       return { behavior: "allow" };
     }
 
-    // 1.1 If acceptEdits mode, allow Edit, MultiEdit, Delete, Write
+    // 1.1 If acceptEdits mode, allow Edit, Write
     if (context.permissionMode === "acceptEdits") {
-      const autoAcceptedTools = [
-        EDIT_TOOL_NAME,
-        MULTI_EDIT_TOOL_NAME,
-        DELETE_FILE_TOOL_NAME,
-        WRITE_TOOL_NAME,
-      ];
+      const autoAcceptedTools = [EDIT_TOOL_NAME, WRITE_TOOL_NAME];
       if (autoAcceptedTools.includes(context.toolName)) {
         // Enforce Safe Zone for file operations
-        const targetPath = (context.toolInput?.file_path ||
-          context.toolInput?.target_file) as string | undefined;
+        const targetPath = context.toolInput?.file_path as string | undefined;
         const workdir = context.toolInput?.workdir as string | undefined;
 
         if (targetPath) {
@@ -323,7 +321,7 @@ export class PermissionManager {
             workdir,
           );
           if (!isInside) {
-            this.logger?.info(
+            logger?.info(
               "File operation outside the Safe Zone in acceptEdits mode, falling back to manual confirmation",
               {
                 toolName: context.toolName,
@@ -333,7 +331,7 @@ export class PermissionManager {
             );
             // Fall through to normal permission check flow to trigger confirmation prompt
           } else {
-            this.logger?.debug(
+            logger?.debug(
               "Permission automatically accepted for tool in acceptEdits mode",
               {
                 toolName: context.toolName,
@@ -347,7 +345,7 @@ export class PermissionManager {
 
     // 1.2 Check if tool call is allowed by persistent or temporary rules
     if (this.isAllowedByRule(context)) {
-      this.logger?.debug("Permission allowed by persistent rule", {
+      logger?.debug("Permission allowed by persistent rule", {
         toolName: context.toolName,
       });
       return { behavior: "allow" };
@@ -355,29 +353,16 @@ export class PermissionManager {
 
     // 1.3 If plan mode, allow Read-only tools and Edit/Write for plan file
     if (context.permissionMode === "plan") {
-      const writeTools = [
-        EDIT_TOOL_NAME,
-        MULTI_EDIT_TOOL_NAME,
-        WRITE_TOOL_NAME,
-        DELETE_FILE_TOOL_NAME,
-      ];
-      if (context.toolName === DELETE_FILE_TOOL_NAME) {
-        return {
-          behavior: "deny",
-          message: "Delete operations are not allowed in plan mode.",
-        };
-      }
-
+      const writeTools = [EDIT_TOOL_NAME, WRITE_TOOL_NAME];
       if (writeTools.includes(context.toolName)) {
-        const targetPath = (context.toolInput?.file_path ||
-          context.toolInput?.target_file) as string | undefined;
+        const targetPath = context.toolInput?.file_path as string | undefined;
 
         if (this.planFilePath && targetPath) {
           const absoluteTargetPath = path.resolve(targetPath);
           const absolutePlanPath = path.resolve(this.planFilePath);
 
           if (absoluteTargetPath === absolutePlanPath) {
-            this.logger?.debug("Allowing write to plan file in plan mode", {
+            logger?.debug("Allowing write to plan file in plan mode", {
               toolName: context.toolName,
               targetPath,
             });
@@ -394,7 +379,7 @@ export class PermissionManager {
 
     // 2. If not a restricted tool, always allow
     if (!this.isRestrictedTool(context.toolName)) {
-      this.logger?.debug("Tool is not restricted, allowing", {
+      logger?.debug("Tool is not restricted, allowing", {
         toolName: context.toolName,
       });
       return { behavior: "allow" };
@@ -403,11 +388,11 @@ export class PermissionManager {
     // 3. If custom callback provided, call it and return result
     if (context.canUseToolCallback) {
       try {
-        this.logger?.debug("Calling custom permission callback for tool", {
+        logger?.debug("Calling custom permission callback for tool", {
           toolName: context.toolName,
         });
         const decision = await context.canUseToolCallback(context);
-        this.logger?.debug("Custom callback returned decision", {
+        logger?.debug("Custom callback returned decision", {
           toolName: context.toolName,
           decision,
         });
@@ -415,7 +400,7 @@ export class PermissionManager {
       } catch (error) {
         const errorMessage =
           error instanceof Error ? error.message : String(error);
-        this.logger?.error("Error in permission callback", {
+        logger?.error("Error in permission callback", {
           toolName: context.toolName,
           error: errorMessage,
         });
@@ -428,7 +413,7 @@ export class PermissionManager {
 
     // 4. For default mode on restricted tools without callback, integrate with CLI confirmation
     // Note: CLI confirmation integration will be implemented in Phase 2
-    this.logger?.warn(
+    logger?.warn(
       "No permission callback provided for restricted tool in default mode",
       {
         toolName: context.toolName,
@@ -447,7 +432,7 @@ export class PermissionManager {
     const isRestricted = (RESTRICTED_TOOLS as readonly string[]).includes(
       toolName,
     );
-    this.logger?.debug("Checking if tool is restricted", {
+    logger?.debug("Checking if tool is restricted", {
       toolName,
       isRestricted,
     });
@@ -483,16 +468,9 @@ export class PermissionManager {
     };
 
     // Set hidePersistentOption for out-of-bounds file operations
-    const fileTools = [
-      EDIT_TOOL_NAME,
-      MULTI_EDIT_TOOL_NAME,
-      DELETE_FILE_TOOL_NAME,
-      WRITE_TOOL_NAME,
-    ];
+    const fileTools = [EDIT_TOOL_NAME, WRITE_TOOL_NAME];
     if (fileTools.includes(toolName)) {
-      const targetPath = (toolInput?.file_path || toolInput?.target_file) as
-        | string
-        | undefined;
+      const targetPath = toolInput?.file_path as string | undefined;
       const workdir = toolInput?.workdir as string | undefined;
 
       if (targetPath) {
@@ -543,7 +521,7 @@ export class PermissionManager {
       }
     }
 
-    this.logger?.debug("Created permission context", {
+    logger?.debug("Created permission context", {
       toolName,
       permissionMode,
       hasCallback: !!callback,
@@ -593,13 +571,10 @@ export class PermissionManager {
       READ_TOOL_NAME,
       WRITE_TOOL_NAME,
       EDIT_TOOL_NAME,
-      MULTI_EDIT_TOOL_NAME,
-      DELETE_FILE_TOOL_NAME,
       LS_TOOL_NAME,
     ];
     if (pathTools.includes(toolName)) {
       const targetPath = (context.toolInput?.file_path ||
-        context.toolInput?.target_file ||
         context.toolInput?.path) as string | undefined;
 
       if (targetPath) {

package/src/managers/planManager.ts

@@ -2,15 +2,19 @@ import path from "node:path";
 import fs from "node:fs/promises";
 import os from "node:os";
 import { generateRandomName } from "../utils/nameGenerator.js";
-import type { Logger } from "../types/core.js";
+
+import { Container } from "../utils/container.js";
 
 /**
  * Manages plan files for plan mode
  */
+import { logger } from "../utils/globalLogger.js";
+
 export class PlanManager {
   private planDir: string;
+  private currentPlanFilePath: string | null = null;
 
-  constructor(private logger?: Logger) {
+  constructor(private container: Container) {
     this.planDir = path.join(os.homedir(), ".wave", "plans");
   }
 
@@ -24,15 +28,30 @@ export class PlanManager {
     try {
       await fs.mkdir(this.planDir, { recursive: true });
     } catch (error) {
-      this.logger?.error(
-        `Failed to create plan directory: ${this.planDir}`,
-        error,
-      );
+      logger?.error(`Failed to create plan directory: ${this.planDir}`, error);
       throw error;
     }
     const name = generateRandomName(seed);
     const filePath = path.join(this.planDir, `${name}.md`);
-    this.logger?.info(`Generated plan file path: ${filePath}`);
+
+    if (this.currentPlanFilePath !== filePath) {
+      try {
+        await fs.unlink(filePath);
+      } catch (error) {
+        if (
+          error instanceof Error &&
+          (error as Error & { code?: string }).code !== "ENOENT"
+        ) {
+          logger?.error(
+            `Failed to remove existing plan file: ${filePath}`,
+            error,
+          );
+        }
+      }
+      this.currentPlanFilePath = filePath;
+    }
+
+    logger?.info(`Generated plan file path: ${filePath}`);
     return { path: filePath, name };
   }
 

package/src/managers/pluginManager.ts

@@ -1,4 +1,5 @@
-import { Plugin, PluginConfig, Logger } from "../types/index.js";
+import { logger } from "../utils/globalLogger.js";
+import { Plugin, PluginConfig } from "../types/index.js";
 import { PluginLoader } from "../services/pluginLoader.js";
 import * as path from "path";
 import { SkillManager } from "./skillManager.js";
@@ -8,41 +9,48 @@ import { McpManager } from "./mcpManager.js";
 import { SlashCommandManager } from "./slashCommandManager.js";
 import { MarketplaceService } from "../services/MarketplaceService.js";
 import { ConfigurationService } from "../services/configurationService.js";
+import { Container } from "../utils/container.js";
 
 export interface PluginManagerOptions {
   workdir: string;
-  logger?: Logger;
-  skillManager?: SkillManager;
-  hookManager?: HookManager;
-  lspManager?: LspManager;
-  mcpManager?: McpManager;
-  slashCommandManager?: SlashCommandManager;
   enabledPlugins?: Record<string, boolean>;
-  configurationService?: ConfigurationService;
 }
 
 export class PluginManager {
   private plugins = new Map<string, Plugin>();
   private workdir: string;
-  private logger?: Logger;
-  private skillManager?: SkillManager;
-  private hookManager?: HookManager;
-  private lspManager?: LspManager;
-  private mcpManager?: McpManager;
-  private slashCommandManager?: SlashCommandManager;
   private enabledPlugins: Record<string, boolean>;
-  private configurationService?: ConfigurationService;
 
-  constructor(options: PluginManagerOptions) {
+  constructor(
+    private container: Container,
+    options: PluginManagerOptions,
+  ) {
     this.workdir = options.workdir;
-    this.logger = options.logger;
-    this.skillManager = options.skillManager;
-    this.hookManager = options.hookManager;
-    this.lspManager = options.lspManager;
-    this.mcpManager = options.mcpManager;
-    this.slashCommandManager = options.slashCommandManager;
     this.enabledPlugins = options.enabledPlugins || {};
-    this.configurationService = options.configurationService;
+  }
+
+  private get skillManager(): SkillManager | undefined {
+    return this.container.get<SkillManager>("SkillManager");
+  }
+
+  private get hookManager(): HookManager | undefined {
+    return this.container.get<HookManager>("HookManager");
+  }
+
+  private get lspManager(): LspManager | undefined {
+    return this.container.get<LspManager>("LspManager");
+  }
+
+  private get mcpManager(): McpManager | undefined {
+    return this.container.get<McpManager>("McpManager");
+  }
+
+  private get slashCommandManager(): SlashCommandManager | undefined {
+    return this.container.get<SlashCommandManager>("SlashCommandManager");
+  }
+
+  private get configurationService(): ConfigurationService | undefined {
+    return this.container.get<ConfigurationService>("ConfigurationService");
   }
 
   /**
@@ -70,15 +78,13 @@ export class PluginManager {
       for (const p of installedRegistry.plugins) {
         const pluginId = `${p.name}@${p.marketplace}`;
         if (this.enabledPlugins[pluginId] !== true) {
-          this.logger?.info(
-            `Plugin ${pluginId} is not enabled via configuration`,
-          );
+          logger?.info(`Plugin ${pluginId} is not enabled via configuration`);
           continue;
         }
         await this.loadSinglePlugin(p.cachePath);
       }
     } catch (error) {
-      this.logger?.error("Failed to load installed plugins:", error);
+      logger?.error("Failed to load installed plugins:", error);
     }
   }
 
@@ -91,9 +97,7 @@ export class PluginManager {
 
       if (this.plugins.has(manifest.name)) {
         // If already loaded (e.g. via explicit config), skip
-        this.logger?.warn(
-          `Plugin with name '${manifest.name}' is already loaded`,
-        );
+        logger?.warn(`Plugin with name '${manifest.name}' is already loaded`);
         return;
       }
 
@@ -138,9 +142,9 @@ export class PluginManager {
       }
 
       this.plugins.set(manifest.name, plugin);
-      this.logger?.info(`Loaded plugin: ${manifest.name} v${manifest.version}`);
+      logger?.info(`Loaded plugin: ${manifest.name} v${manifest.version}`);
     } catch (error) {
-      this.logger?.error(`Failed to load plugin from ${absolutePath}`, error);
+      logger?.error(`Failed to load plugin from ${absolutePath}`, error);
     }
   }
 
@@ -152,7 +156,7 @@ export class PluginManager {
     // Load plugins from configuration (e.g. --plugin-dir) first to give them higher priority
     for (const config of configs) {
       if (config.type !== "local") {
-        this.logger?.warn(`Unsupported plugin type: ${config.type}`);
+        logger?.warn(`Unsupported plugin type: ${config.type}`);
         continue;
       }
 

package/src/managers/reversionManager.ts

@@ -1,13 +1,15 @@
 import fs from "fs/promises";
 import { FileSnapshot } from "../types/reversion.js";
 import { ReversionService } from "../services/reversionService.js";
+import { Container } from "../utils/container.js";
 
 export class ReversionManager {
   private buffer: Map<string, FileSnapshot> = new Map();
-  private reversionService: ReversionService;
 
-  constructor(reversionService: ReversionService) {
-    this.reversionService = reversionService;
+  constructor(private container: Container) {}
+
+  private get reversionService(): ReversionService {
+    return this.container.get<ReversionService>("ReversionService")!;
   }
 
   /**