wave-agent-sdk 0.7.1 → 0.8.0

package/src/services/initializationService.ts

@@ -0,0 +1,291 @@
+import path from "path";
+import * as fs from "fs/promises";
+import os from "os";
+import { handleSessionRestoration } from "./session.js";
+import { setGlobalLogger } from "../utils/globalLogger.js";
+import { LspManager } from "../managers/lspManager.js";
+import type {
+  Message,
+  Logger,
+  AgentOptions,
+  ILspManager,
+} from "../types/index.js";
+import type { SkillManager } from "../managers/skillManager.js";
+import type { SubagentManager } from "../managers/subagentManager.js";
+import type { Container } from "../utils/container.js";
+import type { ToolManager } from "../managers/toolManager.js";
+import type { PluginManager } from "../managers/pluginManager.js";
+import type { SlashCommandManager } from "../managers/slashCommandManager.js";
+import type { McpManager } from "../managers/mcpManager.js";
+import type { ConfigurationService } from "./configurationService.js";
+import type { HookManager } from "../managers/hookManager.js";
+import type { MessageManager } from "../managers/messageManager.js";
+import type { MemoryRuleManager } from "../managers/MemoryRuleManager.js";
+import type { LiveConfigManager } from "../managers/liveConfigManager.js";
+import type { TaskManager } from "./taskManager.js";
+import type { PermissionManager } from "../managers/permissionManager.js";
+
+export interface InitializationContext {
+  skillManager: SkillManager;
+  subagentManager: SubagentManager;
+  container: Container;
+  toolManager: ToolManager;
+  pluginManager: PluginManager;
+  options: AgentOptions;
+  slashCommandManager: SlashCommandManager;
+  logger?: Logger;
+  mcpManager: McpManager;
+  workdir: string;
+  lspManager: ILspManager;
+  configurationService: ConfigurationService;
+  hookManager: HookManager;
+  messageManager: MessageManager;
+  memoryRuleManager: MemoryRuleManager;
+  liveConfigManager: LiveConfigManager;
+  taskManager: TaskManager;
+  setProjectMemory: (content: string) => void;
+  setUserMemory: (content: string) => void;
+  resolveAndValidateConfig: () => void;
+}
+
+export class InitializationService {
+  public static async initialize(
+    context: InitializationContext,
+    options?: {
+      restoreSessionId?: string;
+      continueLastSession?: boolean;
+      messages?: Message[];
+    },
+  ): Promise<void> {
+    const {
+      skillManager,
+      subagentManager,
+      container,
+      toolManager,
+      pluginManager,
+      options: agentOptions,
+      slashCommandManager,
+      logger,
+      mcpManager,
+      workdir,
+      lspManager,
+      configurationService,
+      hookManager,
+      messageManager,
+      memoryRuleManager,
+      liveConfigManager,
+      taskManager,
+      setProjectMemory,
+      setUserMemory,
+      resolveAndValidateConfig,
+    } = context;
+
+    // Initialize managers first
+    try {
+      // Initialize SkillManager
+      await skillManager.initialize();
+
+      // Initialize SubagentManager (load and cache configurations)
+      await subagentManager.initialize();
+
+      // Register managers in container for tool access
+      container.register("SubagentManager", subagentManager);
+      container.register("SkillManager", skillManager);
+
+      // Initialize built-in tools
+      toolManager.initializeBuiltInTools();
+
+      // Initialize plugins
+      await pluginManager.loadPlugins(agentOptions.plugins || []);
+
+      // Register skill commands
+      slashCommandManager.registerSkillCommands(
+        skillManager.getAvailableSkills(),
+      );
+    } catch (error) {
+      logger?.error("Failed to initialize managers and tools:", error);
+      // Don't throw error to prevent app startup failure
+    }
+
+    // Initialize MCP servers with auto-connect
+    try {
+      await mcpManager.initialize(workdir, true);
+      if (lspManager instanceof LspManager) {
+        await lspManager.initialize(workdir);
+      }
+    } catch (error) {
+      logger?.error("Failed to initialize MCP servers:", error);
+      // Don't throw error to prevent app startup failure
+    }
+
+    // Initialize hooks configuration
+    try {
+      // Load hooks configuration using ConfigurationService
+      logger?.debug("Loading hooks configuration...");
+      const configResult =
+        await configurationService.loadMergedConfiguration(workdir);
+
+      hookManager.loadConfigurationFromWaveConfig(configResult.configuration);
+
+      // Update plugin manager with enabled plugins configuration
+      if (configResult.configuration?.enabledPlugins) {
+        pluginManager.updateEnabledPlugins(
+          configResult.configuration.enabledPlugins,
+        );
+      }
+
+      // Initialize permission manager with loaded rules
+      if (configResult.configuration?.permissions) {
+        const permissionManager =
+          context.container.get<PermissionManager>("PermissionManager");
+        if (permissionManager) {
+          if (configResult.configuration.permissions.allow) {
+            permissionManager.updateAllowedRules(
+              configResult.configuration.permissions.allow,
+            );
+          }
+          if (configResult.configuration.permissions.deny) {
+            permissionManager.updateDeniedRules(
+              configResult.configuration.permissions.deny,
+            );
+          }
+          if (configResult.configuration.permissions.defaultMode) {
+            permissionManager.updateConfiguredDefaultMode(
+              configResult.configuration.permissions.defaultMode,
+            );
+          }
+        }
+      }
+
+      logger?.debug("Hooks system initialized successfully");
+    } catch (error) {
+      logger?.error("Failed to initialize hooks system:", error);
+      // Don't throw error to prevent app startup failure
+    }
+
+    // Trigger WorktreeCreate hook if this is a new worktree
+    if (agentOptions.isNewWorktree && hookManager) {
+      try {
+        logger?.info(
+          `Triggering WorktreeCreate hook for ${agentOptions.worktreeName}...`,
+        );
+        const hookResults = await hookManager.executeHooks("WorktreeCreate", {
+          event: "WorktreeCreate",
+          projectDir: workdir,
+          timestamp: new Date(),
+          sessionId: messageManager.getSessionId(),
+          transcriptPath: messageManager.getTranscriptPath(),
+          cwd: workdir,
+          worktreeName: agentOptions.worktreeName,
+          env: configurationService.getEnvironmentVars(),
+        });
+
+        // Process hook results
+        hookManager.processHookResults(
+          "WorktreeCreate",
+          hookResults,
+          messageManager,
+        );
+      } catch (error) {
+        logger?.warn("WorktreeCreate hooks execution failed:", error);
+      }
+    }
+
+    // Resolve and validate configuration after loading settings.json
+    resolveAndValidateConfig();
+
+    // Set global logger for SDK-wide access before discovering rules
+    setGlobalLogger(logger || null);
+
+    // Discover modular memory rules
+    try {
+      await memoryRuleManager.discoverRules();
+    } catch (error) {
+      logger?.error("Failed to discover memory rules:", error);
+    }
+
+    // Initialize live configuration reload
+    try {
+      logger?.debug("Initializing live configuration reload...");
+      await liveConfigManager.initialize();
+      logger?.debug("Live configuration reload initialized successfully");
+    } catch (error) {
+      logger?.error("Failed to initialize live configuration reload:", error);
+      // Don't throw error to prevent app startup failure - continue without live reload
+    }
+
+    // Load memory files during initialization
+    try {
+      logger?.debug("Loading memory files...");
+
+      // Load project memory from AGENTS.md (bypass memory store for direct file access)
+      try {
+        const projectMemoryPath = path.join(workdir, "AGENTS.md");
+        const projectMemoryContent = await fs.readFile(
+          projectMemoryPath,
+          "utf-8",
+        );
+        setProjectMemory(projectMemoryContent);
+        logger?.debug("Project memory loaded successfully");
+      } catch (error) {
+        setProjectMemory("");
+        logger?.debug(
+          "Project memory file not found or unreadable, using empty content:",
+          error instanceof Error ? error.message : String(error),
+        );
+      }
+
+      // Load user memory (bypass memory store for direct file access)
+      try {
+        const userMemoryPath = path.join(os.homedir(), ".wave", "AGENTS.md");
+        const userMemoryContent = await fs.readFile(userMemoryPath, "utf-8");
+        setUserMemory(userMemoryContent);
+        logger?.debug("User memory loaded successfully");
+      } catch (error) {
+        setUserMemory("");
+        logger?.debug(
+          "User memory file not found or unreadable, using empty content:",
+          error instanceof Error ? error.message : String(error),
+        );
+      }
+
+      logger?.debug("Memory initialization completed");
+    } catch (error) {
+      // Ensure memory is always initialized even if loading fails
+      setProjectMemory("");
+      setUserMemory("");
+      logger?.error("Failed to load memory files:", error);
+      // Don't throw error to prevent app startup failure
+    }
+
+    // Handle session restoration or set provided messages
+    if (options?.messages) {
+      // If messages are provided, use them directly (useful for testing)
+      messageManager.setMessages(options.messages);
+      // Rebuild usage array from restored messages
+      messageManager.rebuildUsageFromMessages(options.messages);
+    } else {
+      // Otherwise, handle session restoration
+      const sessionToRestore = await handleSessionRestoration(
+        options?.restoreSessionId,
+        options?.continueLastSession,
+        messageManager.getWorkdir(),
+      );
+      // Rebuild usage array from restored messages
+      messageManager.rebuildUsageFromMessages(sessionToRestore?.messages || []);
+
+      if (sessionToRestore) {
+        messageManager.initializeFromSession(sessionToRestore);
+
+        // Update task manager with the root session ID to ensure continuity across compressions
+        taskManager.setTaskListId(
+          sessionToRestore.rootSessionId || sessionToRestore.id,
+        );
+
+        // After session is initialized, load tasks for the session
+        const tasks = await taskManager.listTasks();
+        agentOptions.callbacks?.onTasksChange?.(tasks);
+      }
+    }
+  }
+}

