wave-agent-sdk 0.2.1 → 0.5.0

package/src/managers/messageManager.ts

@@ -4,7 +4,6 @@ import {
   addErrorBlockToMessage,
   addUserMessageToMessages,
   extractUserInputHistory,
-  addMemoryBlockToMessage,
   addCommandOutputMessage,
   updateCommandOutputInMessage,
   completeCommandInMessage,
@@ -17,7 +16,7 @@ import {
   type AgentToolBlockUpdateParams,
 } from "../utils/messageOperations.js";
 import type { SubagentConfiguration } from "../utils/subagentParser.js";
-import type { Logger, Message, Usage } from "../types/index.js";
+import type { Logger, Message, Usage, SlashCommand } from "../types/index.js";
 import { join } from "path";
 import {
   appendMessages,
@@ -27,6 +26,7 @@ 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 {
@@ -57,6 +57,10 @@ export interface MessageManagerCallbacks {
   onAddCommandOutputMessage?: (command: string) => void;
   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
   onSubAgentBlockAdded?: (
     subagentId: string,
@@ -78,6 +82,7 @@ export interface MessageManagerOptions {
   logger?: Logger;
   sessionType?: "main" | "subagent";
   subagentType?: string;
+  memoryRuleManager?: MemoryRuleManager;
 }
 
 export class MessageManager {
@@ -93,6 +98,7 @@ 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;
 
@@ -108,6 +114,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();
@@ -149,6 +156,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
@@ -249,6 +280,20 @@ export class MessageManager {
     this.savedMessageCount = 0; // Reset saved message count
   }
 
+  /**
+   * Trigger the rewind UI callback
+   */
+  public triggerShowRewind(): void {
+    this.callbacks.onShowRewind?.();
+  }
+
+  /**
+   * Trigger slash commands change callback
+   */
+  public triggerSlashCommandsChange(commands: SlashCommand[]): void {
+    this.callbacks.onSlashCommandsChange?.(commands);
+  }
+
   // Initialize state from session data
   public initializeFromSession(sessionData: SessionData): void {
     this.setSessionId(sessionData.id);
@@ -384,6 +429,18 @@ 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
    */
@@ -427,21 +484,19 @@ export class MessageManager {
     this.callbacks.onCompressBlockAdded?.(insertIndex, compressedContent);
   }
 
-  public addMemoryBlock(
-    content: string,
-    success: boolean,
-    type: "project" | "user",
-    storagePath: string,
+  public addFileHistoryBlock(
+    snapshots: import("../types/reversion.js").FileSnapshot[],
   ): void {
-    const newMessages = addMemoryBlockToMessage({
-      messages: this.messages,
-      content,
-      isSuccess: success,
-      memoryType: type,
-      storagePath,
-    });
-    this.setMessages(newMessages);
-    this.callbacks.onMemoryBlockAdded?.(content, success, type, storagePath);
+    if (snapshots.length === 0) return;
+
+    const lastMessage = this.messages[this.messages.length - 1];
+    if (lastMessage && lastMessage.role === "assistant") {
+      lastMessage.blocks.push({
+        type: "file_history",
+        snapshots,
+      } as unknown as import("../types/index.js").MessageBlock);
+      this.setMessages([...this.messages]);
+    }
   }
 
   // Bash command related message operations
@@ -480,12 +535,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,
@@ -494,6 +550,7 @@ export class MessageManager {
       sessionId,
       status,
       configuration,
+      runInBackground,
     };
     const updatedMessages = addSubagentBlockToMessage(params);
     this.setMessages(updatedMessages);
@@ -505,6 +562,7 @@ export class MessageManager {
     updates: Partial<{
       status: "active" | "completed" | "error" | "aborted";
       sessionId: string;
+      runInBackground: boolean;
     }>,
   ): void {
     const updatedMessages = updateSubagentBlockInMessage(
@@ -518,7 +576,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);
+    }
   }
 
   /**
@@ -643,6 +703,64 @@ export class MessageManager {
     this.setMessages(newMessages);
   }
 
+  /**
+   * Truncate history to a specific index and revert file changes.
+   * @param index - The index of the user message to truncate to.
+   * @param reversionManager - Optional ReversionManager to handle file rollbacks.
+   */
+  public async truncateHistory(
+    index: number,
+    reversionManager?: import("./reversionManager.js").ReversionManager,
+  ): Promise<void> {
+    if (index < 0 || index >= this.messages.length) {
+      throw new Error(`Invalid message index: ${index}`);
+    }
+
+    // Identify messages to be removed
+    const messagesToRemove = this.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);
+    }
+
+    // Truncate messages in memory
+    const newMessages = this.messages.slice(0, index);
+    this.setMessages(newMessages);
+
+    // Update persistence: rewrite the session file
+    await this.rewriteSessionFile(newMessages);
+
+    // Update saved message count
+    this.savedMessageCount = newMessages.length;
+  }
+
+  /**
+   * Rewrite the session file with the current messages.
+   */
+  private async rewriteSessionFile(messages: Message[]): Promise<void> {
+    try {
+      const { writeFile } = await import("fs/promises");
+
+      const sessionMessages: import("../types/session.js").SessionMessage[] =
+        messages.map((message) => ({
+          ...message,
+          timestamp: new Date().toISOString(),
+        }));
+
+      const content =
+        sessionMessages.map((m) => JSON.stringify(m)).join("\n") +
+        (sessionMessages.length > 0 ? "\n" : "");
+
+      await writeFile(this.transcriptPath, content, "utf8");
+    } catch (error) {
+      this.logger?.error("Failed to rewrite session file:", error);
+    }
+  }
+
   /**
    * Updates the set of files mentioned in the conversation.
    */

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);
   }
 
   /**
@@ -558,7 +552,7 @@ export class PermissionManager {
       return true;
     }
 
-    // 2. Tool with pattern match (e.g., "Bash(rm:*)", "Read(**/*.env)")
+    // 2. Tool with pattern match (e.g., "Bash(rm *)", "Read(**/*.env)")
     const match = rule.match(/^(\w+)\((.*)\)$/);
     if (!match) {
       return false;
@@ -573,10 +567,14 @@ export class PermissionManager {
     if (toolName === BASH_TOOL_NAME) {
       const command = String(context.toolInput?.command || "");
       const processedPart = stripRedirections(stripEnvVars(command));
-      if (pattern.endsWith(":*")) {
-        return processedPart.startsWith(pattern.slice(0, -2));
-      }
-      return processedPart === pattern;
+      // For Bash commands, we want '*' to match everything including slashes and spaces
+      // minimatch's default behavior for '*' is to not match across directory separators
+      // We use a regex to replace '*' with '.*' (match anything)
+      const regexPattern = pattern
+        .replace(/[.+^${}()|[\]\\?]/g, "\\$&") // Escape regex special chars including ?
+        .replace(/\*/g, ".*"); // Replace * with .*
+      const regex = new RegExp(`^${regexPattern}$`);
+      return regex.test(processedPart);
     }
 
     // Handle path-based rules (e.g., "Read(**/*.env)")
@@ -768,7 +766,7 @@ export class PermissionManager {
 
         const smartPrefix = getSmartPrefix(processedPart);
         if (smartPrefix) {
-          rules.push(`Bash(${smartPrefix}:*)`);
+          rules.push(`Bash(${smartPrefix}*)`);
         } else {
           rules.push(`Bash(${processedPart})`);
         }

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

@@ -1,6 +1,7 @@
 import { ConfigurationService } from "../services/configurationService.js";
 import { PluginManager } from "./pluginManager.js";
 import { Logger } from "../types/index.js";
+import { Scope } from "../types/configuration.js";
 
 export interface PluginScopeManagerOptions {
   workdir: string;
@@ -25,10 +26,7 @@ export class PluginScopeManager {
   /**
    * Enable a plugin in the specified scope
    */
-  async enablePlugin(
-    scope: "user" | "project" | "local",
-    pluginId: string,
-  ): Promise<void> {
+  async enablePlugin(scope: Scope, pluginId: string): Promise<void> {
     await this.configurationService.updateEnabledPlugin(
       this.workdir,
       scope,
@@ -42,10 +40,7 @@ export class PluginScopeManager {
   /**
    * Disable a plugin in the specified scope
    */
-  async disablePlugin(
-    scope: "user" | "project" | "local",
-    pluginId: string,
-  ): Promise<void> {
+  async disablePlugin(scope: Scope, pluginId: string): Promise<void> {
     await this.configurationService.updateEnabledPlugin(
       this.workdir,
       scope,
@@ -63,6 +58,60 @@ export class PluginScopeManager {
     return this.configurationService.getMergedEnabledPlugins(this.workdir);
   }
 
+  /**
+   * Find the scope where a plugin is currently enabled/disabled.
+   * Priority: local > project > user
+   */
+  findPluginScope(pluginId: string): Scope | null {
+    const projectPaths = this.configurationService.getConfigurationPaths(
+      this.workdir,
+    ).projectPaths; // [local, json]
+    const userPaths = this.configurationService.getConfigurationPaths(
+      this.workdir,
+    ).userPaths; // [local, json]
+
+    const checkPaths: { path: string; scope: Scope }[] = [
+      { path: projectPaths[0], scope: "local" },
+      { path: projectPaths[1], scope: "project" },
+      { path: userPaths[0], scope: "user" }, // user local is still user scope
+      { path: userPaths[1], scope: "user" },
+    ];
+
+    for (const { path, scope } of checkPaths) {
+      const config = this.configurationService.loadWaveConfigFromFile(path);
+      if (config?.enabledPlugins && pluginId in config.enabledPlugins) {
+        return scope;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Remove a plugin from all scopes (user, project, local)
+   * This is useful when uninstalling a plugin to clean up all configuration
+   */
+  async removePluginFromAllScopes(pluginId: string): Promise<void> {
+    const scopes: Scope[] = ["user", "project", "local"];
+
+    for (const scope of scopes) {
+      try {
+        await this.configurationService.removeEnabledPlugin(
+          this.workdir,
+          scope,
+          pluginId,
+        );
+      } catch (error) {
+        // Continue removing from other scopes even if one fails
+        this.logger?.warn(
+          `Failed to remove plugin ${pluginId} from ${scope} scope: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
+    }
+
+    this.refreshPluginManager();
+  }
+
   /**
    * Refresh the plugin manager with the latest configuration
    * Note: This only updates the configuration, it doesn't reload plugins.

package/src/managers/reversionManager.ts

@@ -0,0 +1,152 @@
+import fs from "fs/promises";
+import { FileSnapshot } from "../types/reversion.js";
+import { ReversionService } from "../services/reversionService.js";
+
+export class ReversionManager {
+  private buffer: Map<string, FileSnapshot> = new Map();
+  private reversionService: ReversionService;
+
+  constructor(reversionService: ReversionService) {
+    this.reversionService = reversionService;
+  }
+
+  /**
+   * Records the current state of a file into a temporary buffer.
+   * Returns a snapshotId.
+   */
+  async recordSnapshot(
+    messageId: string,
+    filePath: string,
+    operation: "create" | "modify" | "delete",
+  ): Promise<string> {
+    let content: string | null = null;
+    try {
+      content = await fs.readFile(filePath, "utf-8");
+    } catch {
+      // File doesn't exist, which is expected for 'create' operation
+    }
+
+    const snapshot: FileSnapshot = {
+      messageId,
+      filePath,
+      timestamp: Date.now(),
+      operation,
+    };
+
+    // We temporarily store the content in the buffer, it will be saved to disk on commit
+    const snapshotId = `${messageId}-${filePath}-${snapshot.timestamp}`;
+    this.buffer.set(snapshotId, { ...snapshot, content } as FileSnapshot & {
+      content: string | null;
+    });
+    return snapshotId;
+  }
+
+  /**
+   * Records the current state of a file into a temporary buffer.
+   * Returns a snapshotId.
+   */
+  async recordSnapshotWithId(
+    messageId: string,
+    filePath: string,
+    operation: "create" | "modify" | "delete",
+  ): Promise<string> {
+    return this.recordSnapshot(messageId, filePath, operation);
+  }
+
+  /**
+   * Moves the buffered snapshot to the permanent session log.
+   * Called only if the tool succeeds.
+   */
+  async commitSnapshot(snapshotId: string): Promise<void> {
+    const snapshotWithContent = this.buffer.get(snapshotId) as FileSnapshot & {
+      content: string | null;
+    };
+    if (snapshotWithContent) {
+      const { content, ...snapshot } = snapshotWithContent;
+      const snapshotPath = await this.reversionService.saveSnapshot({
+        ...snapshot,
+        content,
+      } as FileSnapshot);
+      snapshot.snapshotPath = snapshotPath;
+      this.buffer.delete(snapshotId);
+
+      // We need to return the snapshot so it can be added to the message block
+      // But the current API doesn't support it.
+      // Let's store committed snapshots in another buffer for the current turn.
+      this.committedSnapshots.push(snapshot);
+    }
+  }
+
+  private committedSnapshots: FileSnapshot[] = [];
+
+  /**
+   * Gets and clears committed snapshots for the current turn.
+   */
+  getAndClearCommittedSnapshots(): FileSnapshot[] {
+    const snapshots = [...this.committedSnapshots];
+    this.committedSnapshots = [];
+    return snapshots;
+  }
+
+  /**
+   * Discards the buffered snapshot.
+   * Called if the tool fails.
+   */
+  discardSnapshot(snapshotId: string): void {
+    this.buffer.delete(snapshotId);
+  }
+
+  /**
+   * Reverts all file changes associated with messages from the end of history
+   * down to (and including) the specified message index.
+   * This should be called by MessageManager.
+   */
+  async revertTo(
+    messageIds: string[],
+    allMessages: import("../types/index.js").Message[],
+  ): Promise<number> {
+    const messageIdSet = new Set(messageIds);
+    const snapshots: FileSnapshot[] = [];
+
+    for (const message of allMessages) {
+      if (message.id && messageIdSet.has(message.id)) {
+        const historyBlock = message.blocks.find(
+          (b) => b.type === "file_history",
+        ) as { type: "file_history"; snapshots: FileSnapshot[] } | undefined;
+        if (historyBlock && historyBlock.snapshots) {
+          snapshots.push(...historyBlock.snapshots);
+        }
+      }
+    }
+
+    // Revert in reverse chronological order (LIFO)
+    const sortedSnapshots = snapshots.sort((a, b) => b.timestamp - a.timestamp);
+
+    let revertedCount = 0;
+    for (const snapshot of sortedSnapshots) {
+      try {
+        if (!snapshot.snapshotPath) {
+          // File didn't exist before, so delete it
+          await fs.rm(snapshot.filePath, { force: true });
+        } else {
+          // Restore previous content
+          const content = await this.reversionService.readSnapshotContent(
+            snapshot.snapshotPath,
+          );
+          if (content !== null) {
+            await fs.writeFile(snapshot.filePath, content, "utf-8");
+          } else {
+            // If snapshotPath exists but content is null, it means the file should be deleted
+            // (This handles the case where snapshotPath was set but content was null in saveSnapshot)
+            await fs.rm(snapshot.filePath, { force: true });
+          }
+        }
+        revertedCount++;
+      } catch (error) {
+        console.error(`Failed to revert file ${snapshot.filePath}:`, error);
+      }
+    }
+
+    return revertedCount;
+  }
+}

package/src/managers/slashCommandManager.ts

@@ -1,5 +1,6 @@
 import type { MessageManager } from "./messageManager.js";
 import type { AIManager } from "./aiManager.js";
+import type { BackgroundTaskManager } from "./backgroundTaskManager.js";
 import type {
   SlashCommand,
   CustomSlashCommand,
@@ -26,6 +27,7 @@ const execAsync = promisify(exec);
 export interface SlashCommandManagerOptions {
   messageManager: MessageManager;
   aiManager: AIManager;
+  backgroundTaskManager: BackgroundTaskManager;
   workdir: string;
   logger?: Logger;
 }
@@ -35,12 +37,14 @@ export class SlashCommandManager {
   private customCommands = new Map<string, CustomSlashCommand>();
   private messageManager: MessageManager;
   private aiManager: AIManager;
+  private backgroundTaskManager: BackgroundTaskManager;
   private workdir: string;
   private logger?: Logger;
 
   constructor(options: SlashCommandManagerOptions) {
     this.messageManager = options.messageManager;
     this.aiManager = options.aiManager;
+    this.backgroundTaskManager = options.backgroundTaskManager;
     this.workdir = options.workdir;
     this.logger = options.logger;
 
@@ -104,15 +108,24 @@ export class SlashCommandManager {
           handler: async (args?: string) => {
             // Substitute parameters in the command content
             let processedContent = command.content;
+
+            // Substitute $WAVE_PLUGIN_ROOT placeholder for plugin commands
+            if (command.pluginPath) {
+              processedContent = processedContent.replace(
+                /\$WAVE_PLUGIN_ROOT/g,
+                command.pluginPath,
+              );
+            }
+
             if (args) {
-              if (hasParameterPlaceholders(command.content)) {
+              if (hasParameterPlaceholders(processedContent)) {
                 processedContent = substituteCommandParameters(
-                  command.content,
+                  processedContent,
                   args,
                 );
               } else {
                 // If no placeholders, append arguments to the content
-                processedContent = `${command.content.trim()} ${args}`;
+                processedContent = `${processedContent.trim()} ${args}`;
               }
             }
 
@@ -158,15 +171,24 @@ export class SlashCommandManager {
         handler: async (args?: string) => {
           // Substitute parameters in the command content
           let processedContent = command.content;
+
+          // Substitute $WAVE_PLUGIN_ROOT placeholder for plugin commands
+          if (command.pluginPath) {
+            processedContent = processedContent.replace(
+              /\$WAVE_PLUGIN_ROOT/g,
+              command.pluginPath,
+            );
+          }
+
           if (args) {
-            if (hasParameterPlaceholders(command.content)) {
+            if (hasParameterPlaceholders(processedContent)) {
               processedContent = substituteCommandParameters(
-                command.content,
+                processedContent,
                 args,
               );
             } else {
               // If no placeholders, append arguments to the content
-              processedContent = `${command.content.trim()} ${args}`;
+              processedContent = `${processedContent.trim()} ${args}`;
             }
           }
 
@@ -202,8 +224,9 @@ export class SlashCommandManager {
   /**
    * Register new command
    */
-  private registerCommand(command: SlashCommand): void {
+  public registerCommand(command: SlashCommand): void {
     this.commands.set(command.id, command);
+    this.messageManager.triggerSlashCommandsChange(this.getCommands());
   }
 
   /**