wave-agent-sdk 0.2.1 → 0.5.0

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,19 +35,21 @@ export interface AIManagerOptions {
   messageManager: MessageManager;
   toolManager: ToolManager;
   logger?: Logger;
-  backgroundBashManager?: BackgroundBashManager;
+  backgroundTaskManager?: BackgroundTaskManager;
   hookManager?: HookManager;
   permissionManager?: PermissionManager;
   callbacks?: AIManagerCallbacks;
   workdir: string;
   systemPrompt?: string;
   subagentType?: string; // Optional subagent type for hook context
+  reversionManager?: import("./reversionManager.js").ReversionManager;
   /**Whether to use streaming mode for AI responses - defaults to true */
   stream?: boolean;
   // Dynamic configuration getters
   getGatewayConfig: () => GatewayConfig;
   getModelConfig: () => ModelConfig;
   getMaxInputTokens: () => number;
+  getLanguage: () => string | undefined;
   getEnvironmentVars?: () => Record<string, string>; // Get configuration environment variables for hooks
 }
 
@@ -59,8 +60,9 @@ 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;
   private workdir: string;
   private systemPrompt?: string;
@@ -71,13 +73,15 @@ export class AIManager {
   private getGatewayConfigFn: () => GatewayConfig;
   private getModelConfigFn: () => ModelConfig;
   private getMaxInputTokensFn: () => number;
+  private getLanguageFn: () => string | undefined;
   private getEnvironmentVarsFn?: () => Record<string, string>;
 
   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;
     this.logger = options.logger;
     this.workdir = options.workdir;
@@ -90,6 +94,7 @@ export class AIManager {
     this.getGatewayConfigFn = options.getGatewayConfig;
     this.getModelConfigFn = options.getModelConfig;
     this.getMaxInputTokensFn = options.getMaxInputTokens;
+    this.getLanguageFn = options.getLanguage;
     this.getEnvironmentVarsFn = options.getEnvironmentVars;
   }
 
@@ -106,6 +111,10 @@ export class AIManager {
     return this.getMaxInputTokensFn();
   }
 
+  public getLanguage(): string | undefined {
+    return this.getLanguageFn();
+  }
+
   private isCompressing: boolean = false;
   private callbacks: AIManagerCallbacks;
 
@@ -150,6 +159,15 @@ export class AIManager {
     this.setIsLoading(false);
   }
 
+  /**
+   * Abort the AI recursion loop immediately.
+   * This is used when a tool is backgrounded via Ctrl-B, even if no foreground task was active.
+   */
+  public abortRecursion(): void {
+    this.logger?.info("Aborting AI recursion loop");
+    this.abortAIMessage();
+  }
+
   // Helper method to generate compactParams
   private generateCompactParams(
     toolName: string,
@@ -267,7 +285,7 @@ export class AIManager {
     options: {
       recursionDepth?: number;
       model?: string;
-      /** Rules for automatic tool approval (e.g., "Bash(git status:*)") */
+      /** Rules for automatic tool approval (e.g., "Bash(git status*)") */
       allowedRules?: string[];
       /** List of tools available to the AI (e.g., ["Bash", "Read"]) */
       tools?: string[];
@@ -287,9 +305,6 @@ export class AIManager {
       return;
     }
 
-    // Save session in each recursion to ensure message persistence
-    await this.messageManager.saveSession();
-
     // Only create new AbortControllers for the initial call (recursionDepth === 0)
     // For recursive calls, reuse existing controllers to maintain abort signal
     let abortController: AbortController;
@@ -304,10 +319,14 @@ export class AIManager {
       this.toolAbortController = toolAbortController;
     } else {
       // Reuse existing controllers for recursive calls
-      abortController = this.abortController!;
-      toolAbortController = this.toolAbortController!;
+      // Fallback to new controllers if they were cleared (should not happen in normal flow but good for tests)
+      abortController = this.abortController || new AbortController();
+      toolAbortController = this.toolAbortController || new AbortController();
     }
 
+    // Save session in each recursion to ensure message persistence
+    await this.messageManager.saveSession();
+
     // Only set loading state for the initial call
     if (recursionDepth === 0) {
       this.setIsLoading(true);
@@ -323,9 +342,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;
@@ -342,6 +359,13 @@ export class AIManager {
         toolsConfig,
       );
 
+      // Inject language prompt if configured
+      const language = this.getLanguage();
+      if (language) {
+        const languagePrompt = `\n\n# Language\nAlways respond in ${language}. Technical terms (e.g., code, tool names, file paths) should remain in their original language or English where appropriate.`;
+        effectiveSystemPrompt = (effectiveSystemPrompt || "") + languagePrompt;
+      }
+
       if (currentMode === "plan") {
         const planFilePath = this.permissionManager?.getPlanFilePath();
         if (planFilePath) {
@@ -601,8 +625,9 @@ 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,
               };
 
               // Execute tool
@@ -612,6 +637,23 @@ export class AIManager {
                 context,
               );
 
+              // Check if the tool was backgrounded via Ctrl-B
+              // If it was backgrounded, we should abort the AI recursion
+              if (
+                toolResult.success &&
+                toolResult.content.includes(
+                  "Command was manually backgrounded by user",
+                )
+              ) {
+                this.logger?.info(
+                  `Tool ${toolName} was backgrounded via Ctrl-B, aborting AI recursion`,
+                );
+                // Use abortAIMessage directly instead of abortRecursion to avoid double logging
+                // and ensure we don't trigger the "Request was aborted" error block
+                this.abortAIMessage();
+                return;
+              }
+
               // Update message state - tool execution completed
               this.messageManager.updateToolBlock({
                 id: toolId,
@@ -666,6 +708,15 @@ export class AIManager {
 
       // Check if there are tool operations, if so automatically initiate next AI service call
       if (toolCalls.length > 0) {
+        // Record committed snapshots to message history
+        if (this.reversionManager) {
+          const snapshots =
+            this.reversionManager.getAndClearCommittedSnapshots();
+          if (snapshots.length > 0) {
+            this.messageManager.addFileHistoryBlock(snapshots);
+          }
+        }
+
         // Check interruption status
         const isCurrentlyAborted =
           abortController.signal.aborted || toolAbortController.signal.aborted;
@@ -682,9 +733,18 @@ export class AIManager {
         }
       }
     } catch (error) {
-      this.messageManager.addErrorBlock(
-        error instanceof Error ? error.message : "Unknown error occurred",
-      );
+      // Check if the error is an abort error
+      // Use the local variables to avoid null reference if this.abortController was cleared
+      const isCurrentlyAborted =
+        abortController.signal.aborted || toolAbortController.signal.aborted;
+
+      if (isCurrentlyAborted) {
+        this.logger?.info("AI message processing was aborted");
+      } else {
+        this.messageManager.addErrorBlock(
+          error instanceof Error ? error.message : "Unknown error occurred",
+        );
+      }
     } finally {
       // Only execute cleanup and hooks for the initial call
       if (recursionDepth === 0) {
@@ -705,6 +765,15 @@ export class AIManager {
           abortController.signal.aborted || toolAbortController.signal.aborted;
 
         if (!isCurrentlyAborted) {
+          // Record committed snapshots to message history for the final turn
+          if (this.reversionManager) {
+            const snapshots =
+              this.reversionManager.getAndClearCommittedSnapshots();
+            if (snapshots.length > 0) {
+              this.messageManager.addFileHistoryBlock(snapshots);
+            }
+          }
+
           const shouldContinue = await this.executeStopHooks();
 
           // If Stop/SubagentStop hooks indicate we should continue (due to blocking errors),

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/bashManager.ts

@@ -1,5 +1,4 @@
 import { spawn, type ChildProcess } from "child_process";
-import { addBashCommandToHistory } from "../utils/bashHistory.js";
 import type { MessageManager } from "./messageManager.js";
 
 export interface BashManagerOptions {
@@ -66,9 +65,6 @@ export class BashManager {
       child.on("exit", (code, signal) => {
         const exitCode = code === null && signal ? 130 : (code ?? 0);
 
-        // Add command to bash history
-        addBashCommandToHistory(command, this.workdir);
-
         this.messageManager.completeCommandMessage(command, exitCode);
 
         this.setCommandRunning(false);

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/liveConfigManager.ts

@@ -10,6 +10,7 @@
 import { existsSync } from "fs";
 import type { Logger } from "../types/index.js";
 import type { PermissionMode } from "../types/permissions.js";
+import type { Scope } from "../types/configuration.js";
 import {
   FileWatcherService,
   type FileWatchEvent,
@@ -452,7 +453,7 @@ export class LiveConfigManager {
 
   private async handleFileChange(
     event: FileWatchEvent,
-    source: "user" | "project",
+    source: Scope,
   ): Promise<void> {
     this.logger?.debug(
       `Live Config: File ${event.type} detected for ${source} config: ${event.path}`,

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