wave-agent-sdk 0.4.0 → 0.5.1

package/src/agent.ts

@@ -1,3 +1,4 @@
+import { ForegroundTaskManager } from "./managers/foregroundTaskManager.js";
 import {
   MessageManager,
   type MessageManagerCallbacks,
@@ -13,9 +14,9 @@ import { McpManager, type McpManagerCallbacks } from "./managers/mcpManager.js";
 import { LspManager } from "./managers/lspManager.js";
 import { BashManager } from "./managers/bashManager.js";
 import {
-  BackgroundBashManager,
-  type BackgroundBashManagerCallbacks,
-} from "./managers/backgroundBashManager.js";
+  BackgroundTaskManager,
+  type BackgroundTaskManagerCallbacks,
+} from "./managers/backgroundTaskManager.js";
 import { SlashCommandManager } from "./managers/slashCommandManager.js";
 import { PluginManager } from "./managers/pluginManager.js";
 import { HookManager } from "./managers/hookManager.js";
@@ -38,6 +39,8 @@ import type {
   Usage,
   PermissionMode,
   PermissionCallback,
+  BackgroundTask,
+  ForegroundTask,
 } from "./types/index.js";
 import { MemoryRuleManager } from "./managers/MemoryRuleManager.js";
 import { LiveConfigManager } from "./managers/liveConfigManager.js";
