wave-agent-sdk 0.8.0 → 0.8.2

package/src/managers/liveConfigManager.ts

@@ -83,8 +83,6 @@ export class LiveConfigManager {
     projectPaths?: string[],
   ): Promise<void> {
     try {
-      logger?.debug("Live Config: Initializing configuration watching...");
-
       this.userConfigPaths = userPaths;
       this.projectConfigPaths = projectPaths;
 
@@ -94,16 +92,9 @@ export class LiveConfigManager {
       // Start watching user configs that exist
       for (const userPath of userPaths) {
         if (existsSync(userPath)) {
-          logger?.debug(
-            `Live Config: Starting to watch user config: ${userPath}`,
-          );
           await this.fileWatcher.watchFile(userPath, (event) =>
             this.handleFileChange(event, "user"),
           );
-        } else {
-          logger?.debug(
-            `Live Config: User config file does not exist: ${userPath}`,
-          );
         }
       }
 
@@ -114,24 +105,14 @@ export class LiveConfigManager {
             if (projectPath.endsWith("settings.local.json")) {
               await ensureGlobalGitIgnore("**/.wave/settings.local.json");
             }
-            logger?.debug(
-              `Live Config: Starting to watch project config: ${projectPath}`,
-            );
             await this.fileWatcher.watchFile(projectPath, (event) =>
               this.handleFileChange(event, "project"),
             );
-          } else {
-            logger?.debug(
-              `Live Config: Project config file does not exist: ${projectPath}`,
-            );
           }
         }
       }
 
       this.isWatching = true;
-      logger?.debug(
-        "Live Config: Configuration watching initialized successfully",
-      );
     } catch (error) {
       const errorMessage = `Failed to initialize configuration watching: ${(error as Error).message}`;
       logger?.error(`Live Config: ${errorMessage}`);
@@ -151,7 +132,6 @@ export class LiveConfigManager {
    */
   async initialize(): Promise<void> {
     if (this.isInitialized) {
-      logger?.debug("Already initialized");
       return;
     }
 
@@ -163,9 +143,6 @@ export class LiveConfigManager {
       await this.initializeWatching(userPaths, projectPaths);
 
       this.isInitialized = true;
-      logger?.debug(
-        "Live configuration management initialized with file watching",
-      );
     } catch (error) {
       logger?.error(`Failed to initialize: ${(error as Error).message}`);
       throw error;
@@ -181,8 +158,6 @@ export class LiveConfigManager {
     }
 
     try {
-      logger?.debug("Live Config: Shutting down configuration manager...");
-
       this.isWatching = false;
 
       // Cleanup file watcher
@@ -193,7 +168,6 @@ export class LiveConfigManager {
       this.lastValidConfiguration = null;
 
       this.isInitialized = false;
-      logger?.debug("Live configuration management shutdown completed");
     } catch (error) {
       logger?.error(`Error during shutdown: ${(error as Error).message}`);
       throw error;
@@ -206,15 +180,12 @@ export class LiveConfigManager {
    */
   private async reloadConfiguration(): Promise<WaveConfiguration> {
     if (this.reloadInProgress) {
-      logger?.debug("Live Config: Reload already in progress, skipping");
       return this.currentConfiguration || {};
     }
 
     this.reloadInProgress = true;
 
     try {
-      logger?.debug("Live Config: Reloading configuration from files...");
-
       // Load merged configuration using ConfigurationService
       const loadResult: ConfigurationLoadResult =
         await this.configurationService.loadMergedConfiguration(this.workdir);
@@ -237,9 +208,6 @@ export class LiveConfigManager {
 
         // Use fallback configuration if available
         if (this.lastValidConfiguration) {
-          logger?.debug(
-            "Live Config: Using previous valid configuration due to loading errors",
-          );
           this.currentConfiguration = this.lastValidConfiguration;
 
           // Apply environment variables to configuration service if configured
@@ -266,24 +234,6 @@ export class LiveConfigManager {
         }
       }
 
-      // Log success with detailed information
-      if (newConfig) {
-        logger?.debug(
-          `Live Config: Configuration loaded successfully from ${loadResult.sourcePath || "merged sources"}`,
-        );
-
-        // Log detailed configuration info
-        const hookCount = Object.keys(newConfig.hooks || {}).length;
-        const envCount = Object.keys(newConfig.env || {}).length;
-        logger?.debug(
-          `Live Config: Loaded ${hookCount} hook events and ${envCount} environment variables`,
-        );
-      } else {
-        logger?.debug(
-          "Live Config: No configuration found (using empty configuration)",
-        );
-      }
-
       // Log warnings from successful loading
       if (loadResult.warnings && loadResult.warnings.length > 0) {
         logger?.warn(
@@ -300,9 +250,6 @@ export class LiveConfigManager {
 
           // Use previous valid configuration for error recovery
           if (this.lastValidConfiguration) {
-            logger?.debug(
-              "Live Config: Using previous valid configuration due to validation errors",
-            );
             this.currentConfiguration = this.lastValidConfiguration;
 
             // Apply environment variables to configuration service if configured
@@ -339,9 +286,6 @@ export class LiveConfigManager {
       // Save as last valid configuration if it's valid and not empty
       if (newConfig && (newConfig.hooks || newConfig.env)) {
         this.lastValidConfiguration = { ...newConfig };
-        logger?.debug(
-          "Live Config: Saved current configuration as last valid backup",
-        );
       }
 
       // Note: Environment variables are already applied by loadMergedConfiguration()
@@ -378,10 +322,6 @@ export class LiveConfigManager {
         }
       }
 
-      logger?.debug(
-        `Live Config: Configuration reload completed successfully with ${Object.keys(newConfig?.hooks || {}).length} event types and ${Object.keys(newConfig?.env || {}).length} environment variables`,
-      );
-
       return this.currentConfiguration;
     } catch (error) {
       const errorMessage = `Configuration reload failed with exception: ${(error as Error).message}`;
@@ -389,9 +329,6 @@ export class LiveConfigManager {
 
       // Use previous valid configuration for error recovery
       if (this.lastValidConfiguration) {
-        logger?.debug(
-          "Live Config: Using previous valid configuration due to reload exception",
-        );
         this.currentConfiguration = this.lastValidConfiguration;
 
         // Apply environment variables to configuration service if configured
@@ -424,7 +361,6 @@ export class LiveConfigManager {
    * Reload configuration from files (public method)
    */
   async reload(): Promise<WaveConfiguration> {
-    logger?.debug("Manually reloading configuration...");
     return await this.reloadConfiguration();
   }
 
@@ -464,16 +400,9 @@ export class LiveConfigManager {
     event: FileWatchEvent,
     source: Scope,
   ): Promise<void> {
-    logger?.debug(
-      `Live Config: File ${event.type} detected for ${source} config: ${event.path}`,
-    );
-
     try {
       // Handle file deletion
       if (event.type === "delete") {
-        logger?.debug(
-          `Live Config: ${source} config file deleted: ${event.path}`,
-        );
         // Reload configuration without the deleted file
         await this.reloadConfiguration();
         return;
@@ -481,10 +410,6 @@ export class LiveConfigManager {
 
       // Handle file creation or modification
       if (event.type === "change" || event.type === "create") {
-        logger?.debug(
-          `Live Config: ${source} config file ${event.type}: ${event.path}`,
-        );
-
         if (
           source === "project" &&
           event.path.endsWith("settings.local.json") &&

package/src/managers/messageManager.ts

@@ -9,6 +9,7 @@ import {
   removeLastUserMessage,
   UserMessageParams,
   type AgentToolBlockUpdateParams,
+  generateMessageId,
 } from "../utils/messageOperations.js";
 import type { Message, Usage, SlashCommand } from "../types/index.js";
 import { join } from "path";
@@ -422,6 +423,7 @@ export class MessageManager {
 
     // Create compressed message
     const compressMessage: Message = {
+      id: generateMessageId(),
       role: "assistant",
       blocks: [
         {

package/src/managers/skillManager.ts

@@ -355,13 +355,19 @@ export class SkillManager {
    */
   registerPluginSkills(skills: Skill[]): void {
     for (const skill of skills) {
-      this.skillMetadata.set(skill.name, {
+      const metadata: SkillMetadata = {
         name: skill.name,
         description: skill.description,
         type: skill.type,
         skillPath: skill.skillPath,
         allowedTools: skill.allowedTools,
-      });
+        context: skill.context,
+        agent: skill.agent,
+        model: skill.model,
+        disableModelInvocation: skill.disableModelInvocation,
+        userInvocable: skill.userInvocable,
+      };
+      this.skillMetadata.set(skill.name, metadata);
       this.skillContent.set(skill.name, skill);
     }
     logger?.debug(

package/src/managers/slashCommandManager.ts

@@ -117,15 +117,10 @@ export class SlashCommandManager {
             }
 
             if (args) {
-              if (hasParameterPlaceholders(processedContent)) {
-                processedContent = substituteCommandParameters(
-                  processedContent,
-                  args,
-                );
-              } else {
-                // If no placeholders, append arguments to the content
-                processedContent = `${processedContent.trim()} ${args}`;
-              }
+              processedContent = substituteCommandParameters(
+                processedContent,
+                args,
+              );
             }
 
             await this.executeCustomCommandInMainAgent(
@@ -240,15 +235,10 @@ export class SlashCommandManager {
           }
 
           if (args) {
-            if (hasParameterPlaceholders(processedContent)) {
-              processedContent = substituteCommandParameters(
-                processedContent,
-                args,
-              );
-            } else {
-              // If no placeholders, append arguments to the content
-              processedContent = `${processedContent.trim()} ${args}`;
-            }
+            processedContent = substituteCommandParameters(
+              processedContent,
+              args,
+            );
           }
 
           await this.executeCustomCommandInMainAgent(

package/src/services/aiService.ts

@@ -132,9 +132,9 @@ function getModelConfig(
   };
 
   // Configuration rules for specific models
-  if (modelName.includes("gpt-5-codex")) {
-    // gpt-5-codex model sets temperature to undefined
-    config.temperature = undefined;
+  if (modelName.includes("gpt-5")) {
+    // gpt-5 models should not have temperature field
+    delete config.temperature;
   }
 
   return config;
@@ -399,6 +399,7 @@ export async function callAgent(
     }
   } catch (error) {
     if ((error as Error).name === "AbortError") {
+      logger.info("OpenAI request aborted");
       throw new Error("Request was aborted");
     }
 
@@ -818,6 +819,7 @@ export async function compressMessages(
     };
   } catch (error) {
     if ((error as Error).name === "AbortError") {
+      logger.info("Compression request was aborted");
       throw new Error("Compression request was aborted");
     }
     logger.error("Failed to compress messages:", error);

package/src/services/fileWatcher.ts

@@ -115,7 +115,6 @@ export class FileWatcherService extends EventEmitter {
       }
 
       this.watchers.delete(path);
-      this.logger?.debug(`Live Config: Stopped watching file: ${path}`);
     } catch (error) {
       this.logger?.warn(
         `Live Config: Error unwatching file ${path}: ${(error as Error).message}`,
@@ -199,8 +198,6 @@ export class FileWatcherService extends EventEmitter {
       entry.watcher = this.globalWatcher;
       entry.isActive = true;
       entry.errorCount = 0;
-
-      this.logger?.debug(`Live Config: Started watching file: ${entry.path}`);
     } catch (error) {
       entry.errorCount++;
       entry.isActive = false;
@@ -215,9 +212,6 @@ export class FileWatcherService extends EventEmitter {
         !entry.config.fallbackPolling &&
         entry.errorCount < entry.config.maxRetries
       ) {
-        this.logger?.debug(
-          `Live Config: Attempting polling fallback for ${entry.path}`,
-        );
         entry.config.fallbackPolling = true;
         await this.initializeWatcher(entry);
       } else {
@@ -281,7 +275,5 @@ export class FileWatcherService extends EventEmitter {
         );
       }
     }
-
-    this.logger?.debug(`Live Config: File ${type} event for ${filePath}`);
   }
 }

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

@@ -5,6 +5,11 @@ import { resolvePath, getDisplayPath } from "../utils/path.js";
 import { getGlobIgnorePatterns } from "../utils/fileFilter.js";
 import { GLOB_TOOL_NAME } from "../constants/tools.js";
 
+/**
+ * Maximum number of files returned by glob tool
+ */
+const MAX_GLOB_RESULTS = 1000;
+
 /**
  * Glob Tool Plugin - Fast file pattern matching
  */
@@ -109,15 +114,23 @@ export const globTool: ToolPlugin = {
         .sort((a, b) => b.mtime.getTime() - a.mtime.getTime()) // Most recently modified files first
         .map((item) => item.path);
 
+      const totalCount = sortedFiles.length;
+      const finalFiles = sortedFiles.slice(0, MAX_GLOB_RESULTS);
+
       // Format output
-      const output = sortedFiles
+      const output = finalFiles
         .map((file, index) => `${index + 1}. ${file}`)
         .join("\n");
 
+      const isTruncated = totalCount > MAX_GLOB_RESULTS;
+      const shortResult = isTruncated
+        ? `Found ${totalCount} files (showing first ${MAX_GLOB_RESULTS})`
+        : `Found ${totalCount} file${totalCount === 1 ? "" : "s"}`;
+
       return {
         success: true,
         content: output,
-        shortResult: `Found ${sortedFiles.length} file${sortedFiles.length === 1 ? "" : "s"}`,
+        shortResult,
       };
     } catch (error) {
       return {

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);