wave-agent-sdk 0.4.0 → 0.5.0

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}`,

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;