package/src/services/interactionService.ts

@@ -0,0 +1,171 @@
+import { loadSessionFromJsonl } from "./session.js";
+import type { Logger, AgentOptions } from "../types/index.js";
+import type { MessageManager } from "../managers/messageManager.js";
+import type { SlashCommandManager } from "../managers/slashCommandManager.js";
+import type { HookManager } from "../managers/hookManager.js";
+import type { ConfigurationService } from "./configurationService.js";
+import type { AIManager } from "../managers/aiManager.js";
+import type { SubagentManager } from "../managers/subagentManager.js";
+import type { TaskManager } from "./taskManager.js";
+
+export interface InteractionContext {
+  messageManager: MessageManager;
+  slashCommandManager: SlashCommandManager;
+  hookManager: HookManager;
+  workdir: string;
+  configurationService: ConfigurationService;
+  logger?: Logger;
+  aiManager: AIManager;
+  subagentManager: SubagentManager;
+  taskManager: TaskManager;
+  options: AgentOptions;
+  abortMessage: () => void;
+}
+
+export class InteractionService {
+  public static async sendMessage(
+    context: InteractionContext,
+    content: string,
+    images?: Array<{ path: string; mimeType: string }>,
+  ): Promise<void> {
+    const {
+      messageManager,
+      slashCommandManager,
+      hookManager,
+      workdir,
+      configurationService,
+      logger,
+      aiManager,
+    } = context;
+
+    try {
+      // Handle slash command - check if it's a slash command (starts with /)
+      if (content.startsWith("/")) {
+        const command = content.trim();
+        if (!command || command === "/") return;
+
+        // Parse and validate slash command
+        const { isValid, commandId, args } =
+          slashCommandManager.parseAndValidateSlashCommand(command);
+
+        if (isValid && commandId !== undefined) {
+          // Execute valid slash command
+          await slashCommandManager.executeCommand(commandId, args);
+
+          return;
+        }
+
+        // If command doesn't exist, continue as normal message processing
+        // Don't add to history, let normal message processing logic below handle it
+      }
+
+      // Handle normal AI message
+      // Add user message first, will automatically sync to UI
+      messageManager.addUserMessage({
+        content,
+        images: images?.map((img) => ({
+          path: img.path,
+          mimeType: img.mimeType,
+        })),
+      });
+
+      // Execute UserPromptSubmit hooks after adding the user message
+      if (hookManager) {
+        try {
+          const hookResults = await hookManager.executeHooks(
+            "UserPromptSubmit",
+            {
+              event: "UserPromptSubmit",
+              projectDir: workdir,
+              timestamp: new Date(),
+              // UserPromptSubmit doesn't need toolName
+              sessionId: messageManager.getSessionId(),
+              transcriptPath: messageManager.getTranscriptPath(),
+              cwd: workdir,
+              userPrompt: content,
+              env: configurationService.getEnvironmentVars(), // Include configuration environment variables
+            },
+          );
+
+          // Process hook results and determine if we should continue
+          const processResult = hookManager.processHookResults(
+            "UserPromptSubmit",
+            hookResults,
+            messageManager,
+          );
+
+          // If hook processing indicates we should block (exit code 2), stop here
+          if (processResult.shouldBlock) {
+            logger?.info(
+              "UserPromptSubmit hook blocked prompt processing with error:",
+              processResult.errorMessage,
+            );
+            return; // Don't send to AI
+          }
+        } catch (error) {
+          logger?.warn("UserPromptSubmit hooks execution failed:", error);
+          // Continue processing even if hooks fail
+        }
+      }
+
+      // Send AI message
+      await aiManager.sendAIMessage();
+    } catch (error) {
+      console.error("Failed to add user message:", error);
+      // Loading state will be automatically updated by the useEffect that watches messages
+    }
+  }
+
+  public static async restoreSession(
+    context: InteractionContext,
+    sessionId: string,
+  ): Promise<void> {
+    const {
+      messageManager,
+      logger,
+      subagentManager,
+      taskManager,
+      options,
+      abortMessage,
+    } = context;
+
+    // 1. Validation
+    if (!sessionId || sessionId === messageManager.getSessionId()) {
+      return; // No-op if session ID is invalid or already current
+    }
+
+    // 2. Auto-save current session
+    try {
+      await messageManager.saveSession();
+    } catch (error) {
+      logger?.warn("Failed to save current session before restore:", error);
+      // Continue with restoration even if save fails
+    }
+
+    // 3. Load target session
+    const sessionData = await loadSessionFromJsonl(
+      sessionId,
+      messageManager.getWorkdir(),
+    );
+    if (!sessionData) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    // 4. Clean current state
+    abortMessage(); // Abort any running operations
+    subagentManager.cleanup(); // Clean up active subagents
+
+    // 5. Rebuild usage (in correct order)
+    messageManager.rebuildUsageFromMessages(sessionData.messages);
+
+    // 6. Initialize session state last
+    messageManager.initializeFromSession(sessionData);
+
+    // Update task manager with the root session ID to ensure continuity across compressions
+    taskManager.setTaskListId(sessionData.rootSessionId || sessionData.id);
+
+    // 7. Load tasks for the restored session
+    const tasks = await taskManager.listTasks();
+    options.callbacks?.onTasksChange?.(tasks);
+  }
+}

