wave-agent-sdk 0.4.0 → 0.5.1

package/src/managers/messageManager.ts

@@ -26,6 +26,7 @@ import {
   SESSION_DIR,
 } from "../services/session.js";
 import { ChatCompletionMessageFunctionToolCall } from "openai/resources.js";
+import type { MemoryRuleManager } from "./MemoryRuleManager.js";
 import { pathEncoder } from "../utils/pathEncoder.js";
 
 export interface MessageManagerCallbacks {
@@ -57,6 +58,7 @@ export interface MessageManagerCallbacks {
   onUpdateCommandOutputMessage?: (command: string, output: string) => void;
   onCompleteCommandMessage?: (command: string, exitCode: number) => void;
   onSlashCommandsChange?: (commands: SlashCommand[]) => void;
+  onInfoBlockAdded?: (content: string) => void;
   // Rewind callbacks
   onShowRewind?: () => void;
   // Subagent callbacks
@@ -80,6 +82,7 @@ export interface MessageManagerOptions {
   logger?: Logger;
   sessionType?: "main" | "subagent";
   subagentType?: string;
+  memoryRuleManager?: MemoryRuleManager;
 }
 
 export class MessageManager {
@@ -95,6 +98,7 @@ export class MessageManager {
   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;
 
@@ -110,6 +114,7 @@ export class MessageManager {
     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();
@@ -151,6 +156,30 @@ export class MessageManager {
     return this.transcriptPath;
   }
 
+  /**
+   * Get combined memory content (project memory + user memory + modular rules)
+   */
+  public async getCombinedMemory(): Promise<string> {
+    const memory = await import("../services/memory.js");
+    let combined = await memory.getCombinedMemoryContent(this.workdir);
+
+    if (this.memoryRuleManager) {
+      const filesInContext = this.getFilesInContext();
+      const activeRules = this.memoryRuleManager.getActiveRules(filesInContext);
+      if (activeRules.length > 0) {
+        this.logger?.debug(
+          `Active modular rules (${activeRules.length}): ${activeRules.map((r) => r.id).join(", ")}`,
+        );
+        if (combined) {
+          combined += "\n\n";
+        }
+        combined += activeRules.map((r) => r.content).join("\n\n");
+      }
+    }
+
+    return combined;
+  }
+
   /**
    * Compute the transcript path using cached encoded workdir
    * Called during construction and when sessionId changes
@@ -400,6 +429,18 @@ export class MessageManager {
     this.callbacks.onErrorBlockAdded?.(error);
   }
 
+  public addInfoBlock(content: string): void {
+    const lastMessage = this.messages[this.messages.length - 1];
+    if (lastMessage && lastMessage.role === "assistant") {
+      lastMessage.blocks.push({
+        type: "info",
+        content,
+      } as unknown as import("../types/index.js").MessageBlock);
+      this.setMessages([...this.messages]);
+      this.callbacks.onInfoBlockAdded?.(content);
+    }
+  }
+
   /**
    * Compress messages and update session, delete compressed messages, only keep compressed messages and subsequent messages
    */
@@ -494,12 +535,13 @@ export class MessageManager {
     subagentName: string,
     sessionId: string,
     configuration: SubagentConfiguration,
-    status: "active" | "completed" | "error" = "active",
+    status: "active" | "completed" | "error" | "aborted" = "active",
     parameters: {
       description: string;
       prompt: string;
       subagent_type: string;
     },
+    runInBackground?: boolean,
   ): void {
     const params: AddSubagentBlockParams = {
       messages: this.messages,
@@ -508,6 +550,7 @@ export class MessageManager {
       sessionId,
       status,
       configuration,
+      runInBackground,
     };
     const updatedMessages = addSubagentBlockToMessage(params);
     this.setMessages(updatedMessages);
@@ -519,6 +562,7 @@ export class MessageManager {
     updates: Partial<{
       status: "active" | "completed" | "error" | "aborted";
       sessionId: string;
+      runInBackground: boolean;
     }>,
   ): void {
     const updatedMessages = updateSubagentBlockInMessage(
@@ -532,7 +576,9 @@ export class MessageManager {
       subagentId,
       status: updates.status || "active",
     };
-    this.callbacks.onSubAgentBlockUpdated?.(params.subagentId, params.status);
+    if (updates.status) {
+      this.callbacks.onSubAgentBlockUpdated?.(params.subagentId, params.status);
+    }
   }
 
   /**

package/src/managers/permissionManager.ts

@@ -237,13 +237,7 @@ export class PermissionManager {
    * Get the current effective permission mode for tool execution context
    */
   getCurrentEffectiveMode(cliPermissionMode?: PermissionMode): PermissionMode {
-    const mode = this.resolveEffectivePermissionMode(cliPermissionMode);
-    this.logger?.debug("getCurrentEffectiveMode", {
-      cliPermissionMode,
-      configuredDefaultMode: this.configuredDefaultMode,
-      resolvedMode: mode,
-    });
-    return mode;
+    return this.resolveEffectivePermissionMode(cliPermissionMode);
   }
 
   /**

package/src/managers/pluginManager.ts

@@ -149,9 +149,7 @@ export class PluginManager {
    * @param configs Array of plugin configurations
    */
   async loadPlugins(configs: PluginConfig[]): Promise<void> {
-    // Load installed plugins from marketplace first
-    await this.loadInstalledPlugins();
-
+    // 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}`);
@@ -164,6 +162,9 @@ export class PluginManager {
 
       await this.loadSinglePlugin(absolutePath);
     }
+
+    // Load installed plugins from marketplace
+    await this.loadInstalledPlugins();
   }
 
   /**

package/src/managers/slashCommandManager.ts

@@ -1,5 +1,6 @@
 import type { MessageManager } from "./messageManager.js";
 import type { AIManager } from "./aiManager.js";
+import type { BackgroundTaskManager } from "./backgroundTaskManager.js";
 import type {
   SlashCommand,
   CustomSlashCommand,
@@ -26,6 +27,7 @@ const execAsync = promisify(exec);
 export interface SlashCommandManagerOptions {
   messageManager: MessageManager;
   aiManager: AIManager;
+  backgroundTaskManager: BackgroundTaskManager;
   workdir: string;
   logger?: Logger;
 }
@@ -35,12 +37,14 @@ export class SlashCommandManager {
   private customCommands = new Map<string, CustomSlashCommand>();
   private messageManager: MessageManager;
   private aiManager: AIManager;
+  private backgroundTaskManager: BackgroundTaskManager;
   private workdir: string;
   private logger?: Logger;
 
   constructor(options: SlashCommandManagerOptions) {
     this.messageManager = options.messageManager;
     this.aiManager = options.aiManager;
+    this.backgroundTaskManager = options.backgroundTaskManager;
     this.workdir = options.workdir;
     this.logger = options.logger;
 

package/src/managers/subagentManager.ts

@@ -1,4 +1,5 @@
 import { randomUUID } from "crypto";
+import type { MemoryRuleManager } from "./MemoryRuleManager.js";
 import type { SubagentConfiguration } from "../utils/subagentParser.js";
 import type {
   Message,
@@ -20,6 +21,7 @@ import {
   addConsolidatedAbortListener,
   createAbortPromise,
 } from "../utils/abortUtils.js";
+import { BackgroundTaskManager } from "./backgroundTaskManager.js";
 
 export interface SubagentManagerCallbacks {
   // Granular subagent message callbacks (015-subagent-message-callbacks)
@@ -60,6 +62,7 @@ export interface SubagentInstance {
   status: "initializing" | "active" | "completed" | "error" | "aborted";
   messages: Message[];
   subagentType: string; // Store the subagent type for hook context
+  backgroundTaskId?: string; // ID of the background task if transitioned
 }
 
 export interface SubagentManagerOptions {
@@ -74,6 +77,8 @@ export interface SubagentManagerOptions {
   getLanguage: () => string | undefined;
   hookManager?: HookManager;
   onUsageAdded?: (usage: Usage) => void;
+  backgroundTaskManager?: BackgroundTaskManager;
+  memoryRuleManager?: MemoryRuleManager;
 }
 
 export class SubagentManager {
@@ -91,6 +96,8 @@ export class SubagentManager {
   private getLanguage: () => string | undefined;
   private hookManager?: HookManager;
   private onUsageAdded?: (usage: Usage) => void;
+  private backgroundTaskManager?: BackgroundTaskManager;
+  private memoryRuleManager?: MemoryRuleManager;
 
   constructor(options: SubagentManagerOptions) {
     this.workdir = options.workdir;
@@ -104,6 +111,8 @@ export class SubagentManager {
     this.getLanguage = options.getLanguage;
     this.hookManager = options.hookManager;
     this.onUsageAdded = options.onUsageAdded;
+    this.backgroundTaskManager = options.backgroundTaskManager;
+    this.memoryRuleManager = options.memoryRuleManager;
   }
 
   /**
@@ -158,6 +167,7 @@ export class SubagentManager {
       prompt: string;
       subagent_type: string;
     },
+    runInBackground?: boolean,
   ): Promise<SubagentInstance> {
     if (!this.parentToolManager) {
       throw new Error(
@@ -176,6 +186,7 @@ export class SubagentManager {
       logger: this.logger,
       sessionType: "subagent",
       subagentType: parameters.subagent_type,
+      memoryRuleManager: this.memoryRuleManager,
     });
 
     // Use the parent tool manager directly - tool restrictions will be handled by allowedTools parameter
@@ -241,6 +252,7 @@ export class SubagentManager {
       configuration,
       "active",
       parameters,
+      runInBackground,
     );
 
     return instance;
@@ -256,6 +268,7 @@ export class SubagentManager {
     instance: SubagentInstance,
     prompt: string,
     abortSignal?: AbortSignal,
+    runInBackground?: boolean,
   ): Promise<string> {
     try {
       // Check if already aborted before starting
@@ -269,24 +282,119 @@ export class SubagentManager {
         status: "active",
       });
 
-      // Set up consolidated abort handler to prevent listener accumulation
-      let abortCleanup: (() => void) | undefined;
-      if (abortSignal) {
-        abortCleanup = addConsolidatedAbortListener(abortSignal, [
-          () => {
-            // Update status to aborted
-            this.updateInstanceStatus(instance.subagentId, "aborted");
-            this.parentMessageManager.updateSubagentBlock(instance.subagentId, {
-              status: "aborted",
-            });
-          },
-          () => {
-            // Abort the AI execution
-            instance.aiManager.abortAIMessage();
-          },
-        ]);
+      if (runInBackground && this.backgroundTaskManager) {
+        const taskId = this.backgroundTaskManager.generateId();
+        const startTime = Date.now();
+
+        this.backgroundTaskManager.addTask({
+          id: taskId,
+          type: "subagent",
+          status: "running",
+          startTime,
+          description: instance.configuration.description,
+          stdout: "",
+          stderr: "",
+        });
+
+        instance.backgroundTaskId = taskId;
+
+        // Execute in background
+        (async () => {
+          try {
+            const result = await this.internalExecute(
+              instance,
+              prompt,
+              abortSignal,
+            );
+            const task = this.backgroundTaskManager?.getTask(taskId);
+            if (task) {
+              task.status = "completed";
+              task.stdout = result;
+              task.endTime = Date.now();
+              task.runtime = task.endTime - startTime;
+            }
+          } catch (error) {
+            const task = this.backgroundTaskManager?.getTask(taskId);
+            if (task) {
+              task.status = "failed";
+              task.stderr =
+                error instanceof Error ? error.message : String(error);
+              task.endTime = Date.now();
+              task.runtime = task.endTime - startTime;
+            }
+          }
+        })();
+
+        return taskId;
       }
 
+      return await this.internalExecute(instance, prompt, abortSignal);
+    } catch (error) {
+      this.updateInstanceStatus(instance.subagentId, "error");
+      this.parentMessageManager.updateSubagentBlock(instance.subagentId, {
+        status: "error",
+      });
+      throw error;
+    }
+  }
+
+  async backgroundInstance(subagentId: string): Promise<string> {
+    const instance = this.instances.get(subagentId);
+    if (!instance) {
+      throw new Error(`Subagent instance ${subagentId} not found`);
+    }
+
+    if (!this.backgroundTaskManager) {
+      throw new Error("BackgroundTaskManager not available");
+    }
+
+    const taskId = this.backgroundTaskManager.generateId();
+    const startTime = Date.now();
+
+    this.backgroundTaskManager.addTask({
+      id: taskId,
+      type: "subagent",
+      status: "running",
+      startTime,
+      description: instance.configuration.description,
+      stdout: "",
+      stderr: "",
+    });
+
+    instance.backgroundTaskId = taskId;
+
+    // Update parent message manager to reflect background status
+    this.parentMessageManager.updateSubagentBlock(subagentId, {
+      runInBackground: true,
+    });
+
+    return taskId;
+  }
+
+  private async internalExecute(
+    instance: SubagentInstance,
+    prompt: string,
+    abortSignal?: AbortSignal,
+  ): Promise<string> {
+    // Set up consolidated abort handler to prevent listener accumulation
+    let abortCleanup: (() => void) | undefined;
+    if (abortSignal) {
+      abortCleanup = addConsolidatedAbortListener(abortSignal, [
+        () => {
+          // Update status to aborted
+          this.updateInstanceStatus(instance.subagentId, "aborted");
+          this.parentMessageManager.updateSubagentBlock(instance.subagentId, {
+            status: "aborted",
+          });
+        },
+        () => {
+          // Abort the AI execution
+          instance.aiManager.abortAIMessage();
+        },
+      ]);
+    }
+
+    try {
       // Add the user's prompt as a message
       instance.messageManager.addUserMessage({ content: prompt });
 
@@ -326,21 +434,14 @@ export class SubagentManager {
         model: resolvedModel,
       });
 
-      try {
-        // If we have an abort signal, race against it using utilities to prevent listener accumulation
-        if (abortSignal) {
-          await Promise.race([
-            executeAI,
-            createAbortPromise(abortSignal, "Task was aborted"),
-          ]);
-        } else {
-          await executeAI;
-        }
-      } finally {
-        // Clean up abort listeners to prevent memory leaks
-        if (abortCleanup) {
-          abortCleanup();
-        }
+      // If we have an abort signal, race against it using utilities to prevent listener accumulation
+      if (abortSignal) {
+        await Promise.race([
+          executeAI,
+          createAbortPromise(abortSignal, "Task was aborted"),
+        ]);
+      } else {
+        await executeAI;
       }
 
       // Get the latest messages to extract the response
@@ -365,13 +466,43 @@ export class SubagentManager {
         status: "completed",
       });
 
+      // If this was transitioned to background, update the background task
+      if (instance.backgroundTaskId && this.backgroundTaskManager) {
+        const task = this.backgroundTaskManager.getTask(
+          instance.backgroundTaskId,
+        );
+        if (task) {
+          task.status = "completed";
+          task.stdout = response || "Task completed with no text response";
+          task.endTime = Date.now();
+          if (task.startTime) {
+            task.runtime = task.endTime - task.startTime;
+          }
+        }
+      }
+
       return response || "Task completed with no text response";
     } catch (error) {
-      this.updateInstanceStatus(instance.subagentId, "error");
-      this.parentMessageManager.updateSubagentBlock(instance.subagentId, {
-        status: "error",
-      });
+      // 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 (task) {
+          task.status = "failed";
+          task.stderr = error instanceof Error ? error.message : String(error);
+          task.endTime = Date.now();
+          if (task.startTime) {
+            task.runtime = task.endTime - task.startTime;
+          }
+        }
+      }
       throw error;
+    } finally {
+      // Clean up abort listeners to prevent memory leaks
+      if (abortCleanup) {
+        abortCleanup();
+      }
     }
   }
 
@@ -462,6 +593,7 @@ export class SubagentManager {
           logger: this.logger,
           sessionType: "subagent",
           subagentType: configuration.name, // Use configuration name for restored sessions
+          memoryRuleManager: this.memoryRuleManager,
         });
 
         // Use the parent tool manager

package/src/managers/toolManager.ts

@@ -1,5 +1,7 @@
 import type { ToolContext, ToolPlugin, ToolResult } from "../tools/types.js";
-import { bashTool, bashOutputTool, killBashTool } from "../tools/bashTool.js";
+import { bashTool } from "../tools/bashTool.js";
+import { taskOutputTool } from "../tools/taskOutputTool.js";
+import { taskStopTool } from "../tools/taskStopTool.js";
 import { deleteFileTool } from "../tools/deleteFileTool.js";
 import { editTool } from "../tools/editTool.js";
 import { multiEditTool } from "../tools/multiEditTool.js";
@@ -33,10 +35,14 @@ export interface ToolManagerOptions {
   mcpManager: McpManager;
   lspManager?: ILspManager;
   logger?: Logger;
-  /** Optional permission manager for handling tool permission checks */
+  /** Permission manager for handling tool permission checks */
   permissionManager?: PermissionManager;
+  /** Foreground task manager for backgrounding tasks */
+  foregroundTaskManager?: import("../types/processes.js").IForegroundTaskManager;
   /** Reversion manager for file snapshots */
   reversionManager?: ReversionManager;
+  /** Background task manager for background execution */
+  backgroundTaskManager?: import("./backgroundTaskManager.js").BackgroundTaskManager;
   /** Permission mode for tool execution (defaults to "default") */
   permissionMode?: PermissionMode;
   /** Custom permission callback for tool usage */
@@ -55,7 +61,9 @@ class ToolManager {
   private lspManager?: ILspManager;
   private logger?: Logger;
   private permissionManager?: PermissionManager;
+  private foregroundTaskManager?: import("../types/processes.js").IForegroundTaskManager;
   private reversionManager?: ReversionManager;
+  private backgroundTaskManager?: import("./backgroundTaskManager.js").BackgroundTaskManager;
   private permissionMode?: PermissionMode;
   private canUseToolCallback?: PermissionCallback;
 
@@ -64,7 +72,9 @@ class ToolManager {
     this.lspManager = options.lspManager;
     this.logger = options.logger;
     this.permissionManager = options.permissionManager;
+    this.foregroundTaskManager = options.foregroundTaskManager;
     this.reversionManager = options.reversionManager;
+    this.backgroundTaskManager = options.backgroundTaskManager;
     // Store CLI permission mode, let PermissionManager resolve effective mode
     this.permissionMode = options.permissionMode;
     this.canUseToolCallback = options.canUseToolCallback;
@@ -106,8 +116,8 @@ class ToolManager {
   }): void {
     const builtInTools = [
       bashTool,
-      bashOutputTool,
-      killBashTool,
+      taskOutputTool,
+      taskStopTool,
       deleteFileTool,
       editTool,
       multiEditTool,
@@ -168,6 +178,8 @@ class ToolManager {
       canUseToolCallback: this.canUseToolCallback,
       permissionManager: this.permissionManager,
       reversionManager: this.reversionManager,
+      backgroundTaskManager: this.backgroundTaskManager,
+      foregroundTaskManager: this.foregroundTaskManager,
       mcpManager: this.mcpManager,
       lspManager: this.lspManager,
     };

package/src/services/GitService.ts

@@ -43,7 +43,9 @@ export class GitService {
 
     try {
       const refArgs = ref ? `-b "${ref}"` : "--depth 1";
-      await execAsync(`LC_ALL=C git clone ${refArgs} "${url}" "${targetPath}"`);
+      await execAsync(`git clone ${refArgs} "${url}" "${targetPath}"`, {
+        env: { ...process.env, LC_ALL: "C" },
+      });
     } catch (error) {
       throw this.handleGitError(urlOrRepo, error);
     }
@@ -59,7 +61,9 @@ export class GitService {
       );
     }
     try {
-      await execAsync(`LC_ALL=C git -C "${targetPath}" pull`);
+      await execAsync(`git -C "${targetPath}" pull`, {
+        env: { ...process.env, LC_ALL: "C" },
+      });
     } catch (error) {
       throw this.handleGitError(targetPath, error);
     }

package/src/services/MarketplaceService.ts

@@ -346,7 +346,10 @@ export class MarketplaceService {
   /**
    * Installs a plugin from a marketplace
    */
-  async installPlugin(pluginAtMarketplace: string): Promise<InstalledPlugin> {
+  async installPlugin(
+    pluginAtMarketplace: string,
+    projectPath?: string,
+  ): Promise<InstalledPlugin> {
     const [pluginName, marketplaceName] = pluginAtMarketplace.split("@");
     if (!pluginName || !marketplaceName) {
       throw new Error("Invalid plugin format. Use name@marketplace");
@@ -432,7 +435,10 @@ export class MarketplaceService {
 
       const installedRegistry = await this.getInstalledPlugins();
       const existingIndex = installedRegistry.plugins.findIndex(
-        (p) => p.name === pluginName && p.marketplace === marketplaceName,
+        (p) =>
+          p.name === pluginName &&
+          p.marketplace === marketplaceName &&
+          p.projectPath === projectPath,
       );
 
       const installedPlugin: InstalledPlugin = {
@@ -440,6 +446,7 @@ export class MarketplaceService {
         marketplace: marketplaceName,
         version,
         cachePath,
+        projectPath,
       };
 
       if (existingIndex >= 0) {
@@ -467,7 +474,10 @@ export class MarketplaceService {
   /**
    * Uninstalls a plugin
    */
-  async uninstallPlugin(pluginAtMarketplace: string): Promise<void> {
+  async uninstallPlugin(
+    pluginAtMarketplace: string,
+    projectPath?: string,
+  ): Promise<void> {
     const [pluginName, marketplaceName] = pluginAtMarketplace.split("@");
     if (!pluginName || !marketplaceName) {
       throw new Error("Invalid plugin format. Use name@marketplace");
@@ -475,25 +485,33 @@ export class MarketplaceService {
 
     const installedRegistry = await this.getInstalledPlugins();
     const pluginIndex = installedRegistry.plugins.findIndex(
-      (p) => p.name === pluginName && p.marketplace === marketplaceName,
+      (p) =>
+        p.name === pluginName &&
+        p.marketplace === marketplaceName &&
+        p.projectPath === projectPath,
     );
 
     if (pluginIndex === -1) {
       throw new Error(
-        `Plugin ${pluginName}@${marketplaceName} is not installed`,
+        `Plugin ${pluginName}@${marketplaceName} is not installed${projectPath ? ` for project ${projectPath}` : ""}`,
       );
     }
 
-    const plugin = installedRegistry.plugins[pluginIndex];
-
-    // Remove cached files
-    if (existsSync(plugin.cachePath)) {
-      await fs.rm(plugin.cachePath, { recursive: true, force: true });
-    }
+    const pluginToRemove = installedRegistry.plugins[pluginIndex];
 
-    // Remove from registry
+    // Remove from registry first
     installedRegistry.plugins.splice(pluginIndex, 1);
     await this.saveInstalledPlugins(installedRegistry);
+
+    // Check if any other project is still using this same cache path
+    const isStillReferenced = installedRegistry.plugins.some(
+      (p) => p.cachePath === pluginToRemove.cachePath,
+    );
+
+    // Only remove cached files if no other references exist
+    if (!isStillReferenced && existsSync(pluginToRemove.cachePath)) {
+      await fs.rm(pluginToRemove.cachePath, { recursive: true, force: true });
+    }
   }
 
   /**