wave-agent-sdk 0.0.7 → 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,
@@ -22,7 +22,7 @@ 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";
@@ -30,6 +30,7 @@ import type { MessageManager } from "./messageManager.js";
 
 export class HookManager {
   private configuration: PartialHookConfiguration | undefined;
+  private environmentVars: Record<string, string> | undefined;
   private readonly matcher: HookMatcher;
   private readonly logger?: Logger;
   private readonly workdir: string;
@@ -78,18 +79,25 @@ export class HookManager {
 
   /**
    * 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",
@@ -99,11 +107,12 @@ export class HookManager {
       }
 
       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) {
@@ -194,7 +203,12 @@ export class HookManager {
             `[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
@@ -203,7 +217,7 @@ export class HookManager {
               `[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})`,
             );
           }
@@ -344,6 +358,7 @@ export class HookManager {
             result: errorMessage,
             success: false,
             error: "Hook blocked tool execution",
+            stage: "end", // Hook blocking results in end stage with error
           });
         }
         return { shouldBlock: true };
@@ -395,46 +410,62 @@ export class HookManager {
   }
 
   /**
-   * 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 {
@@ -497,6 +528,16 @@ export class HookManager {
     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
    */
@@ -697,6 +738,7 @@ export class HookManager {
           PostToolUse: 0,
           UserPromptSubmit: 0,
           Stop: 0,
+          SubagentStop: 0,
         },
       };
     }
@@ -706,6 +748,7 @@ export class HookManager {
       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 };
+  }
+}