wave-agent-sdk 0.0.6 → 0.0.8

package/src/managers/backgroundBashManager.ts

@@ -1,4 +1,5 @@
 import { spawn } from "child_process";
+import { logger } from "../utils/globalLogger.js";
 import type { BackgroundShell } from "../types/index.js";
 
 export interface BackgroundBashManagerCallbacks {
@@ -127,8 +128,8 @@ export class BackgroundBashManager {
           .split("\n")
           .filter((line) => regex.test(line))
           .join("\n");
-      } catch {
-        // logger.warn(`Invalid filter regex: ${filter}`, error);
+      } catch (error) {
+        logger.warn(`Invalid filter regex: ${filter}`, error);
       }
     }
 
@@ -159,8 +160,8 @@ export class BackgroundBashManager {
           ) {
             try {
               process.kill(-shell.process.pid, "SIGKILL");
-            } catch {
-              // logger.error("Failed to force kill process:", error);
+            } catch (error) {
+              logger.error("Failed to force kill process:", error);
             }
           }
         }, 1000);
@@ -183,8 +184,8 @@ export class BackgroundBashManager {
         shell.runtime = Date.now() - shell.startTime;
         this.notifyShellsChange();
         return true;
-      } catch {
-        // logger.error("Failed to kill child process:", directKillError);
+      } catch (directKillError) {
+        logger.error("Failed to kill child process:", directKillError);
         return false;
       }
     }

package/src/managers/hookManager.ts

