wave-agent-sdk 0.6.1 → 0.6.3

package/src/agent.ts

@@ -50,7 +50,6 @@ import {
   loadSessionFromJsonl,
   handleSessionRestoration,
 } from "./services/session.js";
-import type { SubagentConfiguration } from "./utils/subagentParser.js";
 import { setGlobalLogger } from "./utils/globalLogger.js";
 import { ConfigurationService } from "./services/configurationService.js";
 import * as fs from "fs/promises";
@@ -232,9 +231,6 @@ export class Agent {
           );
           callbacks.onSessionIdChange?.(sessionId);
         },
-        onSubagentTaskStopRequested: (subagentId) => {
-          this.backgroundTaskManager.stopTask(subagentId);
-        },
       },
       workdir: this.workdir,
       logger: this.logger,
@@ -362,7 +358,6 @@ export class Agent {
     this.subagentManager = new SubagentManager({
       workdir: this.workdir,
       parentToolManager: this.toolManager,
-      parentMessageManager: this.messageManager,
       callbacks: {
         onSubagentUserMessageAdded: callbacks.onSubagentUserMessageAdded,
         onSubagentAssistantMessageAdded:
@@ -812,9 +807,6 @@ export class Agent {
       // Rebuild usage array from restored messages
       this.rebuildUsageFromMessages(sessionToRestore?.messages || []);
 
-      // After main session is restored, restore any associated subagent sessions
-      await this.restoreSubagentSessions(sessionToRestore?.messages || []);
-
       if (sessionToRestore) {
         this.messageManager.initializeFromSession(sessionToRestore);
 
@@ -830,85 +822,6 @@ export class Agent {
     }
   }
 
-  /**
-   * Restore subagent sessions associated with the current main session
-   * This method is called after the main session is restored to load any subagent sessions
-   */
-  private async restoreSubagentSessions(messages: Message[]): Promise<void> {
-    try {
-      // Only attempt to restore subagent sessions if we have messages (session was restored)
-      if (messages.length === 0) {
-        return;
-      }
-
-      // Extract sessionId -> subagentId mapping from SubagentBlocks
-      const subagentBlockMap = new Map<
-        string,
-        { subagentId: string; configuration: SubagentConfiguration }
-      >(); // sessionId -> { subagentId, configuration }
-
-      for (const message of messages) {
-        if (message.role === "assistant" && message.blocks) {
-          for (const block of message.blocks) {
-            if (
-              block.type === "subagent" &&
-              block.sessionId &&
-              block.subagentId &&
-              block.configuration
-            ) {
-              subagentBlockMap.set(block.sessionId, {
-                subagentId: block.subagentId,
-                configuration: block.configuration,
-              });
-            }
-          }
-        }
-      }
-
-      if (subagentBlockMap.size === 0) {
-        return; // No subagent blocks found
-      }
-
-      // Load subagent sessions using sessionIds
-      const subagentSessions = [];
-      for (const [sessionId, blockData] of subagentBlockMap) {
-        try {
-          const sessionData = await loadSessionFromJsonl(
-            sessionId,
-            this.messageManager.getWorkdir(),
-            "subagent",
-          );
-          if (sessionData) {
-            subagentSessions.push({
-              sessionData,
-              subagentId: blockData.subagentId, // Use the subagentId from SubagentBlock
-              configuration: blockData.configuration, // Include configuration
-            });
-          }
-        } catch (error) {
-          this.logger?.warn(
-            `Failed to load subagent session ${sessionId}:`,
-            error,
-          );
-        }
-      }
-
-      if (subagentSessions.length > 0) {
-        this.logger?.debug(
-          `Found ${subagentSessions.length} subagent sessions to restore`,
-        );
-
-        // Restore subagent sessions through the SubagentManager
-        await this.subagentManager.restoreSubagentSessions(subagentSessions);
-
-        this.logger?.debug("Subagent sessions restored successfully");
-      }
-    } catch (error) {
-      this.logger?.warn("Failed to restore subagent sessions:", error);
-      // Don't throw error to prevent app startup failure
-    }
-  }
-
   /**
    * Restore a session by ID, switching to the target session without destroying the Agent instance
    * @param sessionId - The ID of the session to restore
@@ -943,9 +856,8 @@ export class Agent {
     this.abortMessage(); // Abort any running operations
     this.subagentManager.cleanup(); // Clean up active subagents
 
-    // 5. Rebuild usage and restore subagents (in correct order)
+    // 5. Rebuild usage (in correct order)
     this.rebuildUsageFromMessages(sessionData.messages);
-    await this.restoreSubagentSessions(sessionData.messages);
 
     // 6. Initialize session state last
     this.messageManager.initializeFromSession(sessionData);
@@ -1240,6 +1152,8 @@ export class Agent {
    */
   public async truncateHistory(index: number): Promise<void> {
     await this.messageManager.truncateHistory(index, this.reversionManager);
+    // After truncating history, the task list might have changed, so refresh it.
+    await this.taskManager.refreshTasks();
   }
 
   /**

package/src/constants/subagents.ts

@@ -0,0 +1,4 @@
+export const BASH_SUBAGENT_TYPE = "Bash";
+export const EXPLORE_SUBAGENT_TYPE = "Explore";
+export const PLAN_SUBAGENT_TYPE = "Plan";
+export const GENERAL_PURPOSE_SUBAGENT_TYPE = "general-purpose";

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);