wave-agent-sdk 0.4.0 → 0.6.1

package/src/managers/messageManager.ts

@@ -3,7 +3,6 @@ import {
   updateToolBlockInMessage,
   addErrorBlockToMessage,
   addUserMessageToMessages,
-  extractUserInputHistory,
   addCommandOutputMessage,
   updateCommandOutputInMessage,
   completeCommandInMessage,
@@ -26,13 +25,13 @@ 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 {
   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;
@@ -44,7 +43,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,
@@ -57,6 +56,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
@@ -72,6 +72,10 @@ export interface MessageManagerCallbacks {
     subagentId: string,
     status: "active" | "completed" | "error" | "aborted",
   ) => void;
+  onFileHistoryBlockAdded?: (
+    snapshots: import("../types/reversion.js").FileSnapshot[],
+  ) => void;
+  onSubagentTaskStopRequested?: (subagentId: string) => void;
 }
 
 export interface MessageManagerOptions {
@@ -80,14 +84,16 @@ export interface MessageManagerOptions {
   logger?: Logger;
   sessionType?: "main" | "subagent";
   subagentType?: string;
+  memoryRuleManager?: MemoryRuleManager;
 }
 
 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
@@ -95,14 +101,15 @@ 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;
 
   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;
@@ -110,6 +117,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();
@@ -120,6 +128,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];
   }
@@ -128,10 +144,6 @@ export class MessageManager {
     return this.latestTotalTokens;
   }
 
-  public getUserInputHistory(): string[] {
-    return [...this.userInputHistory];
-  }
-
   public getWorkdir(): string {
     return this.workdir;
   }
@@ -151,6 +163,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
@@ -218,6 +254,8 @@ export class MessageManager {
         unsavedMessages, // Only append new messages
         this.workdir,
         this.sessionType,
+        this.rootSessionId,
+        this.parentSessionId,
       );
 
       // Update the saved message count
@@ -235,18 +273,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
   }
@@ -268,36 +301,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({
@@ -373,17 +387,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);
@@ -400,15 +404,27 @@ 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
+   * 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 = {
@@ -423,24 +439,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 compressed message and all messages from actualIndex onwards
-    const newMessages: Message[] = [
-      compressMessage,
-      ...currentMessages.slice(actualIndex),
-    ];
+    // Build new message array: keep the compressed message and last 3 messages
+    const newMessages: Message[] = [compressMessage, ...lastThreeMessages];
 
-    // 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(
@@ -455,6 +471,7 @@ export class MessageManager {
         snapshots,
       } as unknown as import("../types/index.js").MessageBlock);
       this.setMessages([...this.messages]);
+      this.callbacks.onFileHistoryBlockAdded?.(snapshots);
     }
   }
 
@@ -494,12 +511,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 +526,7 @@ export class MessageManager {
       sessionId,
       status,
       configuration,
+      runInBackground,
     };
     const updatedMessages = addSubagentBlockToMessage(params);
     this.setMessages(updatedMessages);
@@ -519,6 +538,7 @@ export class MessageManager {
     updates: Partial<{
       status: "active" | "completed" | "error" | "aborted";
       sessionId: string;
+      runInBackground: boolean;
     }>,
   ): void {
     const updatedMessages = updateSubagentBlockInMessage(
@@ -532,7 +552,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);
+    }
   }
 
   /**
@@ -657,6 +679,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.
@@ -666,30 +696,110 @@ 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,
+    );
+
+    // 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 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

@@ -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);
   }
 
   /**
@@ -329,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,
@@ -498,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/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,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,
@@ -26,6 +28,8 @@ const execAsync = promisify(exec);
 export interface SlashCommandManagerOptions {
   messageManager: MessageManager;
   aiManager: AIManager;
+  backgroundTaskManager: BackgroundTaskManager;
+  taskManager: TaskManager;
   workdir: string;
   logger?: Logger;
 }
@@ -35,12 +39,16 @@ export class SlashCommandManager {
   private customCommands = new Map<string, CustomSlashCommand>();
   private messageManager: MessageManager;
   private aiManager: AIManager;
+  private backgroundTaskManager: BackgroundTaskManager;
+  private taskManager: TaskManager;
   private workdir: string;
   private logger?: Logger;
 
   constructor(options: SlashCommandManagerOptions) {
     this.messageManager = options.messageManager;
     this.aiManager = options.aiManager;
+    this.backgroundTaskManager = options.backgroundTaskManager;
+    this.taskManager = options.taskManager;
     this.workdir = options.workdir;
     this.logger = options.logger;
 
@@ -57,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);
+        }
       },
     });