wave-agent-sdk 0.0.8 → 0.0.11

package/dist/managers/liveConfigManager.d.ts

@@ -3,52 +3,89 @@
  *
  * Orchestrates live configuration reload functionality including:
  * - Hook configuration watching and reloading
- * - Memory store management for AGENTS.md files
+ * - Configuration file watching for settings.json files
  * - Coordination between file watchers and configuration updates
  */
 import type { Logger } from "../types/index.js";
+import type { HookManager } from "./hookManager.js";
+import type { PermissionManager } from "./permissionManager.js";
+import type { WaveConfiguration } from "../types/hooks.js";
+import { ConfigurationService } from "../services/configurationService.js";
 export interface LiveConfigManagerOptions {
     workdir: string;
     logger?: Logger;
-    onConfigurationChanged?: () => void;
-    onMemoryStoreFileChanged?: (filePath: string, changeType: "add" | "change" | "unlink") => Promise<void>;
+    hookManager?: HookManager;
+    permissionManager?: PermissionManager;
+    configurationService?: ConfigurationService;
 }
 export declare class LiveConfigManager {
     private readonly workdir;
     private readonly logger?;
-    private readonly onConfigurationChanged?;
-    private readonly onMemoryStoreFileChanged?;
-    private configurationWatcher?;
+    private readonly hookManager?;
+    private readonly permissionManager?;
     private isInitialized;
+    private readonly configurationService;
+    private currentConfiguration;
+    private lastValidConfiguration;
+    private fileWatcher;
+    private userConfigPaths?;
+    private projectConfigPaths?;
+    private isWatching;
+    private reloadInProgress;
     constructor(options: LiveConfigManagerOptions);
     /**
-     * Initialize live configuration management
+     * Initialize configuration watching
+     * Maps to FR-004: System MUST watch settings.json files
+     * Supports watching multiple file paths (e.g., settings.local.json and settings.json)
+     */
+    private initializeWatching;
+    /**
+     * Get current configuration
+     */
+    getCurrentConfiguration(): WaveConfiguration | null;
+    /**
+     * Initialize configuration management with file watching
      */
     initialize(): Promise<void>;
     /**
-     * Shutdown live configuration management
+     * Shutdown configuration management and cleanup resources
      */
     shutdown(): Promise<void>;
     /**
-     * Initialize configuration watcher for hook settings
+     * Reload configuration from files
+     * Maps to FR-008: Continue with previous valid configuration on errors
      */
-    private initializeConfigurationWatcher;
+    private reloadConfiguration;
     /**
-     * Initialize memory store watching for AGENTS.md files
+     * Reload configuration from files (public method)
      */
-    private initializeMemoryStoreWatching;
+    reload(): Promise<WaveConfiguration>;
     /**
-     * Handle configuration change events
+     * Check if watching is active
      */
-    private handleConfigurationChange;
+    isWatchingActive(): boolean;
     /**
-     * Handle AGENTS.md file change events
+     * Get watcher status for monitoring
      */
-    private handleMemoryStoreFileChange;
+    getWatcherStatus(): {
+        isActive: boolean;
+        configurationLoaded: boolean;
+        hasValidConfiguration: boolean;
+        reloadInProgress: boolean;
+        watchedFiles: {
+            path: string;
+            isActive: boolean;
+            method: "native" | "polling" | "failed";
+            errorCount: number;
+        }[];
+    };
+    private setupFileWatcherEvents;
+    private handleFileChange;
     /**
-     * Get initialization status
+     * Validate configuration structure and content
      */
-    get initialized(): boolean;
+    private validateConfiguration;
+    private detectChanges;
     /**
      * Get configuration file paths for user and project settings
      * Returns paths in priority order (local.json first, then .json)

package/dist/managers/liveConfigManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"liveConfigManager.d.ts","sourceRoot":"","sources":["../../src/managers/liveConfigManager.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAehD,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sBAAsB,CAAC,EAAE,MAAM,IAAI,CAAC;IACpC,wBAAwB,CAAC,EAAE,CACzB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,KAAK,GAAG,QAAQ,GAAG,QAAQ,KACpC,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAC,CAAa;IACrD,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAC,CAGvB;IACnB,OAAO,CAAC,oBAAoB,CAAC,CAAuB;IACpD,OAAO,CAAC,aAAa,CAAkB;gBAE3B,OAAO,EAAE,wBAAwB;IAO7C;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IA2BjC;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAuB/B;;OAEG;YACW,8BAA8B;IAoB5C;;OAEG;YACW,6BAA6B;IA4B3C;;OAEG;IACH,OAAO,CAAC,yBAAyB;IA8BjC;;OAEG;YACW,2BAA2B;IA8BzC;;OAEG;IACH,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED;;;OAGG;IACH,OAAO,CAAC,qBAAqB;CAQ9B"}
+{"version":3,"file":"liveConfigManager.d.ts","sourceRoot":"","sources":["../../src/managers/liveConfigManager.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAKhD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAKhE,OAAO,KAAK,EAAE,iBAAiB,EAAoB,MAAM,mBAAmB,CAAC;AAE7E,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAK3E,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAC7C;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAc;IAC3C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAoB;IACvD,OAAO,CAAC,aAAa,CAAkB;IACvC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAuB;IAG5D,OAAO,CAAC,oBAAoB,CAAkC;IAC9D,OAAO,CAAC,sBAAsB,CAAkC;IAGhE,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,eAAe,CAAC,CAAW;IACnC,OAAO,CAAC,kBAAkB,CAAC,CAAW;IACtC,OAAO,CAAC,UAAU,CAAkB;IACpC,OAAO,CAAC,gBAAgB,CAAkB;gBAE9B,OAAO,EAAE,wBAAwB;IAW7C;;;;OAIG;YACW,kBAAkB;IA6DhC;;OAEG;IACH,uBAAuB,IAAI,iBAAiB,GAAG,IAAI;IAInD;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAuBjC;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAyB/B;;;OAGG;YACW,mBAAmB;IA8MjC;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAK1C;;OAEG;IACH,gBAAgB,IAAI,OAAO;IAI3B;;OAEG;IACH,gBAAgB;;;;;;;;;;;;IAgBhB,OAAO,CAAC,sBAAsB;YAMhB,gBAAgB;IA8C9B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IA0E7B,OAAO,CAAC,aAAa;IAuDrB;;;OAGG;IACH,OAAO,CAAC,qBAAqB;CAQ9B"}

package/dist/managers/liveConfigManager.js

@@ -3,150 +3,432 @@
  *
  * Orchestrates live configuration reload functionality including:
  * - Hook configuration watching and reloading
- * - Memory store management for AGENTS.md files
+ * - Configuration file watching for settings.json files
  * - Coordination between file watchers and configuration updates
  */
-import { ConfigurationWatcher, } from "../services/configurationWatcher.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";
+import { existsSync } from "fs";
+import { FileWatcherService, } from "../services/fileWatcher.js";
+import { getProjectConfigPaths, getUserConfigPaths, } from "../utils/configPaths.js";
+import { isValidHookEvent, isValidHookEventConfig } from "../types/hooks.js";
+import { ConfigurationService } from "../services/configurationService.js";
+import { ensureGlobalGitIgnore } from "../utils/fileUtils.js";
 export class LiveConfigManager {
     constructor(options) {
         this.isInitialized = false;
+        // Configuration state
+        this.currentConfiguration = null;
+        this.lastValidConfiguration = null;
+        this.isWatching = false;
+        this.reloadInProgress = false;
         this.workdir = options.workdir;
         this.logger = options.logger;
-        this.onConfigurationChanged = options.onConfigurationChanged;
-        this.onMemoryStoreFileChanged = options.onMemoryStoreFileChanged;
+        this.hookManager = options.hookManager;
+        this.permissionManager = options.permissionManager;
+        this.configurationService =
+            options.configurationService || new ConfigurationService();
+        this.fileWatcher = new FileWatcherService(this.logger);
+        this.setupFileWatcherEvents();
     }
     /**
-     * Initialize live configuration management
+     * Initialize configuration watching
+     * Maps to FR-004: System MUST watch settings.json files
+     * Supports watching multiple file paths (e.g., settings.local.json and settings.json)
+     */
+    async initializeWatching(userPaths, projectPaths) {
+        try {
+            this.logger?.info("Live Config: Initializing configuration watching...");
+            this.userConfigPaths = userPaths;
+            this.projectConfigPaths = projectPaths;
+            // Load initial configuration
+            await this.reloadConfiguration();
+            // Start watching user configs that exist
+            for (const userPath of userPaths) {
+                if (existsSync(userPath)) {
+                    this.logger?.debug(`Live Config: Starting to watch user config: ${userPath}`);
+                    await this.fileWatcher.watchFile(userPath, (event) => this.handleFileChange(event, "user"));
+                }
+                else {
+                    this.logger?.debug(`Live Config: User config file does not exist: ${userPath}`);
+                }
+            }
+            // Start watching project configs that exist
+            if (projectPaths) {
+                for (const projectPath of projectPaths) {
+                    if (existsSync(projectPath)) {
+                        if (projectPath.endsWith("settings.local.json")) {
+                            await ensureGlobalGitIgnore("**/.wave/settings.local.json");
+                        }
+                        this.logger?.debug(`Live Config: Starting to watch project config: ${projectPath}`);
+                        await this.fileWatcher.watchFile(projectPath, (event) => this.handleFileChange(event, "project"));
+                    }
+                    else {
+                        this.logger?.debug(`Live Config: Project config file does not exist: ${projectPath}`);
+                    }
+                }
+            }
+            this.isWatching = true;
+            this.logger?.info("Live Config: Configuration watching initialized successfully");
+        }
+        catch (error) {
+            const errorMessage = `Failed to initialize configuration watching: ${error.message}`;
+            this.logger?.error(`Live Config: ${errorMessage}`);
+            throw new Error(errorMessage);
+        }
+    }
+    /**
+     * Get current configuration
+     */
+    getCurrentConfiguration() {
+        return this.currentConfiguration ? { ...this.currentConfiguration } : null;
+    }
+    /**
+     * Initialize configuration management with file watching
      */
     async initialize() {
         if (this.isInitialized) {
-            this.logger?.debug("[LiveConfigManager] Already initialized");
+            this.logger?.debug("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();
-            }
+            // Get configuration file paths
+            const { userPaths, projectPaths } = this.getConfigurationPaths();
+            // Initialize configuration watching
+            await this.initializeWatching(userPaths, projectPaths);
             this.isInitialized = true;
-            this.logger?.info("Live Config: Live configuration management initialized successfully");
+            this.logger?.info("Live configuration management initialized with file watching");
         }
         catch (error) {
-            this.logger?.error(`Live Config: Failed to initialize: ${error.message}`);
+            this.logger?.error(`Failed to initialize: ${error.message}`);
             throw error;
         }
     }
     /**
-     * Shutdown live configuration management
+     * Shutdown configuration management and cleanup resources
      */
     async shutdown() {
         if (!this.isInitialized) {
             return;
         }
         try {
-            if (this.configurationWatcher) {
-                await this.configurationWatcher.shutdown();
-                this.configurationWatcher = undefined;
-            }
+            this.logger?.info("Live Config: Shutting down configuration manager...");
+            this.isWatching = false;
+            // Cleanup file watcher
+            await this.fileWatcher.cleanup();
+            // Clean up state
+            this.currentConfiguration = null;
+            this.lastValidConfiguration = null;
             this.isInitialized = false;
-            this.logger?.info("Live Config: Live configuration management shutdown completed");
+            this.logger?.info("Live configuration management shutdown completed");
         }
         catch (error) {
-            this.logger?.error(`Live Config: Error during shutdown: ${error.message}`);
+            this.logger?.error(`Error during shutdown: ${error.message}`);
             throw error;
         }
     }
     /**
-     * Initialize configuration watcher for hook settings
-     */
-    async initializeConfigurationWatcher() {
-        this.configurationWatcher = new ConfigurationWatcher(this.workdir, this.logger);
-        // Set up configuration change handler using EventEmitter pattern
-        this.configurationWatcher.on(CONFIGURATION_EVENTS.CONFIGURATION_CHANGE, (event) => {
-            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
+     * Reload configuration from files
+     * Maps to FR-008: Continue with previous valid configuration on errors
      */
-    async initializeMemoryStoreWatching() {
-        if (!this.onMemoryStoreFileChanged || !this.configurationWatcher) {
-            this.logger?.debug("Live Config: Memory store callback or configuration watcher not available, skipping AGENTS.md watching");
-            return;
+    async reloadConfiguration() {
+        if (this.reloadInProgress) {
+            this.logger?.debug("Live Config: Reload already in progress, skipping");
+            return this.currentConfiguration || {};
         }
+        this.reloadInProgress = true;
         try {
-            const agentsFilePath = join(this.workdir, "AGENTS.md");
-            // Add AGENTS.md to file watcher
-            await this.configurationWatcher.watchAdditionalFile(agentsFilePath, async (event) => {
-                await this.handleMemoryStoreFileChange(event);
-            });
-            this.logger?.info("Live Config: AGENTS.md file watching initialized");
+            this.logger?.debug("Live Config: Reloading configuration from files...");
+            // Load merged configuration using ConfigurationService
+            const loadResult = await this.configurationService.loadMergedConfiguration(this.workdir);
+            const newConfig = loadResult.configuration;
+            // Check for errors during loading
+            if (!loadResult.success) {
+                const errorMessage = loadResult.error || "Configuration loading failed with unknown error";
+                this.logger?.error(`Live Config: Configuration loading failed: ${errorMessage}`);
+                // Log warnings if any
+                if (loadResult.warnings && loadResult.warnings.length > 0) {
+                    this.logger?.warn(`Live Config: Configuration warnings: ${loadResult.warnings.join("; ")}`);
+                }
+                // Use fallback configuration if available
+                if (this.lastValidConfiguration) {
+                    this.logger?.info("Live Config: Using previous valid configuration due to loading errors");
+                    this.currentConfiguration = this.lastValidConfiguration;
+                    // Apply environment variables to configuration service if configured
+                    if (this.lastValidConfiguration.env) {
+                        this.configurationService.setEnvironmentVars(this.lastValidConfiguration.env);
+                    }
+                    // Update hook manager if available
+                    if (this.hookManager) {
+                        this.hookManager.loadConfigurationFromWaveConfig(this.lastValidConfiguration);
+                    }
+                    return this.currentConfiguration;
+                }
+                else {
+                    this.logger?.warn("Live Config: No previous valid configuration available, using empty config");
+                    this.currentConfiguration = {};
+                    return this.currentConfiguration;
+                }
+            }
+            // Log success with detailed information
+            if (newConfig) {
+                this.logger?.info(`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;
+                this.logger?.debug(`Live Config: Loaded ${hookCount} hook events and ${envCount} environment variables`);
+            }
+            else {
+                this.logger?.info("Live Config: No configuration found (using empty configuration)");
+            }
+            // Log warnings from successful loading
+            if (loadResult.warnings && loadResult.warnings.length > 0) {
+                this.logger?.warn(`Live Config: Configuration warnings: ${loadResult.warnings.join("; ")}`);
+            }
+            // Validate new configuration if it exists
+            if (newConfig) {
+                const validation = this.validateConfiguration(newConfig);
+                if (!validation.valid) {
+                    const errorMessage = `Configuration validation failed: ${validation.errors.join(", ")}`;
+                    this.logger?.error(`Live Config: ${errorMessage}`);
+                    // Use previous valid configuration for error recovery
+                    if (this.lastValidConfiguration) {
+                        this.logger?.info("Live Config: Using previous valid configuration due to validation errors");
+                        this.currentConfiguration = this.lastValidConfiguration;
+                        // Apply environment variables to configuration service if configured
+                        if (this.lastValidConfiguration.env) {
+                            this.configurationService.setEnvironmentVars(this.lastValidConfiguration.env);
+                        }
+                        // Update hook manager if available
+                        if (this.hookManager) {
+                            this.hookManager.loadConfigurationFromWaveConfig(this.lastValidConfiguration);
+                        }
+                        return this.currentConfiguration;
+                    }
+                    else {
+                        this.logger?.warn("Live Config: No previous valid configuration available, using empty config");
+                        this.currentConfiguration = {};
+                        return this.currentConfiguration;
+                    }
+                }
+            }
+            // Detect changes between old and new configuration
+            this.detectChanges(this.currentConfiguration, newConfig);
+            // Update current configuration
+            this.currentConfiguration = newConfig || {};
+            // Save as last valid configuration if it's valid and not empty
+            if (newConfig && (newConfig.hooks || newConfig.env)) {
+                this.lastValidConfiguration = { ...newConfig };
+                this.logger?.debug("Live Config: Saved current configuration as last valid backup");
+            }
+            // Note: Environment variables are already applied by loadMergedConfiguration()
+            // No need to set them again here as currentConfiguration === newConfig
+            // Update hook manager if available
+            if (this.hookManager) {
+                this.hookManager.loadConfigurationFromWaveConfig(this.currentConfiguration);
+            }
+            // Update permission manager if available
+            if (this.permissionManager) {
+                if (this.currentConfiguration.defaultMode) {
+                    this.permissionManager.updateConfiguredDefaultMode(this.currentConfiguration.defaultMode);
+                }
+                if (this.currentConfiguration.permissions?.allow) {
+                    this.permissionManager.updateAllowedRules(this.currentConfiguration.permissions.allow);
+                }
+            }
+            this.logger?.info(`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) {
-            this.logger?.warn(`Live Config: Failed to initialize AGENTS.md watching: ${error.message}`);
-            // Don't throw - memory optimization is not critical for core functionality
+            const errorMessage = `Configuration reload failed with exception: ${error.message}`;
+            this.logger?.error(`Live Config: ${errorMessage}`);
+            // Use previous valid configuration for error recovery
+            if (this.lastValidConfiguration) {
+                this.logger?.info("Live Config: Using previous valid configuration due to reload exception");
+                this.currentConfiguration = this.lastValidConfiguration;
+                // Apply environment variables to configuration service if configured
+                if (this.lastValidConfiguration.env) {
+                    this.configurationService.setEnvironmentVars(this.lastValidConfiguration.env);
+                }
+                // Update hook manager if available
+                if (this.hookManager) {
+                    this.hookManager.loadConfigurationFromWaveConfig(this.lastValidConfiguration);
+                }
+            }
+            else {
+                this.logger?.warn("Live Config: No previous valid configuration available, using empty config");
+                this.currentConfiguration = {};
+            }
+            return this.currentConfiguration;
+        }
+        finally {
+            this.reloadInProgress = false;
         }
     }
     /**
-     * Handle configuration change events
+     * Reload configuration from files (public method)
      */
-    handleConfigurationChange(event) {
-        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.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`);
-        }
+    async reload() {
+        this.logger?.info("Manually reloading configuration...");
+        return await this.reloadConfiguration();
     }
     /**
-     * Handle AGENTS.md file change events
+     * Check if watching is active
      */
-    async handleMemoryStoreFileChange(event) {
-        if (!this.onMemoryStoreFileChanged) {
-            return;
-        }
+    isWatchingActive() {
+        return this.isWatching;
+    }
+    /**
+     * Get watcher status for monitoring
+     */
+    getWatcherStatus() {
+        const statuses = this.fileWatcher.getAllWatcherStatuses();
+        return {
+            isActive: this.isWatching,
+            configurationLoaded: this.currentConfiguration !== null,
+            hasValidConfiguration: this.lastValidConfiguration !== null,
+            reloadInProgress: this.reloadInProgress,
+            watchedFiles: statuses.map((s) => ({
+                path: s.path,
+                isActive: s.isActive,
+                method: s.method,
+                errorCount: s.errorCount,
+            })),
+        };
+    }
+    setupFileWatcherEvents() {
+        this.fileWatcher.on("watcherError", (error) => {
+            this.logger?.error(`Live Config: File watcher error: ${error.message}`);
+        });
+    }
+    async handleFileChange(event, source) {
+        this.logger?.debug(`Live Config: File ${event.type} detected for ${source} config: ${event.path}`);
         try {
-            this.logger?.info(`Live Config: AGENTS.md ${event.type} detected: ${event.path}`);
-            const changeType = 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}`);
+            // Handle file deletion
+            if (event.type === "delete") {
+                this.logger?.info(`Live Config: ${source} config file deleted: ${event.path}`);
+                // Reload configuration without the deleted file
+                await this.reloadConfiguration();
+                return;
+            }
+            // Handle file creation or modification
+            if (event.type === "change" || event.type === "create") {
+                this.logger?.info(`Live Config: ${source} config file ${event.type}: ${event.path}`);
+                if (source === "project" &&
+                    event.path.endsWith("settings.local.json") &&
+                    event.type === "create") {
+                    await ensureGlobalGitIgnore("**/.wave/settings.local.json");
+                }
+                // Add small delay to ensure file write is complete
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                // Reload configuration
+                await this.reloadConfiguration();
+            }
         }
         catch (error) {
-            this.logger?.error(`Live Config: Failed to handle AGENTS.md file change: ${error.message}`);
+            this.logger?.error(`Live Config: Error handling file change for ${source} config: ${error.message}`);
         }
     }
     /**
-     * Get initialization status
+     * Validate configuration structure and content
      */
-    get initialized() {
-        return this.isInitialized;
+    validateConfiguration(config) {
+        const errors = [];
+        if (!config || typeof config !== "object") {
+            return { valid: false, errors: ["Configuration must be an object"] };
+        }
+        // Validate defaultMode if present
+        if (config.defaultMode !== undefined) {
+            if (config.defaultMode !== "default" &&
+                config.defaultMode !== "bypassPermissions" &&
+                config.defaultMode !== "acceptEdits") {
+                errors.push(`Invalid defaultMode: "${config.defaultMode}". Must be "default", "bypassPermissions" or "acceptEdits"`);
+            }
+        }
+        // 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 event configurations
+                    if (!Array.isArray(eventConfigs)) {
+                        errors.push(`Hook event ${eventName} must be an array of configurations`);
+                        continue;
+                    }
+                    eventConfigs.forEach((eventConfig, index) => {
+                        if (!isValidHookEventConfig(eventConfig)) {
+                            errors.push(`Invalid hook event configuration at ${eventName}[${index}]`);
+                        }
+                    });
+                }
+            }
+        }
+        // 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 {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    detectChanges(oldConfig, newConfig) {
+        const added = [];
+        const modified = [];
+        const removed = [];
+        // Handle environment variables changes
+        const oldEnv = oldConfig?.env || {};
+        const newEnv = newConfig?.env || {};
+        for (const key of Object.keys(newEnv)) {
+            if (!(key in oldEnv)) {
+                added.push(`env.${key}`);
+            }
+            else if (oldEnv[key] !== newEnv[key]) {
+                modified.push(`env.${key}`);
+            }
+        }
+        for (const key of Object.keys(oldEnv)) {
+            if (!(key in newEnv)) {
+                removed.push(`env.${key}`);
+            }
+        }
+        // Handle hooks changes (simplified)
+        const oldHooks = oldConfig?.hooks || {};
+        const newHooks = newConfig?.hooks || {};
+        for (const event of Object.keys(newHooks)) {
+            if (isValidHookEvent(event)) {
+                if (!(event in oldHooks)) {
+                    added.push(`hooks.${event}`);
+                }
+                else if (JSON.stringify(oldHooks[event]) !== JSON.stringify(newHooks[event])) {
+                    modified.push(`hooks.${event}`);
+                }
+            }
+        }
+        for (const event of Object.keys(oldHooks)) {
+            if (isValidHookEvent(event) && !(event in newHooks)) {
+                removed.push(`hooks.${event}`);
+            }
+        }
+        return { added, modified, removed };
     }
     /**
      * Get configuration file paths for user and project settings