wave-agent-sdk 0.8.1 → 0.8.3

package/src/services/initializationService.ts

@@ -121,7 +121,6 @@ export class InitializationService {
     // Initialize hooks configuration
     try {
       // Load hooks configuration using ConfigurationService
-      logger?.debug("Loading hooks configuration...");
       const configResult =
         await configurationService.loadMergedConfiguration(workdir);
 
@@ -156,8 +155,6 @@ export class InitializationService {
           }
         }
       }
-
-      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
@@ -206,9 +203,7 @@ export class InitializationService {
 
     // 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
@@ -216,8 +211,6 @@ export class InitializationService {
 
     // 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");
@@ -226,13 +219,9 @@ export class InitializationService {
           "utf-8",
         );
         setProjectMemory(projectMemoryContent);
-        logger?.debug("Project memory loaded successfully");
       } catch (error) {
+        logger?.warn("Failed to load project memory file:", 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)
@@ -240,16 +229,10 @@ export class InitializationService {
         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) {
+        logger?.warn("Failed to load user memory file:", 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("");

package/src/services/pluginLoader.ts

@@ -98,10 +98,8 @@ export class PluginLoader {
             });
             if (parsed.isValid) {
               skills.push({
-                name: parsed.skillMetadata.name,
-                description: parsed.skillMetadata.description,
+                ...parsed.skillMetadata,
                 type: "project", // Plugin skills are treated as project skills
-                skillPath: parsed.skillMetadata.skillPath,
                 content: parsed.content,
                 frontmatter: parsed.frontmatter,
                 isValid: parsed.isValid,

package/src/services/taskManager.ts

@@ -161,6 +161,57 @@ export class TaskManager extends EventEmitter {
     });
   }
 
+  async deleteTask(taskId: string): Promise<void> {
+    await this.withLock(async () => {
+      const taskPath = this.getTaskPath(taskId);
+      try {
+        await fs.unlink(taskPath);
+        this.emit("tasksChange", this.taskListId);
+        logger.debug(
+          `Task ${taskId} deleted from task list ${this.taskListId}`,
+        );
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+          throw error;
+        }
+      }
+    });
+  }
+
+  async cleanupOldTaskLists(days: number = 30): Promise<void> {
+    const threshold = Date.now() - days * 24 * 60 * 60 * 1000;
+    try {
+      const dirs = await fs.readdir(this.baseDir);
+      for (const dir of dirs) {
+        if (dir === this.taskListId) continue;
+
+        const dirPath = join(this.baseDir, dir);
+        const stats = await fs.stat(dirPath);
+        if (!stats.isDirectory()) continue;
+
+        // Check mtime of the directory and its contents
+        let latestMtime = stats.mtimeMs;
+        const files = await fs.readdir(dirPath);
+        for (const file of files) {
+          const filePath = join(dirPath, file);
+          const fileStats = await fs.stat(filePath);
+          if (fileStats.mtimeMs > latestMtime) {
+            latestMtime = fileStats.mtimeMs;
+          }
+        }
+
+        if (latestMtime < threshold) {
+          logger.info(`Cleaning up old task list directory: ${dirPath}`);
+          await fs.rm(dirPath, { recursive: true, force: true });
+        }
+      }
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+        logger.error("Failed to cleanup old task lists:", error);
+      }
+    }
+  }
+
   async listTasks(): Promise<Task[]> {
     const sessionDir = this.getSessionDir();
     try {

package/src/tools/taskManagementTools.ts

@@ -101,6 +101,15 @@ NOTE that you should not use this tool if there is only one trivial task to do.
 - Check TaskList first to avoid creating duplicate tasks`,
   execute: async (args, context: ToolContext): Promise<ToolResult> => {
     const taskManager = context.taskManager;
+
+    if (args.status === "deleted") {
+      return {
+        success: true,
+        content: `Task creation skipped because status was set to 'deleted'.`,
+        shortResult: `Skipped deleted task`,
+      };
+    }
+
     const task: Omit<Task, "id"> = {
       subject: args.subject as string,
       description: args.description as string,
@@ -334,6 +343,74 @@ Set up task dependencies:
       };
     }
 
+    if (args.status === "deleted") {
+      // Reciprocal Dependency Cleanup
+      // For each task in the deleted task's blocks list, remove the deleted task's ID from their blockedBy list.
+      for (const targetId of existingTask.blocks) {
+        const targetTask = await taskManager.getTask(targetId);
+        if (targetTask && targetTask.blockedBy.includes(taskId)) {
+          let targetSnapshotId: string | undefined;
+          if (context.reversionManager && context.messageId) {
+            const targetPath = taskManager.getTaskPath(targetId);
+            targetSnapshotId = await context.reversionManager.recordSnapshot(
+              context.messageId,
+              targetPath,
+              "modify",
+            );
+          }
+          await taskManager.updateTask({
+            ...targetTask,
+            blockedBy: targetTask.blockedBy.filter((id) => id !== taskId),
+          });
+          if (context.reversionManager && targetSnapshotId) {
+            await context.reversionManager.commitSnapshot(targetSnapshotId);
+          }
+        }
+      }
+
+      // For each task in the deleted task's blockedBy list, remove the deleted task's ID from their blocks list.
+      for (const targetId of existingTask.blockedBy) {
+        const targetTask = await taskManager.getTask(targetId);
+        if (targetTask && targetTask.blocks.includes(taskId)) {
+          let targetSnapshotId: string | undefined;
+          if (context.reversionManager && context.messageId) {
+            const targetPath = taskManager.getTaskPath(targetId);
+            targetSnapshotId = await context.reversionManager.recordSnapshot(
+              context.messageId,
+              targetPath,
+              "modify",
+            );
+          }
+          await taskManager.updateTask({
+            ...targetTask,
+            blocks: targetTask.blocks.filter((id) => id !== taskId),
+          });
+          if (context.reversionManager && targetSnapshotId) {
+            await context.reversionManager.commitSnapshot(targetSnapshotId);
+          }
+        }
+      }
+
+      // Record delete snapshot for the task itself
+      if (context.reversionManager && context.messageId) {
+        const taskPath = taskManager.getTaskPath(taskId);
+        const deleteSnapshotId = await context.reversionManager.recordSnapshot(
+          context.messageId,
+          taskPath,
+          "delete",
+        );
+        await context.reversionManager.commitSnapshot(deleteSnapshotId);
+      }
+
+      await taskManager.deleteTask(taskId);
+
+      return {
+        success: true,
+        content: `Task #${taskId} deleted and removed from disk.`,
+        shortResult: `Deleted task ${taskId}`,
+      };
+    }
+
     let snapshotId: string | undefined;
     if (context.reversionManager && context.messageId) {
       const taskPath = taskManager.getTaskPath(taskId);

package/src/tools/taskTool.ts

@@ -162,68 +162,77 @@ ${subagentList || "No subagents configured"}
         },
       );
 
-      // Register for backgrounding if not already in background
-      if (!run_in_background && context.foregroundTaskManager) {
-        context.foregroundTaskManager.registerForegroundTask({
-          id: instance.subagentId,
-          backgroundHandler: async () => {
-            isBackgrounded = true;
-            await subagentManager.backgroundInstance(instance.subagentId);
-          },
-        });
-      }
-
-      try {
-        const result = await subagentManager.executeTask(
-          instance,
-          prompt,
-          context.abortSignal,
-          run_in_background,
-        );
-
-        if (isBackgrounded) {
-          // If it was backgrounded during execution, the backgroundHandler already returned/will return
-          // But wait, the backgroundHandler is async and returns a ToolResult.
-          // In the current ToolManager/AIManager implementation, the backgroundHandler's return value
-          // is what's used when backgrounding happens.
-          // However, executeTask might still be running.
-          // We should return a special value or just let it be.
-          return {
-            success: true,
-            content: "Task backgrounded",
-            shortResult: "Task backgrounded",
-            isManuallyBackgrounded: true,
-          };
-        }
-
-        if (run_in_background) {
-          return {
-            success: true,
-            content: `Task started in background with ID: ${result}`,
-            shortResult: `Task started in background: ${result}`,
-          };
-        }
-
-        // Cleanup subagent instance after task completion
-        subagentManager.cleanupInstance(instance.subagentId);
-
-        const messages = instance.messageManager.getMessages();
-        const tokens = instance.messageManager.getlatestTotalTokens();
-        const toolCount = countToolBlocks(messages);
-        const summary = formatToolTokenSummary(toolCount, tokens);
+      return new Promise<ToolResult>((resolve) => {
+        (async () => {
+          // Register for backgrounding if not already in background
+          if (!run_in_background && context.foregroundTaskManager) {
+            context.foregroundTaskManager.registerForegroundTask({
+              id: instance.subagentId,
+              backgroundHandler: async () => {
+                isBackgrounded = true;
+                await subagentManager.backgroundInstance(instance.subagentId);
+                resolve({
+                  success: true,
+                  content: "Task backgrounded",
+                  shortResult: "Task backgrounded",
+                  isManuallyBackgrounded: true,
+                });
+              },
+            });
+          }
 
-        return {
-          success: true,
-          content: result,
-          shortResult: `Task completed${summary ? ` ${summary}` : ""}`,
-        };
-      } finally {
-        if (!run_in_background && context.foregroundTaskManager) {
-          context.foregroundTaskManager.unregisterForegroundTask(
-            instance.subagentId,
-          );
-        }
-      }
+          try {
+            const result = await subagentManager.executeTask(
+              instance,
+              prompt,
+              context.abortSignal,
+              run_in_background,
+            );
+
+            if (isBackgrounded) {
+              return;
+            }
+
+            if (run_in_background) {
+              resolve({
+                success: true,
+                content: `Task started in background with ID: ${result}`,
+                shortResult: `Task started in background: ${result}`,
+              });
+              return;
+            }
+
+            // Cleanup subagent instance after task completion
+            subagentManager.cleanupInstance(instance.subagentId);
+
+            const messages = instance.messageManager.getMessages();
+            const tokens = instance.messageManager.getlatestTotalTokens();
+            const toolCount = countToolBlocks(messages);
+            const summary = formatToolTokenSummary(toolCount, tokens);
+
+            resolve({
+              success: true,
+              content: result,
+              shortResult: `Task completed${summary ? ` ${summary}` : ""}`,
+            });
+          } catch (error) {
+            if (!isBackgrounded) {
+              resolve({
+                success: false,
+                content: "",
+                error: `Task delegation failed: ${error instanceof Error ? error.message : String(error)}`,
+                shortResult: "Delegation error",
+              });
+            }
+          } finally {
+            if (!run_in_background && context.foregroundTaskManager) {
+              context.foregroundTaskManager.unregisterForegroundTask(
+                instance.subagentId,
+              );
+            }
+          }
+        })();
+      });
     } catch (error) {
       return {
         success: false,

package/src/utils/bashParser.ts

@@ -100,8 +100,13 @@ export function splitBashCommand(command: string): string[] {
 
   const finalResult: string[] = [];
   for (const part of parts) {
-    const stripped = stripRedirections(stripEnvVars(part));
-    if (stripped.startsWith("(") && stripped.endsWith(")")) {
+    const envStripped = stripEnvVars(part);
+    const stripped = stripRedirections(envStripped);
+    if (
+      stripped.startsWith("(") &&
+      stripped.endsWith(")") &&
+      stripped === envStripped
+    ) {
       const inner = stripped.substring(1, stripped.length - 1).trim();
       if (inner) {
         finalResult.push(...splitBashCommand(inner));
@@ -286,6 +291,49 @@ export function stripRedirections(command: string): string {
   return result.trim();
 }
 
+/**
+ * Checks if a bash command contains any write redirections (>, >>, &>, 2>, >|).
+ */
+export function hasWriteRedirections(command: string): boolean {
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let escaped = false;
+
+  for (let i = 0; i < command.length; i++) {
+    const char = command[i];
+
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+
+    if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      continue;
+    }
+
+    if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      continue;
+    }
+
+    if (inSingleQuote || inDoubleQuote) {
+      continue;
+    }
+
+    if (char === ">") {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 /**
  * Blacklist of dangerous commands that should not be safely prefix-matched
  * and should not have persistent permissions.

package/src/utils/containerSetup.ts

@@ -116,6 +116,9 @@ export function setupAgentContainer(
     const tasks = await taskManager.listTasks();
     onTasksChange(tasks);
   });
+  taskManager.cleanupOldTaskLists(30).catch((error) => {
+    logger.error("Failed to cleanup old task lists:", error);
+  });
 
   const backgroundTaskManager = new BackgroundTaskManager(container, {
     callbacks: {

package/src/utils/messageOperations.ts

@@ -1,3 +1,4 @@
+import { randomUUID } from "crypto";
 import type { Message, Usage } from "../types/index.js";
 import { MessageSource } from "../types/index.js";
 import { readFileSync } from "fs";
@@ -113,6 +114,8 @@ export const convertImageToBase64 = (imagePath: string): string => {
   }
 };
 
+export const generateMessageId = (): string => `msg-${randomUUID()}`;
+
 // Add user message
 export const addUserMessageToMessages = ({
   messages,
@@ -142,7 +145,7 @@ export const addUserMessageToMessages = ({
   }
 
   const userMessage: Message = {
-    id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+    id: generateMessageId(),
     role: "user",
     blocks,
   };
@@ -179,7 +182,7 @@ export const addAssistantMessageToMessages = (
   }
 
   const initialAssistantMessage: Message = {
-    id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+    id: generateMessageId(),
     role: "assistant",
     blocks,
     usage, // Include usage data if provided
@@ -283,6 +286,7 @@ export const addErrorBlockToMessage = ({
   } else {
     // If the last message is not an assistant message, create a new assistant message
     newMessages.push({
+      id: generateMessageId(),
       role: "assistant",
       blocks: [
         {
@@ -302,6 +306,7 @@ export const addBangMessage = ({
   command,
 }: AddBangParams): Message[] => {
   const outputMessage: Message = {
+    id: generateMessageId(),
     role: "user",
     blocks: [
       {

package/src/utils/openaiClient.ts

@@ -52,7 +52,9 @@ export class OpenAIClient {
             >;
           // Prevent unhandled rejection if only withResponse() is used
           promise.catch((e) => {
-            logger.error("Unhandled OpenAI promise rejection:", e);
+            if (!(e instanceof Error && e.name === "AbortError")) {
+              logger.error("Unhandled OpenAI promise rejection:", e);
+            }
           });
           return promise;
         },