wave-agent-sdk 0.6.1 → 0.6.2

package/src/managers/aiManager.ts

@@ -1,5 +1,3 @@
-import * as os from "node:os";
-import * as path from "node:path";
 import {
   callAgent,
   compressMessages,
@@ -7,7 +5,6 @@ import {
 } from "../services/aiService.js";
 import { convertMessagesForAPI } from "../utils/convertMessagesForAPI.js";
 import { calculateComprehensiveTotalTokens } from "../utils/tokenCalculation.js";
-import * as fsSync from "node:fs";
 import * as fs from "node:fs/promises";
 import type {
   Logger,
@@ -23,24 +20,7 @@ import { ChatCompletionMessageFunctionToolCall } from "openai/resources.js";
 import type { HookManager } from "./hookManager.js";
 import type { ExtendedHookExecutionContext } from "../types/hooks.js";
 import type { PermissionManager } from "./permissionManager.js";
-import { buildSystemPrompt } from "../constants/prompts.js";
-
-function isGitRepository(dirPath: string): string {
-  try {
-    // Check if .git directory exists in current directory or any parent directory
-    let currentPath = path.resolve(dirPath);
-    while (currentPath !== path.dirname(currentPath)) {
-      const gitPath = path.join(currentPath, ".git");
-      if (fsSync.existsSync(gitPath)) {
-        return "Yes";
-      }
-      currentPath = path.dirname(currentPath);
-    }
-    return "No";
-  } catch {
-    return "No";
-  }
-}
+import { buildSystemPrompt } from "../prompts/index.js";
 
 export interface AIManagerCallbacks {
   onCompressionStateChange?: (isCompressing: boolean) => void;
@@ -399,12 +379,9 @@ export class AIManager {
           filteredToolPlugins,
           {
             workdir: this.workdir,
-            isGitRepo: isGitRepository(this.workdir),
-            platform: os.platform(),
-            osVersion: `${os.type()} ${os.release()}`,
-            today: new Date().toISOString().split("T")[0],
             memory: combinedMemory,
             language: this.getLanguage(),
+            isSubagent: !!this.subagentType,
             planMode: planModeOptions,
           },
         ), // Pass custom system prompt
@@ -643,6 +620,13 @@ export class AIManager {
                 messageId: this.messageManager.getMessages().slice(-1)[0]?.id,
                 sessionId: this.messageManager.getSessionId(),
                 taskManager: this.taskManager,
+                onShortResultUpdate: (shortResult: string) => {
+                  this.messageManager.updateToolBlock({
+                    id: toolId,
+                    shortResult,
+                    stage: "running", // Keep it in running stage while updating shortResult
+                  });
+                },
               };
 
               // Execute tool

package/src/managers/backgroundTaskManager.ts

@@ -285,6 +285,11 @@ export class BackgroundTaskManager {
       }
     }
 
+    // If it's a subagent task, we should also notify the subagent manager to cleanup
+    // However, to avoid circular dependency, we rely on the onStop callback
+    // which is already set to instance.aiManager.abortAIMessage()
+    // The subagentManager.cleanupInstance will be called by the tool or by status change.
+
     task.status = "killed";
     task.endTime = Date.now();
     task.runtime = task.endTime - task.startTime;

package/src/managers/messageManager.ts

@@ -6,15 +6,10 @@ import {
   addCommandOutputMessage,
   updateCommandOutputInMessage,
   completeCommandInMessage,
-  addSubagentBlockToMessage,
-  updateSubagentBlockInMessage,
   removeLastUserMessage,
   UserMessageParams,
-  type AddSubagentBlockParams,
-  type UpdateSubagentBlockParams,
   type AgentToolBlockUpdateParams,
 } from "../utils/messageOperations.js";
-import type { SubagentConfiguration } from "../utils/subagentParser.js";
 import type { Logger, Message, Usage, SlashCommand } from "../types/index.js";
 import { join } from "path";
 import {
@@ -59,23 +54,9 @@ export interface MessageManagerCallbacks {
   onInfoBlockAdded?: (content: string) => void;
   // Rewind callbacks
   onShowRewind?: () => void;
-  // Subagent callbacks
-  onSubAgentBlockAdded?: (
-    subagentId: string,
-    parameters: {
-      description: string;
-      prompt: string;
-      subagent_type: string;
-    },
-  ) => void;
-  onSubAgentBlockUpdated?: (
-    subagentId: string,
-    status: "active" | "completed" | "error" | "aborted",
-  ) => void;
   onFileHistoryBlockAdded?: (
     snapshots: import("../types/reversion.js").FileSnapshot[],
   ) => void;
-  onSubagentTaskStopRequested?: (subagentId: string) => void;
 }
 
 export interface MessageManagerOptions {
@@ -505,58 +486,6 @@ export class MessageManager {
     this.callbacks.onCompleteCommandMessage?.(command, exitCode);
   }
 
-  // Subagent block methods
-  public addSubagentBlock(
-    subagentId: string,
-    subagentName: string,
-    sessionId: string,
-    configuration: SubagentConfiguration,
-    status: "active" | "completed" | "error" | "aborted" = "active",
-    parameters: {
-      description: string;
-      prompt: string;
-      subagent_type: string;
-    },
-    runInBackground?: boolean,
-  ): void {
-    const params: AddSubagentBlockParams = {
-      messages: this.messages,
-      subagentId,
-      subagentName,
-      sessionId,
-      status,
-      configuration,
-      runInBackground,
-    };
-    const updatedMessages = addSubagentBlockToMessage(params);
-    this.setMessages(updatedMessages);
-    this.callbacks.onSubAgentBlockAdded?.(params.subagentId, parameters);
-  }
-
-  public updateSubagentBlock(
-    subagentId: string,
-    updates: Partial<{
-      status: "active" | "completed" | "error" | "aborted";
-      sessionId: string;
-      runInBackground: boolean;
-    }>,
-  ): void {
-    const updatedMessages = updateSubagentBlockInMessage(
-      this.messages,
-      subagentId,
-      updates,
-    );
-    this.setMessages(updatedMessages);
-    const params: UpdateSubagentBlockParams = {
-      messages: this.messages,
-      subagentId,
-      status: updates.status || "active",
-    };
-    if (updates.status) {
-      this.callbacks.onSubAgentBlockUpdated?.(params.subagentId, params.status);
-    }
-  }
-
   /**
    * Trigger usage change callback with all usage data from assistant messages
    */
@@ -773,15 +702,6 @@ export class MessageManager {
       targetIndexInSession,
     );
 
-    // Identify subagent tasks to stop
-    for (const message of messagesToRemove) {
-      for (const block of message.blocks) {
-        if (block.type === "subagent" && block.subagentId) {
-          this.callbacks.onSubagentTaskStopRequested?.(block.subagentId);
-        }
-      }
-    }
-
     // Update target session file
     this.sessionId = targetSessionId;
     this.rootSessionId = targetSessionData.rootSessionId || targetSessionId;

package/src/managers/reversionManager.ts

@@ -123,10 +123,15 @@ export class ReversionManager {
     const sortedSnapshots = snapshots.sort((a, b) => b.timestamp - a.timestamp);
 
     let revertedCount = 0;
+    const affectedTaskListIds = new Set<string>();
+
     for (const snapshot of sortedSnapshots) {
       try {
-        if (!snapshot.snapshotPath) {
-          // File didn't exist before, so delete it
+        if (snapshot.operation === "create") {
+          // For 'create' operations, we should hard delete the file upon reversion
+          await fs.rm(snapshot.filePath, { force: true });
+        } else if (!snapshot.snapshotPath) {
+          // Fallback for older snapshots or if snapshotPath is missing
           await fs.rm(snapshot.filePath, { force: true });
         } else {
           // Restore previous content
@@ -141,12 +146,31 @@ export class ReversionManager {
             await fs.rm(snapshot.filePath, { force: true });
           }
         }
+
+        // Check if this is a task file and track the task list ID
+        if (snapshot.filePath.includes("/.wave/tasks/")) {
+          const parts = snapshot.filePath.split("/.wave/tasks/");
+          if (parts.length > 1) {
+            const taskListId = parts[1].split("/")[0];
+            if (taskListId) {
+              affectedTaskListIds.add(taskListId);
+            }
+          }
+        }
+
         revertedCount++;
       } catch (error) {
         console.error(`Failed to revert file ${snapshot.filePath}:`, error);
       }
     }
 
+    // Notify TaskManager if any task lists were affected
+    // Note: In the current architecture, TaskManager is managed by Agent and
+    // listens for file changes if it's a foreground process, or we might need
+    // to explicitly trigger a refresh. Since ReversionManager doesn't have
+    // a direct reference to TaskManager, we rely on the fact that TaskManager
+    // will see the file system changes or be refreshed by the Agent/UI.
+
     return revertedCount;
   }
 }

package/src/managers/slashCommandManager.ts

@@ -21,7 +21,7 @@ import {
 } from "../utils/markdownParser.js";
 import { exec } from "child_process";
 import { promisify } from "util";
-import { INIT_PROMPT } from "../constants/prompts.js";
+import { INIT_PROMPT } from "../prompts/index.js";
 
 const execAsync = promisify(exec);
 

package/src/managers/subagentManager.ts

@@ -8,20 +8,19 @@ import type {
   ModelConfig,
   Usage,
 } from "../types/index.js";
-import type { SessionData } from "../services/session.js";
 import { AIManager } from "./aiManager.js";
 import { MessageManager } from "./messageManager.js";
 import { ToolManager } from "./toolManager.js";
 import { HookManager } from "./hookManager.js";
-import {
-  UserMessageParams,
-  type AgentToolBlockUpdateParams,
-} from "../utils/messageOperations.js";
 import {
   addConsolidatedAbortListener,
   createAbortPromise,
 } from "../utils/abortUtils.js";
 import { BackgroundTaskManager } from "./backgroundTaskManager.js";
+import {
+  UserMessageParams,
+  type AgentToolBlockUpdateParams,
+} from "../utils/messageOperations.js";
 
 export interface SubagentManagerCallbacks {
   // Granular subagent message callbacks (015-subagent-message-callbacks)
@@ -66,14 +65,15 @@ export interface SubagentInstance {
   toolManager: ToolManager;
   status: "initializing" | "active" | "completed" | "error" | "aborted";
   messages: Message[];
+  lastTools: string[]; // Track last two tool names
   subagentType: string; // Store the subagent type for hook context
   backgroundTaskId?: string; // ID of the background task if transitioned
+  onUpdate?: () => void; // Optional callback for real-time updates
 }
 
 export interface SubagentManagerOptions {
   workdir: string;
   parentToolManager: ToolManager;
-  parentMessageManager: MessageManager;
   taskManager: import("../services/taskManager.js").TaskManager;
   callbacks?: SubagentManagerCallbacks; // Use SubagentManagerCallbacks instead of parentCallbacks
   logger?: Logger;
@@ -93,7 +93,6 @@ export class SubagentManager {
 
   private workdir: string;
   private parentToolManager: ToolManager;
-  private parentMessageManager: MessageManager;
   private taskManager: import("../services/taskManager.js").TaskManager;
   private callbacks?: SubagentManagerCallbacks; // Use SubagentManagerCallbacks instead of parentCallbacks
   private logger?: Logger;
@@ -109,7 +108,6 @@ export class SubagentManager {
   constructor(options: SubagentManagerOptions) {
     this.workdir = options.workdir;
     this.parentToolManager = options.parentToolManager;
-    this.parentMessageManager = options.parentMessageManager;
     this.taskManager = options.taskManager;
     this.callbacks = options.callbacks; // Store SubagentManagerCallbacks
     this.logger = options.logger;
@@ -176,6 +174,7 @@ export class SubagentManager {
       subagent_type: string;
     },
     runInBackground?: boolean,
+    onUpdate?: () => void,
   ): Promise<SubagentInstance> {
     if (!this.parentToolManager) {
       throw new Error(
@@ -248,22 +247,13 @@ export class SubagentManager {
       toolManager,
       status: "initializing",
       messages: [],
+      lastTools: [], // Initialize lastTools
       subagentType: parameters.subagent_type, // Store the subagent type
+      onUpdate,
     };
 
     this.instances.set(subagentId, instance);
 
-    // Create subagent block in parent message manager
-    this.parentMessageManager.addSubagentBlock(
-      subagentId,
-      configuration.name,
-      messageManager.getSessionId(),
-      configuration,
-      "active",
-      parameters,
-      runInBackground,
-    );
-
     return instance;
   }
 
@@ -287,9 +277,6 @@ export class SubagentManager {
 
       // Set status to active and update parent
       this.updateInstanceStatus(instance.subagentId, "active");
-      this.parentMessageManager.updateSubagentBlock(instance.subagentId, {
-        status: "active",
-      });
 
       if (runInBackground && this.backgroundTaskManager) {
         const taskId = this.backgroundTaskManager.generateId();
@@ -303,7 +290,11 @@ export class SubagentManager {
           description: instance.configuration.description,
           stdout: "",
           stderr: "",
-          onStop: () => instance.aiManager.abortAIMessage(),
+          subagentId: instance.subagentId,
+          onStop: () => {
+            instance.aiManager.abortAIMessage();
+            this.cleanupInstance(instance.subagentId);
+          },
         });
 
         instance.backgroundTaskId = taskId;
@@ -341,9 +332,6 @@ export class SubagentManager {
       return await this.internalExecute(instance, prompt, abortSignal);
     } catch (error) {
       this.updateInstanceStatus(instance.subagentId, "error");
-      this.parentMessageManager.updateSubagentBlock(instance.subagentId, {
-        status: "error",
-      });
       throw error;
     }
   }
@@ -369,16 +357,15 @@ export class SubagentManager {
       description: instance.configuration.description,
       stdout: "",
       stderr: "",
-      onStop: () => instance.aiManager.abortAIMessage(),
+      subagentId: instance.subagentId,
+      onStop: () => {
+        instance.aiManager.abortAIMessage();
+        this.cleanupInstance(instance.subagentId);
+      },
     });
 
     instance.backgroundTaskId = taskId;
 
-    // Update parent message manager to reflect background status
-    this.parentMessageManager.updateSubagentBlock(subagentId, {
-      runInBackground: true,
-    });
-
     return taskId;
   }
 
@@ -395,9 +382,8 @@ export class SubagentManager {
         () => {
           // Update status to aborted
           this.updateInstanceStatus(instance.subagentId, "aborted");
-          this.parentMessageManager.updateSubagentBlock(instance.subagentId, {
-            status: "aborted",
-          });
+          // Cleanup instance immediately on abort
+          this.cleanupInstance(instance.subagentId);
         },
         () => {
           // Abort the AI execution
@@ -474,9 +460,6 @@ export class SubagentManager {
 
       // Update status to completed and update parent
       this.updateInstanceStatus(instance.subagentId, "completed");
-      this.parentMessageManager.updateSubagentBlock(instance.subagentId, {
-        status: "completed",
-      });
 
       // If this was transitioned to background, update the background task
       if (instance.backgroundTaskId && this.backgroundTaskManager) {
@@ -580,99 +563,6 @@ export class SubagentManager {
     this.instances.clear();
   }
 
-  /**
-   * Restore subagent instances from saved session data
-   * This method is called during agent initialization to restore previous subagent states
-   */
-  async restoreSubagentSessions(
-    subagentSessions: Array<{
-      sessionData: SessionData;
-      subagentId: string;
-      configuration: SubagentConfiguration;
-    }>,
-  ): Promise<void> {
-    for (const { sessionData, subagentId, configuration } of subagentSessions) {
-      try {
-        // Use the configuration from the SubagentBlock
-
-        // Create the subagent instance without executing - just restore the state
-
-        // Create MessageManager for the restored subagent
-        const subagentCallbacks = this.createSubagentCallbacks(subagentId);
-        const messageManager = new MessageManager({
-          callbacks: subagentCallbacks,
-          workdir: this.workdir,
-          logger: this.logger,
-          sessionType: "subagent",
-          subagentType: configuration.name, // Use configuration name for restored sessions
-          memoryRuleManager: this.memoryRuleManager,
-        });
-
-        // Use the parent tool manager
-        const toolManager = this.parentToolManager;
-
-        // Determine model to use
-        let modelToUse: string;
-        const parentModelConfig = this.getModelConfig();
-
-        if (!configuration.model || configuration.model === "inherit") {
-          modelToUse = parentModelConfig.agentModel;
-        } else if (configuration.model === "fastModel") {
-          modelToUse = parentModelConfig.fastModel;
-        } else {
-          modelToUse = configuration.model;
-        }
-
-        // Create AIManager for the restored subagent
-        const aiManager = new AIManager({
-          messageManager,
-          toolManager,
-          taskManager: this.taskManager,
-          logger: this.logger,
-          workdir: this.workdir,
-          systemPrompt: configuration.systemPrompt,
-          subagentType: configuration.name, // Use configuration name as subagent type for restored instances
-          hookManager: this.hookManager,
-          permissionManager: this.parentToolManager.getPermissionManager(),
-          getGatewayConfig: this.getGatewayConfig,
-          getModelConfig: () => ({
-            ...parentModelConfig,
-            agentModel: modelToUse,
-          }),
-          getMaxInputTokens: this.getMaxInputTokens,
-          getLanguage: this.getLanguage,
-          callbacks: {
-            onUsageAdded: this.onUsageAdded,
-          },
-        });
-
-        // Create restored instance
-        const instance: SubagentInstance = {
-          subagentId,
-          configuration,
-          aiManager,
-          messageManager,
-          toolManager,
-          status: "completed", // Restored sessions are considered completed
-          messages: sessionData.messages,
-          subagentType: configuration.name, // Use configuration name as subagent type for restored instances
-        };
-
-        // IMPORTANT: Store instance in map BEFORE calling setMessages
-        // This ensures the callback can find the instance
-        this.instances.set(subagentId, instance);
-
-        messageManager.initializeFromSession(sessionData);
-      } catch (error) {
-        this.logger?.warn(
-          `Failed to restore subagent session ${subagentId}:`,
-          error,
-        );
-        // Continue with other sessions even if one fails
-      }
-    }
-  }
-
   /**
    * Create subagent callbacks for a specific subagent ID
    * Extracted to reuse in both create and restore flows
@@ -715,6 +605,20 @@ export class SubagentManager {
       },
 
       onToolBlockUpdated: (params: AgentToolBlockUpdateParams) => {
+        // Track last two tool names when a tool starts running
+        if (params.stage === "running" && params.name) {
+          const instance = this.instances.get(subagentId);
+          if (instance) {
+            // Add to lastTools if it's different from the last one or we want to show duplicates
+            // Based on "ToolA, ToolB" requirement, we'll just keep the last two
+            instance.lastTools.push(params.name);
+            if (instance.lastTools.length > 2) {
+              instance.lastTools.shift();
+            }
+            instance.onUpdate?.();
+          }
+        }
+
         // Forward tool block updates to parent via SubagentManager callbacks
         if (this.callbacks?.onSubagentToolBlockUpdated) {
           this.callbacks.onSubagentToolBlockUpdated(subagentId, params);
@@ -726,6 +630,8 @@ export class SubagentManager {
         const instance = this.instances.get(subagentId);
         if (instance) {
           instance.messages = messages;
+          // Trigger the onUpdate callback if provided
+          instance.onUpdate?.();
           // Forward subagent message changes to parent via callbacks
           if (this.callbacks?.onSubagentMessagesChange) {
             this.callbacks.onSubagentMessagesChange(subagentId, messages);
@@ -733,26 +639,17 @@ export class SubagentManager {
         }
       },
 
-      onSessionIdChange: (newSessionId: string) => {
-        // Update the subagent block with the new session ID
-        this.parentMessageManager.updateSubagentBlock(subagentId, {
-          sessionId: newSessionId,
-        });
-      },
-
       onLatestTotalTokensChange: (tokens: number) => {
+        const instance = this.instances.get(subagentId);
+        if (instance) {
+          // Trigger the onUpdate callback if provided
+          instance.onUpdate?.();
+        }
         // Forward latest total tokens to parent via SubagentManager callbacks
         if (this.callbacks?.onSubagentLatestTotalTokensChange) {
           this.callbacks.onSubagentLatestTotalTokensChange(subagentId, tokens);
         }
       },
-
-      onFileHistoryBlockAdded: (
-        snapshots: import("../types/reversion.js").FileSnapshot[],
-      ) => {
-        // Forward file history blocks to parent MessageManager
-        this.parentMessageManager.addFileHistoryBlock(snapshots);
-      },
     };
   }
 }