@@ -8,7 +8,7 @@
 import {
   type HookEvent,
   type HookEventConfig,
-  type HookConfiguration,
+  type WaveConfiguration,
   type PartialHookConfiguration,
   type HookExecutionContext,
   type ExtendedHookExecutionContext,
@@ -18,50 +18,26 @@ import {
   isValidHookEvent,
   isValidHookEventConfig,
 } from "../types/hooks.js";
-import { type IHookMatcher, HookMatcher } from "../utils/hookMatcher.js";
+import { HookMatcher } from "../utils/hookMatcher.js";
 import {
   executeCommand,
   isCommandSafe,
-  loadMergedHooksConfig,
+  loadMergedWaveConfig,
 } from "../services/hook.js";
 import type { Logger } from "../types/index.js";
+import { MessageSource } from "../types/index.js";
 import type { MessageManager } from "./messageManager.js";
 
-export interface IHookManager {
-  // Load configuration from settings
-  loadConfiguration(
-    userHooks?: PartialHookConfiguration,
-    projectHooks?: PartialHookConfiguration,
-  ): void;
-
-  // Load configuration from filesystem settings
-  loadConfigurationFromSettings(): void;
-
-  // Execute hooks for specific event
-  executeHooks(
-    event: HookEvent,
-    context: HookExecutionContext | ExtendedHookExecutionContext,
-  ): Promise<HookExecutionResult[]>;
-
-  // Check if hooks are configured for event
-  hasHooks(event: HookEvent, toolName?: string): boolean;
-
-  // Validate hook configuration
-  validateConfiguration(config: HookConfiguration): ValidationResult;
-
-  // Get current configuration
-  getConfiguration(): PartialHookConfiguration | undefined;
-}
-
-export class HookManager implements IHookManager {
+export class HookManager {
   private configuration: PartialHookConfiguration | undefined;
-  private readonly matcher: IHookMatcher;
+  private environmentVars: Record<string, string> | undefined;
+  private readonly matcher: HookMatcher;
   private readonly logger?: Logger;
   private readonly workdir: string;
 
   constructor(
     workdir: string,
-    matcher: IHookMatcher = new HookMatcher(),
+    matcher: HookMatcher = new HookMatcher(),
     logger?: Logger,
   ) {
     this.workdir = workdir;
@@ -103,18 +79,25 @@ export class HookManager implements IHookManager {
 
   /**
    * Load configuration from filesystem settings
-   * Automatically loads and merges user and project hooks configuration
+   * Automatically loads and merges user and project Wave configuration (hooks + environment)
    */
   loadConfigurationFromSettings(): void {
     try {
       this.logger?.debug(`[HookManager] Loading configuration...`);
-      const mergedConfig = loadMergedHooksConfig(this.workdir);
-      this.logger?.debug(`[HookManager] Merged config result:`, mergedConfig);
-      this.configuration = mergedConfig || undefined;
+      const mergedWaveConfig = loadMergedWaveConfig(this.workdir);
+      this.logger?.debug(
+        `[HookManager] Merged config result:`,
+        mergedWaveConfig,
+      );
+
+      this.configuration = mergedWaveConfig?.hooks || undefined;
+      this.environmentVars = mergedWaveConfig?.env || undefined;
 
       // Validate the loaded configuration if it exists
-      if (mergedConfig) {
-        const validation = this.validatePartialConfiguration(mergedConfig);
+      if (mergedWaveConfig?.hooks) {
+        const validation = this.validatePartialConfiguration(
+          mergedWaveConfig.hooks,
+        );
         if (!validation.valid) {
           throw new HookConfigurationError(
             "filesystem settings",
@@ -124,11 +107,12 @@ export class HookManager implements IHookManager {
       }
 
       this.logger?.debug(
-        `[HookManager] Configuration loaded successfully with ${Object.keys(mergedConfig || {}).length} event types`,
+        `[HookManager] Configuration loaded successfully with ${Object.keys(mergedWaveConfig?.hooks || {}).length} event types and ${Object.keys(this.environmentVars || {}).length} environment variables`,
       );
     } catch (error) {
       // If loading fails, start with undefined configuration (no hooks)
       this.configuration = undefined;
+      this.environmentVars = undefined;
 
       // Re-throw configuration errors, but handle file system errors gracefully
       if (error instanceof HookConfigurationError) {
@@ -219,7 +203,12 @@ export class HookManager implements IHookManager {
             `[HookManager] Executing command ${commandIndex + 1}/${config.hooks.length} in configuration ${configIndex + 1}`,
           );
 
-          const result = await executeCommand(hookCommand.command, context);
+          const result = await executeCommand(
+            hookCommand.command,
+            context,
+            undefined,
+            this.environmentVars,
+          );
           results.push(result);
 
           // Report individual command result
@@ -228,7 +217,7 @@ export class HookManager implements IHookManager {
               `[HookManager] Command ${commandIndex + 1} completed successfully in ${result.duration}ms`,
             );
           } else {
-            this.logger?.warn(
+            this.logger?.debug(
               `[HookManager] Command ${commandIndex + 1} failed in ${result.duration}ms (exit code: ${result.exitCode}, timed out: ${result.timedOut})`,
             );
           }
@@ -274,7 +263,7 @@ export class HookManager implements IHookManager {
     results: HookExecutionResult[],
     messageManager?: MessageManager,
     toolId?: string,
-    originalToolResult?: string,
+    toolParameters?: string,
   ): {
     shouldBlock: boolean;
     errorMessage?: string;
@@ -293,7 +282,7 @@ export class HookManager implements IHookManager {
           result,
           messageManager,
           toolId,
-          originalToolResult,
+          toolParameters,
         );
       }
     }
@@ -327,7 +316,10 @@ export class HookManager implements IHookManager {
   ): void {
     if (event === "UserPromptSubmit" && result.stdout?.trim()) {
       // Inject stdout as user message context for UserPromptSubmit
-      messageManager.addUserMessage(result.stdout.trim());
+      messageManager.addUserMessage({
+        content: result.stdout.trim(),
+        source: MessageSource.HOOK,
+      });
     }
     // For other hook types (PreToolUse, PostToolUse, Stop), ignore stdout
   }
@@ -340,7 +332,7 @@ export class HookManager implements IHookManager {
     result: HookExecutionResult,
     messageManager: MessageManager,
     toolId?: string,
-    originalToolResult?: string,
+    toolParameters?: string,
   ): {
     shouldBlock: boolean;
     errorMessage?: string;
@@ -361,28 +353,30 @@ export class HookManager implements IHookManager {
         // Block tool execution and show error to Wave Agent via tool block
         if (toolId) {
           messageManager.updateToolBlock({
-            toolId,
+            id: toolId,
+            parameters: toolParameters || "",
             result: errorMessage,
             success: false,
             error: "Hook blocked tool execution",
+            stage: "end", // Hook blocking results in end stage with error
           });
         }
         return { shouldBlock: true };
 
       case "PostToolUse":
-        // Show error to Wave Agent via tool block, execution continues
-        if (toolId && originalToolResult !== undefined) {
-          messageManager.updateToolBlock({
-            toolId,
-            result: `${originalToolResult}\n\nHook feedback: ${errorMessage}`,
-            success: false,
-          });
-        }
+        // Show error to Wave Agent via user message and allow AI to continue
+        messageManager.addUserMessage({
+          content: errorMessage,
+          source: MessageSource.HOOK,
+        });
         return { shouldBlock: false };
 
       case "Stop":
         // Show error to Wave Agent via user message and block stopping to continue conversation
-        messageManager.addUserMessage(errorMessage);
+        messageManager.addUserMessage({
+          content: errorMessage,
+          source: MessageSource.HOOK,
+        });
         return { shouldBlock: true, errorMessage };
 
       default:
@@ -416,46 +410,62 @@ export class HookManager implements IHookManager {
   }
 
   /**
-   * Validate hook configuration structure and content
+   * Validate Wave configuration structure and content
    */
-  validateConfiguration(config: HookConfiguration): ValidationResult {
+  validateConfiguration(config: WaveConfiguration): ValidationResult {
     const errors: string[] = [];
 
     if (!config || typeof config !== "object") {
       return { valid: false, errors: ["Configuration must be an object"] };
     }
 
-    if (!config.hooks || typeof config.hooks !== "object") {
-      return {
-        valid: false,
-        errors: ["Configuration must have a hooks property"],
-      };
-    }
+    // Validate hooks if present
+    if (config.hooks) {
+      if (typeof config.hooks !== "object") {
+        errors.push("hooks property must be an object");
+      } else {
+        // Validate each hook event
+        for (const [eventName, eventConfigs] of Object.entries(config.hooks)) {
+          // Validate event name
+          if (!isValidHookEvent(eventName)) {
+            errors.push(`Invalid hook event: ${eventName}`);
+            continue;
+          }
 
-    // Validate each hook event
-    for (const [eventName, eventConfigs] of Object.entries(config.hooks)) {
-      // Validate event name
-      if (!isValidHookEvent(eventName)) {
-        errors.push(`Invalid hook event: ${eventName}`);
-        continue;
-      }
+          // Validate event configurations
+          if (!Array.isArray(eventConfigs)) {
+            errors.push(
+              `Hook event ${eventName} must be an array of configurations`,
+            );
+            continue;
+          }
 
-      // Validate event configurations
-      if (!Array.isArray(eventConfigs)) {
-        errors.push(
-          `Hook event ${eventName} must be an array of configurations`,
-        );
-        continue;
+          eventConfigs.forEach((eventConfig, index) => {
+            const configErrors = this.validateEventConfig(
+              eventName as HookEvent,
+              eventConfig,
+              index,
+            );
+            errors.push(...configErrors);
+          });
+        }
       }
+    }
 
-      eventConfigs.forEach((eventConfig, index) => {
-        const configErrors = this.validateEventConfig(
-          eventName as HookEvent,
-          eventConfig,
-          index,
-        );
-        errors.push(...configErrors);
-      });
+    // Validate environment variables if present
+    if (config.env) {
+      if (typeof config.env !== "object" || Array.isArray(config.env)) {
+        errors.push("env property must be an object");
+      } else {
+        for (const [key, value] of Object.entries(config.env)) {
+          if (typeof key !== "string" || key.trim() === "") {
+            errors.push(`Invalid environment variable key: ${key}`);
+          }
+          if (typeof value !== "string") {
+            errors.push(`Environment variable ${key} must have a string value`);
+          }
+        }
+      }
     }
 
     return {
@@ -518,6 +528,16 @@ export class HookManager implements IHookManager {
     return JSON.parse(JSON.stringify(this.configuration));
   }
 
+  /**
+   * Get current environment variables
+   */
+  getEnvironmentVars(): Record<string, string> | undefined {
+    if (!this.environmentVars) return undefined;
+
+    // Deep clone to prevent external modification
+    return JSON.parse(JSON.stringify(this.environmentVars));
+  }
+
   /**
    * Clear current configuration
    */
@@ -718,6 +738,7 @@ export class HookManager implements IHookManager {
           PostToolUse: 0,
           UserPromptSubmit: 0,
           Stop: 0,
+          SubagentStop: 0,
         },
       };
     }
@@ -727,6 +748,7 @@ export class HookManager implements IHookManager {
       PostToolUse: 0,
       UserPromptSubmit: 0,
       Stop: 0,
+      SubagentStop: 0,
     };
 
     let totalConfigs = 0;

package/src/managers/liveConfigManager.ts

@@ -0,0 +1,248 @@
+/**
+ * Live Configuration Manager
+ *
+ * Orchestrates live configuration reload functionality including:
+ * - Hook configuration watching and reloading
+ * - Memory store management for AGENTS.md files
+ * - Coordination between file watchers and configuration updates
+ */
+
+import type { Logger } from "../types/index.js";
+import {
+  ConfigurationWatcher,
+  type ConfigurationChangeEvent,
+} from "../services/configurationWatcher.js";
+
+import { type FileWatchEvent } from "../services/fileWatcher.js";
+import { configResolver } from "../utils/configResolver.js";
+import { join } from "path";
+import {
+  getUserConfigPaths,
+  getProjectConfigPaths,
+} from "../utils/configPaths.js";
+import { CONFIGURATION_EVENTS } from "../constants/events.js";
+
+export interface LiveConfigManagerOptions {
+  workdir: string;
+  logger?: Logger;
+  onConfigurationChanged?: () => void; // Callback for when configuration changes
+  onMemoryStoreFileChanged?: (
+    filePath: string,
+    changeType: "add" | "change" | "unlink",
+  ) => Promise<void>; // Callback for memory store file changes
+}
+
+export class LiveConfigManager {
+  private readonly workdir: string;
+  private readonly logger?: Logger;
+  private readonly onConfigurationChanged?: () => void;
+  private readonly onMemoryStoreFileChanged?: (
+    filePath: string,
+    changeType: "add" | "change" | "unlink",
+  ) => Promise<void>;
+  private configurationWatcher?: ConfigurationWatcher;
+  private isInitialized: boolean = false;
+
+  constructor(options: LiveConfigManagerOptions) {
+    this.workdir = options.workdir;
+    this.logger = options.logger;
+    this.onConfigurationChanged = options.onConfigurationChanged;
+    this.onMemoryStoreFileChanged = options.onMemoryStoreFileChanged;
+  }
+
+  /**
+   * Initialize live configuration management
+   */
+  async initialize(): Promise<void> {
+    if (this.isInitialized) {
+      this.logger?.debug("[LiveConfigManager] Already initialized");
+      return;
+    }
+
+    try {
+      // Initialize configuration watcher for hook settings
+      await this.initializeConfigurationWatcher();
+
+      // Initialize memory store watching for AGENTS.md if callback is available
+      if (this.onMemoryStoreFileChanged) {
+        await this.initializeMemoryStoreWatching();
+      }
+
+      this.isInitialized = true;
+      this.logger?.info(
+        "Live Config: Live configuration management initialized successfully",
+      );
+    } catch (error) {
+      this.logger?.error(
+        `Live Config: Failed to initialize: ${(error as Error).message}`,
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Shutdown live configuration management
+   */
+  async shutdown(): Promise<void> {
+    if (!this.isInitialized) {
+      return;
+    }
+
+    try {
+      if (this.configurationWatcher) {
+        await this.configurationWatcher.shutdown();
+        this.configurationWatcher = undefined;
+      }
+
+      this.isInitialized = false;
+      this.logger?.info(
+        "Live Config: Live configuration management shutdown completed",
+      );
+    } catch (error) {
+      this.logger?.error(
+        `Live Config: Error during shutdown: ${(error as Error).message}`,
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Initialize configuration watcher for hook settings
+   */
+  private async initializeConfigurationWatcher(): Promise<void> {
+    this.configurationWatcher = new ConfigurationWatcher(
+      this.workdir,
+      this.logger,
+    );
+
+    // Set up configuration change handler using EventEmitter pattern
+    this.configurationWatcher.on(
+      CONFIGURATION_EVENTS.CONFIGURATION_CHANGE,
+      (event: ConfigurationChangeEvent) => {
+        this.handleConfigurationChange(event);
+      },
+    );
+
+    // Initialize watching for user and project settings
+    const { userPaths, projectPaths } = this.getConfigurationPaths();
+    await this.configurationWatcher.initializeWatching(userPaths, projectPaths);
+    this.logger?.info("Live Config: Configuration watching initialized");
+  }
+
+  /**
+   * Initialize memory store watching for AGENTS.md files
+   */
+  private async initializeMemoryStoreWatching(): Promise<void> {
+    if (!this.onMemoryStoreFileChanged || !this.configurationWatcher) {
+      this.logger?.debug(
+        "Live Config: Memory store callback or configuration watcher not available, skipping AGENTS.md watching",
+      );
+      return;
+    }
+
+    try {
+      const agentsFilePath = join(this.workdir, "AGENTS.md");
+
+      // Add AGENTS.md to file watcher
+      await this.configurationWatcher.watchAdditionalFile(
+        agentsFilePath,
+        async (event: FileWatchEvent) => {
+          await this.handleMemoryStoreFileChange(event);
+        },
+      );
+
+      this.logger?.info("Live Config: AGENTS.md file watching initialized");
+    } catch (error) {
+      this.logger?.warn(
+        `Live Config: Failed to initialize AGENTS.md watching: ${(error as Error).message}`,
+      );
+      // Don't throw - memory optimization is not critical for core functionality
+    }
+  }
+
+  /**
+   * Handle configuration change events
+   */
+  private handleConfigurationChange(event: ConfigurationChangeEvent): void {
+    this.logger?.info(
+      `Live Config: Configuration change detected: ${event.type} at ${event.path}`,
+    );
+
+    // Invalidate and refresh configuration cache for live environment variable updates
+    configResolver.invalidateCache(this.workdir);
+    configResolver.refreshCache(this.workdir);
+
+    // Trigger Agent configuration update callback if provided
+    if (this.onConfigurationChanged) {
+      try {
+        this.logger?.info("Live Config: Triggering Agent configuration update");
+        this.onConfigurationChanged();
+      } catch (error) {
+        this.logger?.error(
+          `Live Config: Error in configuration change callback: ${(error as Error).message}`,
+        );
+      }
+    }
+
+    // Log cache status after refresh
+    const cacheStatus = configResolver.getCacheStatus();
+    if (cacheStatus) {
+      this.logger?.info(
+        `Live Config: Configuration cache refreshed - ${cacheStatus.envVarCount} environment variables loaded`,
+      );
+    }
+  }
+
+  /**
+   * Handle AGENTS.md file change events
+   */
+  private async handleMemoryStoreFileChange(
+    event: FileWatchEvent,
+  ): Promise<void> {
+    if (!this.onMemoryStoreFileChanged) {
+      return;
+    }
+
+    try {
+      this.logger?.info(
+        `Live Config: AGENTS.md ${event.type} detected: ${event.path}`,
+      );
+
+      const changeType: "add" | "change" | "unlink" =
+        event.type === "delete"
+          ? "unlink"
+          : event.type === "create"
+            ? "add"
+            : "change";
+      await this.onMemoryStoreFileChanged(event.path, changeType);
+
+      this.logger?.info(
+        `Live Config: Memory store updated for AGENTS.md ${event.type}`,
+      );
+    } catch (error) {
+      this.logger?.error(
+        `Live Config: Failed to handle AGENTS.md file change: ${(error as Error).message}`,
+      );
+    }
+  }
+
+  /**
+   * Get initialization status
+   */
+  get initialized(): boolean {
+    return this.isInitialized;
+  }
+
+  /**
+   * Get configuration file paths for user and project settings
+   * Returns paths in priority order (local.json first, then .json)
+   */
+  private getConfigurationPaths(): {
+    userPaths: string[];
+    projectPaths: string[];
+  } {
+    const userPaths = getUserConfigPaths();
+    const projectPaths = getProjectConfigPaths(this.workdir);
+    return { userPaths, projectPaths };
+  }
+}