package/src/services/session.ts

@@ -768,7 +768,7 @@ export async function getFirstMessageContent(
       }
 
       const commandBlock = message.blocks.find(
-        (block) => block.type === "command_output",
+        (block) => block.type === "bang",
       );
       if (commandBlock && "command" in commandBlock) {
         return commandBlock.command;

package/src/services/taskManager.ts

@@ -5,6 +5,7 @@ import { EventEmitter } from "events";
 import { Task } from "../types/tasks.js";
 import { logger } from "../utils/globalLogger.js";
 import { Container } from "../utils/container.js";
+import type { MessageManager } from "../managers/messageManager.js";
 
 export class TaskManager extends EventEmitter {
   private readonly baseDir: string;
@@ -27,6 +28,21 @@ export class TaskManager extends EventEmitter {
     this.taskListId = taskListId;
   }
 
+  /**
+   * Syncs the task list ID with the current session's root session ID.
+   * This is typically called when the session is cleared or compressed.
+   */
+  public async syncWithSession(): Promise<void> {
+    const messageManager = this.container.get<MessageManager>("MessageManager");
+    if (!messageManager) return;
+
+    const rootSessionId = messageManager.getRootSessionId();
+    if (this.taskListId !== rootSessionId && !process.env.WAVE_TASK_LIST_ID) {
+      this.setTaskListId(rootSessionId);
+      await this.refreshTasks();
+    }
+  }
+
   private getSessionDir(): string {
     return join(this.baseDir, this.taskListId);
   }
@@ -110,7 +126,7 @@ export class TaskManager extends EventEmitter {
       const content = JSON.stringify(fullTask, null, 2);
       await fs.writeFile(taskPath, content, "utf8");
       this.emit("tasksChange", this.taskListId);
-      logger.info(`Task ${taskId} created in task list ${this.taskListId}`);
+      logger.debug(`Task ${taskId} created in task list ${this.taskListId}`);
       return taskId;
     });
   }