@@ -100,10 +103,12 @@ export interface AgentOptions {
 
 export interface AgentCallbacks
   extends MessageManagerCallbacks,
-    BackgroundBashManagerCallbacks,
+    BackgroundTaskManagerCallbacks,
     McpManagerCallbacks,
     SubagentManagerCallbacks {
+  onTasksChange?: (tasks: BackgroundTask[]) => void;
   onPermissionModeChange?: (mode: PermissionMode) => void;
+  onBackgroundCurrentTask?: () => void;
 }
 
 export class Agent {
@@ -111,7 +116,7 @@ export class Agent {
   private aiManager: AIManager;
 
   private bashManager: BashManager | null = null;
-  private backgroundBashManager: BackgroundBashManager;
+  private backgroundTaskManager: BackgroundTaskManager;
   private logger?: Logger; // Add optional logger property
   private toolManager: ToolManager; // Add tool registry instance
   private mcpManager: McpManager; // Add MCP manager instance
@@ -126,6 +131,7 @@ export class Agent {
   private reversionManager: ReversionManager;
   private memoryRuleManager: MemoryRuleManager; // Add memory rule manager instance
   private liveConfigManager: LiveConfigManager; // Add live configuration manager
+  private foregroundTaskManager: ForegroundTaskManager;
   private configurationService: ConfigurationService; // Add configuration service
   private workdir: string; // Working directory
   private systemPrompt?: string; // Custom system prompt
@@ -200,8 +206,15 @@ export class Agent {
     // Store options for dynamic configuration resolution
     this.options = options;
 
-    this.backgroundBashManager = new BackgroundBashManager({
-      callbacks,
+    this.foregroundTaskManager = new ForegroundTaskManager();
+
+    this.backgroundTaskManager = new BackgroundTaskManager({
+      callbacks: {
+        ...callbacks,
+        onTasksChange: (tasks) => {
+          callbacks.onTasksChange?.(tasks);
+        },
+      },
       workdir: this.workdir,
     });
     this.mcpManager = new McpManager({ callbacks, logger: this.logger }); // Initialize MCP manager
@@ -230,11 +243,17 @@ export class Agent {
       workdir: this.workdir,
     });
 
+    // Initialize memory rule manager
+    this.memoryRuleManager = new MemoryRuleManager({
+      workdir: this.workdir,
+    });
+
     // Initialize MessageManager
     this.messageManager = new MessageManager({
       callbacks,
       workdir: this.workdir,
       logger: this.logger,
+      memoryRuleManager: this.memoryRuleManager,
     });
 
     // Initialize ReversionManager
@@ -242,11 +261,6 @@ export class Agent {
       new ReversionService(this.messageManager.getTranscriptPath()),
     );
 
-    // Initialize memory rule manager
-    this.memoryRuleManager = new MemoryRuleManager({
-      workdir: this.workdir,
-    });
-
     // Create a wrapper for canUseTool that triggers notification hooks
     const canUseToolWithNotification: PermissionCallback | undefined =
       options.canUseTool
@@ -298,6 +312,8 @@ export class Agent {
       reversionManager: this.reversionManager,
       permissionMode: options.permissionMode, // Let PermissionManager handle defaultMode resolution
       canUseToolCallback: canUseToolWithNotification,
+      backgroundTaskManager: this.backgroundTaskManager,
+      foregroundTaskManager: this.foregroundTaskManager,
     }); // Initialize tool registry with permission support
     this.liveConfigManager = new LiveConfigManager({
       workdir: this.workdir,
@@ -331,6 +347,8 @@ export class Agent {
       getLanguage: () => this.getLanguage(),
       hookManager: this.hookManager,
       onUsageAdded: (usage) => this.addUsage(usage),
+      backgroundTaskManager: this.backgroundTaskManager,
+      memoryRuleManager: this.memoryRuleManager,
     });
 
     // Initialize AI manager with resolved configuration
@@ -338,7 +356,7 @@ export class Agent {
       messageManager: this.messageManager,
       toolManager: this.toolManager,
       logger: this.logger,
-      backgroundBashManager: this.backgroundBashManager,
+      backgroundTaskManager: this.backgroundTaskManager,
       hookManager: this.hookManager,
       permissionManager: this.permissionManager,
       callbacks: {
@@ -362,6 +380,7 @@ export class Agent {
     this.slashCommandManager = new SlashCommandManager({
       messageManager: this.messageManager,
       aiManager: this.aiManager,
+      backgroundTaskManager: this.backgroundTaskManager,
       workdir: this.workdir,
       logger: this.logger,
     });
@@ -456,34 +475,8 @@ export class Agent {
   }
 
   /** Get combined memory content (project + user + modular rules) */
-  public get combinedMemory(): string {
-    let combined = "";
-    if (this._projectMemoryContent.trim()) {
-      combined += this._projectMemoryContent;
-    }
-    if (this._userMemoryContent.trim()) {
-      if (combined) {
-        combined += "\n\n";
-      }
-      combined += this._userMemoryContent;
-    }
-
-    // Add modular memory rules
-    const filesInContext = this.messageManager.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");
-    } else {
-      this.logger?.debug("No active modular rules for current context");
-    }
-
-    return combined;
+  public async getCombinedMemory(): Promise<string> {
+    return this.messageManager.getCombinedMemory();
   }
 
   /** Get AI loading status */
@@ -506,12 +499,25 @@ export class Agent {
     id: string,
     filter?: string,
   ): { stdout: string; stderr: string; status: string } | null {
-    return this.backgroundBashManager.getOutput(id, filter);
+    return this.backgroundTaskManager.getOutput(id, filter);
   }
 
   /** Kill background bash shell */
   public killBackgroundShell(id: string): boolean {
-    return this.backgroundBashManager.killShell(id);
+    return this.backgroundTaskManager.stopTask(id);
+  }
+
+  /** Get background task output */
+  public getBackgroundTaskOutput(
+    id: string,
+    filter?: string,
+  ): { stdout: string; stderr: string; status: string } | null {
+    return this.backgroundTaskManager.getOutput(id, filter);
+  }
+
+  /** Stop background task */
+  public stopBackgroundTask(id: string): boolean {
+    return this.backgroundTaskManager.stopTask(id);
   }
 
   /**
@@ -938,14 +944,36 @@ export class Agent {
     this.slashCommandManager.abortCurrentCommand();
   }
 
+  /**
+   * Register a foreground task that can be backgrounded
+   */
+  public registerForegroundTask(task: ForegroundTask): void {
+    this.foregroundTaskManager.registerForegroundTask(task);
+  }
+
+  /**
+   * Unregister a foreground task
+   */
+  public unregisterForegroundTask(id: string): void {
+    this.foregroundTaskManager.unregisterForegroundTask(id);
+  }
+
+  /**
+   * Background the current foreground task
+   */
+  public async backgroundCurrentTask(): Promise<void> {
+    await this.foregroundTaskManager.backgroundCurrentTask();
+    this.options.callbacks?.onBackgroundCurrentTask?.();
+  }
+
   /** Destroy managers, clean up resources */
   public async destroy(): Promise<void> {
     await this.messageManager.saveSession();
     this.abortAIMessage(); // This will abort tools including Task tool (subagents)
     this.abortBashCommand();
     this.abortSlashCommand();
-    // Cleanup background bash manager
-    this.backgroundBashManager.cleanup();
+    // Cleanup background task manager
+    this.backgroundTaskManager.cleanup();
     // Cleanup MCP connections
     await this.mcpManager.cleanup();
     // Cleanup LSP connections

package/src/constants/tools.ts

@@ -1,7 +1,7 @@
 export const ASK_USER_QUESTION_TOOL_NAME = "AskUserQuestion";
 export const BASH_TOOL_NAME = "Bash";
-export const BASH_OUTPUT_TOOL_NAME = "BashOutput";
-export const KILL_BASH_TOOL_NAME = "KillBash";
+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";

package/src/managers/MemoryRuleManager.ts

@@ -148,7 +148,7 @@ export class MemoryRuleManager {
   getActiveRules(filesInContext: string[]): MemoryRule[] {
     const activeRules: MemoryRule[] = [];
     for (const rule of Object.values(this.state.rules)) {
-      if (this.service.isRuleActive(rule, filesInContext)) {
+      if (this.service.isRuleActive(rule, filesInContext, this.workdir)) {
         activeRules.push(rule);
       }
     }

package/src/managers/aiManager.ts

@@ -6,7 +6,6 @@ import {
 import { getMessagesToCompress } from "../utils/messageOperations.js";
 import { convertMessagesForAPI } from "../utils/convertMessagesForAPI.js";
 import { calculateComprehensiveTotalTokens } from "../utils/tokenCalculation.js";
-import * as memory from "../services/memory.js";
 import * as fs from "node:fs/promises";
 import type {
   Logger,
@@ -17,7 +16,7 @@ import type {
 import type { ToolManager } from "./toolManager.js";
 import type { ToolContext, ToolResult } from "../tools/types.js";
 import type { MessageManager } from "./messageManager.js";
-import type { BackgroundBashManager } from "./backgroundBashManager.js";
+import type { BackgroundTaskManager } from "./backgroundTaskManager.js";
 import { ChatCompletionMessageFunctionToolCall } from "openai/resources.js";
 import type { HookManager } from "./hookManager.js";
 import type { ExtendedHookExecutionContext } from "../types/hooks.js";
@@ -36,7 +35,7 @@ export interface AIManagerOptions {
   messageManager: MessageManager;
   toolManager: ToolManager;
   logger?: Logger;
-  backgroundBashManager?: BackgroundBashManager;
+  backgroundTaskManager?: BackgroundTaskManager;
   hookManager?: HookManager;
   permissionManager?: PermissionManager;
   callbacks?: AIManagerCallbacks;
@@ -61,7 +60,7 @@ export class AIManager {
   private logger?: Logger;
   private toolManager: ToolManager;
   private messageManager: MessageManager;
-  private backgroundBashManager?: BackgroundBashManager;
+  private backgroundTaskManager?: BackgroundTaskManager;
   private hookManager?: HookManager;
   private reversionManager?: import("./reversionManager.js").ReversionManager;
   private permissionManager?: PermissionManager;
@@ -80,7 +79,7 @@ export class AIManager {
   constructor(options: AIManagerOptions) {
     this.messageManager = options.messageManager;
     this.toolManager = options.toolManager;
-    this.backgroundBashManager = options.backgroundBashManager;
+    this.backgroundTaskManager = options.backgroundTaskManager;
     this.hookManager = options.hookManager;
     this.reversionManager = options.reversionManager;
     this.permissionManager = options.permissionManager;
@@ -333,9 +332,7 @@ export class AIManager {
 
     try {
       // Get combined memory content
-      const combinedMemory = await memory.getCombinedMemoryContent(
-        this.workdir,
-      );
+      const combinedMemory = await this.messageManager.getCombinedMemory();
 
       // Track if assistant message has been created
       let assistantMessageCreated = false;
@@ -618,7 +615,7 @@ export class AIManager {
               // Create tool execution context
               const context: ToolContext = {
                 abortSignal: toolAbortController.signal,
-                backgroundBashManager: this.backgroundBashManager,
+                backgroundTaskManager: this.backgroundTaskManager,
                 workdir: this.workdir,
                 messageId: this.messageManager.getMessages().slice(-1)[0]?.id,
               };

package/src/managers/backgroundBashManager.ts

@@ -42,6 +42,7 @@ export class BackgroundBashManager {
 
     const shell: BackgroundShell = {
       id,
+      type: "shell",
       process: child,
       command,
       startTime,

package/src/managers/backgroundTaskManager.ts

@@ -0,0 +1,306 @@
+import { spawn, type ChildProcess } from "child_process";
+import { BackgroundTask, BackgroundShell } from "../types/processes.js";
+import { stripAnsiColors } from "../utils/stringUtils.js";
+import { logger } from "../utils/globalLogger.js";
+
+export interface BackgroundTaskManagerCallbacks {
+  onTasksChange?: (tasks: BackgroundTask[]) => void;
+}
+
+export interface BackgroundTaskManagerOptions {
+  callbacks?: BackgroundTaskManagerCallbacks;
+  workdir: string;
+}
+
+export class BackgroundTaskManager {
+  private tasks = new Map<string, BackgroundTask>();
+  private nextId = 1;
+  private callbacks: BackgroundTaskManagerCallbacks;
+  private workdir: string;
+
+  constructor(options: BackgroundTaskManagerOptions) {
+    this.callbacks = options.callbacks || {};
+    this.workdir = options.workdir;
+  }
+
+  private notifyTasksChange(): void {
+    this.callbacks.onTasksChange?.(Array.from(this.tasks.values()));
+  }
+
+  public generateId(): string {
+    return `task_${this.nextId++}`;
+  }
+
+  public addTask(task: BackgroundTask): void {
+    this.tasks.set(task.id, task);
+    this.notifyTasksChange();
+  }
+
+  public getTask(id: string): BackgroundTask | undefined {
+    return this.tasks.get(id);
+  }
+
+  public getAllTasks(): BackgroundTask[] {
+    return Array.from(this.tasks.values());
+  }
+
+  public startShell(
+    command: string,
+    timeout?: number,
+  ): { id: string; child: ChildProcess; detach: () => void } {
+    const id = this.generateId();
+    const startTime = Date.now();
+
+    const child = spawn(command, {
+      shell: true,
+      stdio: "pipe",
+      cwd: this.workdir,
+      env: {
+        ...process.env,
+      },
+    });
+
+    const shell: BackgroundShell = {
+      id,
+      type: "shell",
+      process: child,
+      command,
+      startTime,
+      status: "running",
+      stdout: "",
+      stderr: "",
+    };
+
+    this.tasks.set(id, shell);
+    this.notifyTasksChange();
+
+    // Set up timeout if specified
+    let timeoutHandle: NodeJS.Timeout | undefined;
+    if (timeout && timeout > 0) {
+      timeoutHandle = setTimeout(() => {
+        if (shell.status === "running") {
+          this.stopTask(id);
+        }
+      }, timeout);
+    }
+
+    const onStdout = (data: Buffer | string) => {
+      shell.stdout += stripAnsiColors(data.toString());
+      this.notifyTasksChange();
+    };
+
+    const onStderr = (data: Buffer | string) => {
+      shell.stderr += stripAnsiColors(data.toString());
+      this.notifyTasksChange();
+    };
+
+    const onExit = (code: number | null) => {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+      shell.status = code === 0 ? "completed" : "failed";
+      shell.exitCode = code ?? 0;
+      shell.endTime = Date.now();
+      shell.runtime = shell.endTime - startTime;
+      this.notifyTasksChange();
+    };
+
+    const onError = (error: Error) => {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+      shell.status = "failed";
+      shell.stderr += `\nProcess error: ${stripAnsiColors(error.message)}`;
+      shell.exitCode = 1;
+      shell.endTime = Date.now();
+      shell.runtime = shell.endTime - startTime;
+      this.notifyTasksChange();
+    };
+
+    child.stdout?.on("data", onStdout);
+    child.stderr?.on("data", onStderr);
+    child.on("exit", onExit);
+    child.on("error", onError);
+
+    const detach = () => {
+      child.stdout?.off("data", onStdout);
+      child.stderr?.off("data", onStderr);
+      child.off("exit", onExit);
+      child.off("error", onError);
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+      this.tasks.delete(id);
+      this.notifyTasksChange();
+    };
+
+    return { id, child, detach };
+  }
+
+  public adoptProcess(
+    child: ChildProcess,
+    command: string,
+    initialStdout: string = "",
+    initialStderr: string = "",
+  ): string {
+    const id = this.generateId();
+    const startTime = Date.now();
+
+    const shell: BackgroundShell = {
+      id,
+      type: "shell",
+      process: child,
+      command,
+      startTime,
+      status: "running",
+      stdout: initialStdout,
+      stderr: initialStderr,
+    };
+
+    this.tasks.set(id, shell);
+    this.notifyTasksChange();
+
+    child.stdout?.on("data", (data) => {
+      shell.stdout += stripAnsiColors(data.toString());
+      this.notifyTasksChange();
+    });
+
+    child.stderr?.on("data", (data) => {
+      shell.stderr += stripAnsiColors(data.toString());
+      this.notifyTasksChange();
+    });
+
+    child.on("exit", (code) => {
+      shell.status = code === 0 ? "completed" : "failed";
+      shell.exitCode = code ?? 0;
+      shell.endTime = Date.now();
+      shell.runtime = shell.endTime - startTime;
+      this.notifyTasksChange();
+    });
+
+    child.on("error", (error) => {
+      shell.status = "failed";
+      shell.stderr += `\nProcess error: ${stripAnsiColors(error.message)}`;
+      shell.exitCode = 1;
+      shell.endTime = Date.now();
+      shell.runtime = shell.endTime - startTime;
+      this.notifyTasksChange();
+    });
+
+    return id;
+  }
+
+  public getOutput(
+    id: string,
+    filter?: string,
+  ): { stdout: string; stderr: string; status: string } | null {
+    const task = this.tasks.get(id);
+    if (!task) {
+      return null;
+    }
+
+    let stdout = task.stdout;
+    let stderr = task.stderr;
+
+    // Apply regex filter if provided
+    if (filter) {
+      try {
+        const regex = new RegExp(filter);
+        stdout = stdout
+          .split("\n")
+          .filter((line) => regex.test(line))
+          .join("\n");
+        stderr = stderr
+          .split("\n")
+          .filter((line) => regex.test(line))
+          .join("\n");
+      } catch (error) {
+        logger.warn(`Invalid filter regex: ${filter}`, error);
+      }
+    }
+
+    return {
+      stdout,
+      stderr,
+      status: task.status,
+    };
+  }
+
+  public stopTask(id: string): boolean {
+    const task = this.tasks.get(id);
+    if (!task || task.status !== "running") {
+      return false;
+    }
+
+    if (task.type === "shell") {
+      const shell = task as BackgroundShell;
+      try {
+        // Try to kill process group first
+        if (shell.process.pid) {
+          process.kill(-shell.process.pid, "SIGTERM");
+
+          // Force kill after timeout
+          setTimeout(() => {
+            if (
+              shell.status === "running" &&
+              shell.process.pid &&
+              !shell.process.killed
+            ) {
+              try {
+                process.kill(-shell.process.pid, "SIGKILL");
+              } catch (error) {
+                logger.error("Failed to force kill process:", error);
+              }
+            }
+          }, 1000);
+        }
+
+        shell.status = "killed";
+        shell.endTime = Date.now();
+        shell.runtime = shell.endTime - shell.startTime;
+        this.notifyTasksChange();
+        return true;
+      } catch {
+        // Fallback to direct process kill
+        try {
+          shell.process.kill("SIGTERM");
+          setTimeout(() => {
+            if (!shell.process.killed) {
+              shell.process.kill("SIGKILL");
+            }
+          }, 1000);
+          shell.status = "killed";
+          shell.endTime = Date.now();
+          shell.runtime = shell.endTime - shell.startTime;
+          this.notifyTasksChange();
+          return true;
+        } catch (directKillError) {
+          logger.error("Failed to kill child process:", directKillError);
+          return false;
+        }
+      }
+    } else if (task.type === "subagent") {
+      // Subagent termination logic will be handled by aborting the AI loop
+      // which is already managed by the SubagentManager and AIManager.
+      // Here we just update the status.
+      task.status = "killed";
+      task.endTime = Date.now();
+      task.runtime = task.endTime - task.startTime;
+      this.notifyTasksChange();
+      return true;
+    }
+
+    return false;
+  }
+
+  public cleanup(): void {
+    // Kill all running tasks
+    for (const [id, task] of this.tasks) {
+      if (task.status === "running") {
+        this.stopTask(id);
+      }
+    }
+    this.tasks.clear();
+    this.notifyTasksChange();
+  }
+}

package/src/managers/foregroundTaskManager.ts

@@ -0,0 +1,26 @@
+import { ForegroundTask, IForegroundTaskManager } from "../types/processes.js";
+
+export class ForegroundTaskManager implements IForegroundTaskManager {
+  private activeForegroundTasks: ForegroundTask[] = [];
+
+  public registerForegroundTask(task: ForegroundTask): void {
+    this.activeForegroundTasks.push(task);
+  }
+
+  public unregisterForegroundTask(id: string): void {
+    this.activeForegroundTasks = this.activeForegroundTasks.filter(
+      (t) => t.id !== id,
+    );
+  }
+
+  public async backgroundCurrentTask(): Promise<void> {
+    const task = this.activeForegroundTasks.pop();
+    if (task) {
+      await task.backgroundHandler();
+    }
+  }
+
+  public hasActiveTasks(): boolean {
+    return this.activeForegroundTasks.length > 0;
+  }
+}

package/src/managers/lspManager.ts

@@ -418,7 +418,9 @@ export class LspManager implements ILspManager {
         await this.sendRequest(lspProc, "shutdown", {}, timeout);
         await this.sendNotification(lspProc, "exit", {});
         // Give it a moment to exit
-        await new Promise((resolve) => setTimeout(resolve, 100));
+        if (timeout > 100) {
+          await new Promise((resolve) => setTimeout(resolve, 100));
+        }
       } catch (error) {
         this.logger?.debug(
           `Failed to gracefully shutdown LSP for ${language}: ${error}`,