wave-agent-sdk 0.5.0 → 0.6.2

package/src/managers/messageManager.ts

@@ -3,19 +3,13 @@ import {
   updateToolBlockInMessage,
   addErrorBlockToMessage,
   addUserMessageToMessages,
-  extractUserInputHistory,
   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 {
@@ -33,7 +27,6 @@ export interface MessageManagerCallbacks {
   onMessagesChange?: (messages: Message[]) => void;
   onSessionIdChange?: (sessionId: string) => void;
   onLatestTotalTokensChange?: (latestTotalTokens: number) => void;
-  onUserInputHistoryChange?: (history: string[]) => void;
   onUsagesChange?: (usages: Usage[]) => void;
   // Incremental callback
   onUserMessageAdded?: (params: UserMessageParams) => void;
@@ -45,7 +38,7 @@ export interface MessageManagerCallbacks {
   onAssistantReasoningUpdated?: (chunk: string, accumulated: string) => void;
   onToolBlockUpdated?: (params: AgentToolBlockUpdateParams) => void;
   onErrorBlockAdded?: (error: string) => void;
-  onCompressBlockAdded?: (insertIndex: number, content: string) => void;
+  onCompressBlockAdded?: (content: string) => void;
   onCompressionStateChange?: (isCompressing: boolean) => void;
   onMemoryBlockAdded?: (
     content: string,
@@ -61,18 +54,8 @@ 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",
+  onFileHistoryBlockAdded?: (
+    snapshots: import("../types/reversion.js").FileSnapshot[],
   ) => void;
 }
 
@@ -88,9 +71,10 @@ export interface MessageManagerOptions {
 export class MessageManager {
   // Private state properties
   private sessionId: string;
+  private rootSessionId: string;
+  private parentSessionId?: string;
   private messages: Message[];
   private latestTotalTokens: number;
-  private userInputHistory: string[];
   private workdir: string;
   private encodedWorkdir: string; // Cached encoded workdir
   private logger?: Logger; // Add optional logger property
@@ -104,9 +88,9 @@ export class MessageManager {
 
   constructor(options: MessageManagerOptions) {
     this.sessionId = generateSessionId();
+    this.rootSessionId = this.sessionId;
     this.messages = [];
     this.latestTotalTokens = 0;
-    this.userInputHistory = [];
     this.workdir = options.workdir;
     this.encodedWorkdir = pathEncoder.encodeSync(this.workdir); // Cache encoded workdir
     this.callbacks = options.callbacks;
@@ -125,6 +109,14 @@ export class MessageManager {
     return this.sessionId;
   }
 
+  public getRootSessionId(): string {
+    return this.rootSessionId;
+  }
+
+  public getParentSessionId(): string | undefined {
+    return this.parentSessionId;
+  }
+
   public getMessages(): Message[] {
     return [...this.messages];
   }
@@ -133,10 +125,6 @@ export class MessageManager {
     return this.latestTotalTokens;
   }
 
-  public getUserInputHistory(): string[] {
-    return [...this.userInputHistory];
-  }
-
   public getWorkdir(): string {
     return this.workdir;
   }
@@ -247,6 +235,8 @@ export class MessageManager {
         unsavedMessages, // Only append new messages
         this.workdir,
         this.sessionType,
+        this.rootSessionId,
+        this.parentSessionId,
       );
 
       // Update the saved message count
@@ -264,18 +254,13 @@ export class MessageManager {
     }
   }
 
-  public setUserInputHistory(userInputHistory: string[]): void {
-    this.userInputHistory = [...userInputHistory];
-    this.callbacks.onUserInputHistoryChange?.(this.userInputHistory);
-  }
-
   /**
-   * Clear messages and input history
+   * Clear messages
    */
   public clearMessages(): void {
     this.setMessages([]);
-    this.setUserInputHistory([]);
     this.setSessionId(generateSessionId());
+    this.rootSessionId = this.sessionId;
     this.setlatestTotalTokens(0);
     this.savedMessageCount = 0; // Reset saved message count
   }
@@ -297,36 +282,17 @@ export class MessageManager {
   // Initialize state from session data
   public initializeFromSession(sessionData: SessionData): void {
     this.setSessionId(sessionData.id);
+    this.rootSessionId = sessionData.rootSessionId || sessionData.id;
+    this.parentSessionId = sessionData.parentSessionId;
     this.setMessages([...sessionData.messages]);
     this.updateFilesInContext(sessionData.messages);
     this.setlatestTotalTokens(sessionData.metadata.latestTotalTokens);
 
-    // Extract user input history from session messages
-    this.setUserInputHistory(extractUserInputHistory(sessionData.messages));
-
     // Set saved message count to the number of loaded messages since they're already saved
     // This must be done after setSessionId which resets it to 0
     this.savedMessageCount = sessionData.messages.length;
   }
 
-  // Add to input history
-  public addToInputHistory(input: string): void {
-    // Avoid adding duplicate inputs
-    if (
-      this.userInputHistory.length > 0 &&
-      this.userInputHistory[this.userInputHistory.length - 1] === input
-    ) {
-      return;
-    }
-    // Limit history records, keep the latest 100
-    this.setUserInputHistory([...this.userInputHistory, input].slice(-100));
-  }
-
-  // Clear input history
-  public clearInputHistory(): void {
-    this.setUserInputHistory([]);
-  }
-
   // Encapsulated message operation functions
   public addUserMessage(params: UserMessageParams): void {
     const newMessages = addUserMessageToMessages({
@@ -402,17 +368,7 @@ export class MessageManager {
   public updateToolBlock(params: AgentToolBlockUpdateParams): void {
     const newMessages = updateToolBlockInMessage({
       messages: this.messages,
-      id: params.id,
-      parameters: params.parameters,
-      result: params.result,
-      success: params.success,
-      error: params.error,
-      stage: params.stage,
-      name: params.name,
-      shortResult: params.shortResult,
-      images: params.images,
-      compactParams: params.compactParams,
-      parametersChunk: params.parametersChunk,
+      ...params,
     });
     this.setMessages(newMessages);
     this.callbacks.onToolBlockUpdated?.(params);
@@ -442,14 +398,14 @@ export class MessageManager {
   }
 
   /**
-   * Compress messages and update session, delete compressed messages, only keep compressed messages and subsequent messages
+   * Compress messages and update session, delete compressed messages, only keep compressed messages and last 3 messages
    */
   public compressMessagesAndUpdateSession(
-    insertIndex: number,
     compressedContent: string,
     usage?: Usage,
   ): void {
-    const currentMessages = this.messages;
+    // Get last 3 messages to preserve
+    const lastThreeMessages = this.messages.slice(-3);
 
     // Create compressed message
     const compressMessage: Message = {
@@ -464,24 +420,24 @@ export class MessageManager {
       ...(usage && { usage }),
     };
 
-    // Convert negative index to positive index
-    const actualIndex =
-      insertIndex < 0 ? currentMessages.length + insertIndex : insertIndex;
+    // Build new message array: keep the compressed message and last 3 messages
+    const newMessages: Message[] = [compressMessage, ...lastThreeMessages];
 
-    // Build new message array: keep compressed message and all messages from actualIndex onwards
-    const newMessages: Message[] = [
-      compressMessage,
-      ...currentMessages.slice(actualIndex),
-    ];
-
-    // Update sessionId
+    // Update sessionId and parentSessionId
+    const oldSessionId = this.sessionId;
     this.setSessionId(generateSessionId());
+    this.parentSessionId = oldSessionId;
+
+    // Trigger task list update if this is the main session to ensure continuity
+    if (this.sessionType === "main") {
+      this.callbacks.onSessionIdChange?.(this.sessionId);
+    }
 
     // Set new message list
     this.setMessages(newMessages);
 
-    // Trigger compression callback, insertIndex remains unchanged
-    this.callbacks.onCompressBlockAdded?.(insertIndex, compressedContent);
+    // Trigger compression callback
+    this.callbacks.onCompressBlockAdded?.(compressedContent);
   }
 
   public addFileHistoryBlock(
@@ -496,6 +452,7 @@ export class MessageManager {
         snapshots,
       } as unknown as import("../types/index.js").MessageBlock);
       this.setMessages([...this.messages]);
+      this.callbacks.onFileHistoryBlockAdded?.(snapshots);
     }
   }
 
@@ -529,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
    */
@@ -703,6 +608,14 @@ export class MessageManager {
     this.setMessages(newMessages);
   }
 
+  public async getFullMessageThread(): Promise<{
+    messages: Message[];
+    sessionIds: string[];
+  }> {
+    const { loadFullMessageThread } = await import("../services/session.js");
+    return loadFullMessageThread(this.sessionId, this.workdir);
+  }
+
   /**
    * Truncate history to a specific index and revert file changes.
    * @param index - The index of the user message to truncate to.
@@ -712,30 +625,101 @@ export class MessageManager {
     index: number,
     reversionManager?: import("./reversionManager.js").ReversionManager,
   ): Promise<void> {
-    if (index < 0 || index >= this.messages.length) {
+    const { messages, sessionIds } = await this.getFullMessageThread();
+
+    if (index < 0 || index >= messages.length) {
       throw new Error(`Invalid message index: ${index}`);
     }
 
-    // Identify messages to be removed
-    const messagesToRemove = this.messages.slice(index);
+    // Find which session the index belongs to
+    let targetSessionId = this.sessionId;
+    let targetIndexInSession = index;
+
+    // We need to be careful here because loadFullMessageThread might have removed "compress" blocks
+    // Let's re-calculate based on the actual messages returned.
+    // Actually, it's easier to just load sessions one by one again or keep track of counts.
+
+    // For simplicity, let's assume we want to truncate the WHOLE thread.
+    // If the index is in a previous session, we need to:
+    // 1. Load that session.
+    // 2. Truncate it.
+    // 3. Make it the current session.
+    // 4. Delete/Invalidate subsequent sessions.
+
+    // To correctly map 'index' to a session, we need to know the message count of each session
+    // as they appear in the concatenated 'messages' array.
+
+    let remainingIndex = index;
+    const { loadSessionFromJsonl } = await import("../services/session.js");
+
+    for (const sid of sessionIds) {
+      const sessionData = await loadSessionFromJsonl(sid, this.workdir);
+      if (!sessionData) continue;
+
+      const sessionMessages = sessionData.messages;
+      // If this is not the first session in the thread, it might have a compress block at the start
+      // that was removed in getFullMessageThread.
+      const hasCompressBlock = sessionMessages[0]?.blocks.some(
+        (b) => b.type === "compress",
+      );
+      const effectiveMessages =
+        hasCompressBlock && sid !== sessionIds[0]
+          ? sessionMessages.slice(1)
+          : sessionMessages;
+
+      if (remainingIndex < effectiveMessages.length) {
+        targetSessionId = sid;
+        targetIndexInSession = hasCompressBlock
+          ? remainingIndex + 1
+          : remainingIndex;
+        break;
+      }
+      remainingIndex -= effectiveMessages.length;
+    }
+
+    // Load the target session to perform truncation
+    const targetSessionData = await loadSessionFromJsonl(
+      targetSessionId,
+      this.workdir,
+    );
+    if (!targetSessionData)
+      throw new Error(`Target session ${targetSessionId} not found`);
+
+    // Identify messages to be removed (from the whole thread)
+    const messagesToRemove = messages.slice(index);
     const messageIdsToRemove = messagesToRemove
       .map((m) => m.id as string)
       .filter((id) => !!id);
 
     // Revert file changes if manager is provided
     if (reversionManager && messageIdsToRemove.length > 0) {
-      await reversionManager.revertTo(messageIdsToRemove, this.messages);
+      await reversionManager.revertTo(messageIdsToRemove, messages);
     }
 
-    // Truncate messages in memory
-    const newMessages = this.messages.slice(0, index);
-    this.setMessages(newMessages);
+    // Truncate messages in the target session
+    const newMessagesInSession = targetSessionData.messages.slice(
+      0,
+      targetIndexInSession,
+    );
 
-    // Update persistence: rewrite the session file
-    await this.rewriteSessionFile(newMessages);
+    // Update target session file
+    this.sessionId = targetSessionId;
+    this.rootSessionId = targetSessionData.rootSessionId || targetSessionId;
+    this.parentSessionId = targetSessionData.parentSessionId;
+    this.transcriptPath = this.computeTranscriptPath();
+
+    await this.rewriteSessionFile(newMessagesInSession);
+
+    // Update in-memory messages to the truncated session messages
+    // We do NOT include ancestor messages here to avoid exceeding context limits.
+    // The 'compress' block at the start of the session (if any) already summarizes them.
+    this.setMessages(newMessagesInSession);
 
     // Update saved message count
-    this.savedMessageCount = newMessages.length;
+    this.savedMessageCount = newMessagesInSession.length;
+
+    // Notify session ID change if it changed
+    this.callbacks.onSessionIdChange?.(this.sessionId);
   }
 
   /**

package/src/managers/permissionManager.ts

@@ -323,40 +323,30 @@ export class PermissionManager {
             workdir,
           );
           if (!isInside) {
-            this.logger?.warn(
-              "File operation outside the Safe Zone in acceptEdits mode",
+            this.logger?.info(
+              "File operation outside the Safe Zone in acceptEdits mode, falling back to manual confirmation",
               {
                 toolName: context.toolName,
                 targetPath,
                 resolvedPath,
               },
             );
-            return {
-              behavior: "deny",
-              message: `Tool '${context.toolName}' attempted to modify a file outside the Safe Zone: ${targetPath}. Operations outside the Safe Zone always require manual confirmation.`,
-            };
+            // Fall through to normal permission check flow to trigger confirmation prompt
+          } else {
+            this.logger?.debug(
+              "Permission automatically accepted for tool in acceptEdits mode",
+              {
+                toolName: context.toolName,
+              },
+            );
+            return { behavior: "allow" };
           }
         }
-
-        this.logger?.debug(
-          "Permission automatically accepted for tool in acceptEdits mode",
-          {
-            toolName: context.toolName,
-          },
-        );
-        return { behavior: "allow" };
       }
     }
 
     // 1.3 If plan mode, allow Read-only tools and Edit/Write for plan file
     if (context.permissionMode === "plan") {
-      if (context.toolName === BASH_TOOL_NAME) {
-        return {
-          behavior: "deny",
-          message: "Bash commands are not allowed in plan mode.",
-        };
-      }
-
       const writeTools = [
         EDIT_TOOL_NAME,
         MULTI_EDIT_TOOL_NAME,
@@ -492,6 +482,27 @@ export class PermissionManager {
       suggestedPrefix,
     };
 
+    // Set hidePersistentOption for out-of-bounds file operations
+    const fileTools = [
+      EDIT_TOOL_NAME,
+      MULTI_EDIT_TOOL_NAME,
+      DELETE_FILE_TOOL_NAME,
+      WRITE_TOOL_NAME,
+    ];
+    if (fileTools.includes(toolName)) {
+      const targetPath = (toolInput?.file_path || toolInput?.target_file) as
+        | string
+        | undefined;
+      const workdir = toolInput?.workdir as string | undefined;
+
+      if (targetPath) {
+        const { isInside } = this.isInsideSafeZone(targetPath, workdir);
+        if (!isInside) {
+          context.hidePersistentOption = true;
+        }
+      }
+    }
+
     // Set hidePersistentOption for dangerous or out-of-bounds bash commands
     if (toolName === BASH_TOOL_NAME && toolInput?.command) {
       const command = String(toolInput.command);

package/src/managers/planManager.ts

@@ -17,7 +17,7 @@ export class PlanManager {
   /**
    * Ensures the plan directory exists and generates a new plan file path with a random name
    */
-  public async getOrGeneratePlanFilePath(): Promise<{
+  public async getOrGeneratePlanFilePath(seed?: string): Promise<{
     path: string;
     name: string;
   }> {
@@ -30,7 +30,7 @@ export class PlanManager {
       );
       throw error;
     }
-    const name = generateRandomName();
+    const name = generateRandomName(seed);
     const filePath = path.join(this.planDir, `${name}.md`);
     this.logger?.info(`Generated plan file path: ${filePath}`);
     return { path: filePath, name };

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

@@ -1,6 +1,7 @@
 import type { MessageManager } from "./messageManager.js";
 import type { AIManager } from "./aiManager.js";
 import type { BackgroundTaskManager } from "./backgroundTaskManager.js";
+import type { TaskManager } from "../services/taskManager.js";
 import type {
   SlashCommand,
   CustomSlashCommand,
@@ -20,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);
 
@@ -28,6 +29,7 @@ export interface SlashCommandManagerOptions {
   messageManager: MessageManager;
   aiManager: AIManager;
   backgroundTaskManager: BackgroundTaskManager;
+  taskManager: TaskManager;
   workdir: string;
   logger?: Logger;
 }
@@ -38,6 +40,7 @@ export class SlashCommandManager {
   private messageManager: MessageManager;
   private aiManager: AIManager;
   private backgroundTaskManager: BackgroundTaskManager;
+  private taskManager: TaskManager;
   private workdir: string;
   private logger?: Logger;
 
@@ -45,6 +48,7 @@ export class SlashCommandManager {
     this.messageManager = options.messageManager;
     this.aiManager = options.aiManager;
     this.backgroundTaskManager = options.backgroundTaskManager;
+    this.taskManager = options.taskManager;
     this.workdir = options.workdir;
     this.logger = options.logger;
 
@@ -61,8 +65,13 @@ export class SlashCommandManager {
       handler: () => {
         // Clear chat messages
         this.messageManager.clearMessages();
-        // Clear terminal screen
-        process.stdout.write("\x1Bc");
+
+        // Reset task list if WAVE_TASK_LIST_ID is not set
+        if (!process.env.WAVE_TASK_LIST_ID) {
+          const newTaskListId = this.messageManager.getRootSessionId();
+          this.taskManager.setTaskListId(newTaskListId);
+          this.taskManager.emit("tasksChange", newTaskListId);
+        }
       },
     });