@@ -141,7 +157,7 @@ export class TaskManager extends EventEmitter {
       const content = JSON.stringify(task, null, 2);
       await fs.writeFile(taskPath, content, "utf8");
       this.emit("tasksChange", this.taskListId);
-      logger.info(`Task ${task.id} updated in task list ${this.taskListId}`);
+      logger.debug(`Task ${task.id} updated in task list ${this.taskListId}`);
     });
   }
 

package/src/tools/bashTool.ts

@@ -153,7 +153,7 @@ Usage notes:
           return {
             success: false,
             content: "",
-            error: `${BASH_TOOL_NAME} operation denied, reason: ${permissionResult.message || "No reason provided"}`,
+            error: `${BASH_TOOL_NAME} operation denied by user, reason: ${permissionResult.message || "No reason provided"}`,
           };
         }
       } catch {
@@ -197,24 +197,9 @@ Usage notes:
 
       let outputBuffer = "";
       let errorBuffer = "";
-      let shortResultBuffer = "";
       let isAborted = false;
       let isBackgrounded = false;
 
-      const updateShortResult = (chunk: string) => {
-        if (!chunk) return;
-        shortResultBuffer += chunk;
-        if (shortResultBuffer.length > MAX_OUTPUT_LENGTH) {
-          shortResultBuffer = shortResultBuffer.slice(-MAX_OUTPUT_LENGTH);
-        }
-        const lastLines = shortResultBuffer
-          .trim()
-          .split("\n")
-          .slice(-3)
-          .join("\n");
-        context.onShortResultUpdate?.(lastLines || "");
-      };
-
       const foregroundTaskId = `bash_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
 
       // Register as foreground task
@@ -324,7 +309,6 @@ Usage notes:
         if (!isAborted && !isBackgrounded && !runInBackground) {
           const chunk = stripAnsiColors(data.toString());
           outputBuffer += chunk;
-          updateShortResult(chunk);
         }
       });
 
@@ -332,7 +316,6 @@ Usage notes:
         if (!isAborted && !isBackgrounded && !runInBackground) {
           const chunk = stripAnsiColors(data.toString());
           errorBuffer += chunk;
-          updateShortResult(chunk);
         }
       });
 
@@ -361,9 +344,16 @@ Usage notes:
                 "\n\n... (output truncated)"
               : finalOutput;
 
+          const shortResult = combinedOutput
+            .trim()
+            .split("\n")
+            .slice(-3)
+            .join("\n");
+
           resolve({
             success: exitCode === 0,
             content,
+            shortResult: shortResult || undefined,
             error:
               exitCode !== 0
                 ? `Command failed with exit code: ${exitCode}`

package/src/tools/editTool.ts

@@ -182,7 +182,7 @@ Usage:
             return {
               success: false,
               content: "",
-              error: `${EDIT_TOOL_NAME} operation denied, reason: ${permissionResult.message || "No reason provided"}`,
+              error: `${EDIT_TOOL_NAME} operation denied by user, reason: ${permissionResult.message || "No reason provided"}`,
             };
           }
         } catch {

package/src/tools/exitPlanMode.ts

@@ -93,7 +93,7 @@ Ensure your plan is complete and unambiguous:
       if (permissionResult.behavior === "deny") {
         return {
           success: false,
-          content: `User feedback: ${permissionResult.message || "Plan rejected by user"}. Please update your proposal accordingly.`,
+          content: `Please update your proposal based on the following user feedback: ${permissionResult.message || "Plan rejected by user"}`,
           error: permissionResult.message ? undefined : "Plan rejected by user",
         };
       }

package/src/tools/lsTool.ts

@@ -2,7 +2,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { minimatch } from "minimatch";
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
-import { isBinary, getDisplayPath } from "@/utils/path.js";
+import { isBinary, getDisplayPath } from "../utils/path.js";
 import {
   LS_TOOL_NAME,
   GLOB_TOOL_NAME,