thuban 0.3.2 → 0.3.3

package/packages/scanner/file-watcher.js

@@ -1,323 +1,323 @@
-/**
- * File Watcher
- *
- * @purpose Event-driven FileWatcher component
- * @module sentinel
- * @layer application
- * @imports-from fs, path, events
- * @exports-to sentinel
- * @side-effects File system reads, Console output, Event emission
- * @critical-for sentinel
- */
-
-/**
- * Sentinel File Watcher
- *
- * Real-time file system monitoring for the Orion codebase.
- * Detects file changes, additions, and deletions to trigger scans.
- */
-
-const fs = require('fs');
-const path = require('path');
-const EventEmitter = require('events');
-
-class FileWatcher extends EventEmitter {
-  constructor(config = {}) {
-    super();
-
-    this.config = {
-      rootPath: config.rootPath || process.cwd(),
-      watchPatterns: config.watchPatterns || ['**/*.js', '**/*.ts', '**/*.json'],
-      ignorePatterns: config.ignorePatterns || [
-        'node_modules/**',
-        '.git/**',
-        'dist/**',
-        'build/**',
-        '.orion/snapshots/**',
-        'coverage/**',
-        '*.log'
-      ],
-      debounceMs: config.debounceMs || 300,
-      ...config
-    };
-
-    this.watchers = [];
-    this.watchedFiles = new Set();
-    this.debounceTimers = new Map();
-    this.isRunning = false;
-  }
-
-  /**
-   * Start watching files
-   */
-  async start() {
-    if (this.isRunning) {
-      return { success: true, message: 'Already watching' };
-    }
-
-    console.log('[FILE-WATCHER] Starting file watcher...');
-    console.log(`[FILE-WATCHER] Root path: ${this.config.rootPath}`);
-
-    try {
-      // Discover files to watch
-      await this._discoverFiles(this.config.rootPath);
-
-      // Set up watchers
-      this._setupWatchers();
-
-      this.isRunning = true;
-      console.log(`[FILE-WATCHER] Watching ${this.watchedFiles.size} files`);
-
-      return {
-        success: true,
-        filesWatched: this.watchedFiles.size
-      };
-    } catch (error) {
-      console.error('[FILE-WATCHER] Start failed:', error.message);
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
-   * Stop watching files
-   */
-  async stop() {
-    console.log('[FILE-WATCHER] Stopping file watcher...');
-
-    // Close all watchers
-    for (const watcher of this.watchers) {
-      try {
-        watcher.close();
-      } catch (e) {
-        // Ignore close errors
-      }
-    }
-
-    // Clear debounce timers
-    for (const timer of this.debounceTimers.values()) {
-      clearTimeout(timer);
-    }
-
-    this.watchers = [];
-    this.debounceTimers.clear();
-    this.isRunning = false;
-
-    console.log('[FILE-WATCHER] Stopped');
-    return { success: true };
-  }
-
-  /**
-   * Get count of watched files
-   */
-  getWatchedCount() {
-    return this.watchedFiles.size;
-  }
-
-  /**
-   * Get list of watched files
-   */
-  getWatchedFiles() {
-    return Array.from(this.watchedFiles);
-  }
-
-  /**
-   * Check if a file path should be ignored
-   */
-  shouldIgnore(filePath) {
-    const relativePath = path.relative(this.config.rootPath, filePath);
-
-    for (const pattern of this.config.ignorePatterns) {
-      if (this._matchPattern(relativePath, pattern)) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  /**
-   * Check if a file path matches watch patterns
-   */
-  shouldWatch(filePath) {
-    const relativePath = path.relative(this.config.rootPath, filePath);
-
-    // First check if ignored
-    if (this.shouldIgnore(filePath)) {
-      return false;
-    }
-
-    // Then check if matches watch patterns
-    for (const pattern of this.config.watchPatterns) {
-      if (this._matchPattern(relativePath, pattern)) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  // Private methods
-
-  async _discoverFiles(dir) {
-    try {
-      const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-      for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-
-        // Skip ignored directories early
-        if (entry.isDirectory()) {
-          if (!this.shouldIgnore(fullPath)) {
-            await this._discoverFiles(fullPath);
-          }
-        } else if (entry.isFile()) {
-          if (this.shouldWatch(fullPath)) {
-            this.watchedFiles.add(fullPath);
-          }
-        }
-      }
-    } catch (error) {
-      // Directory might not exist or be inaccessible
-      if (error.code !== 'ENOENT' && error.code !== 'EACCES') {
-        console.warn(`[FILE-WATCHER] Error scanning ${dir}:`, error.message);
-      }
-    }
-  }
-
-  _setupWatchers() {
-    // Group files by directory for efficient watching
-    const directories = new Set();
-    for (const file of this.watchedFiles) {
-      directories.add(path.dirname(file));
-    }
-
-    // Watch each directory
-    for (const dir of directories) {
-      try {
-        const watcher = fs.watch(dir, { persistent: true }, (eventType, filename) => {
-          if (filename) {
-            const fullPath = path.join(dir, filename);
-            this._handleFileEvent(eventType, fullPath);
-          }
-        });
-
-        watcher.on('error', (error) => {
-          console.warn(`[FILE-WATCHER] Watcher error for ${dir}:`, error.message);
-        });
-
-        this.watchers.push(watcher);
-      } catch (error) {
-        console.warn(`[FILE-WATCHER] Could not watch ${dir}:`, error.message);
-      }
-    }
-
-    // Also set up a recursive watcher for the root (if supported)
-    try {
-      const rootWatcher = fs.watch(this.config.rootPath, { recursive: true }, (eventType, filename) => {
-        if (filename) {
-          const fullPath = path.join(this.config.rootPath, filename);
-          this._handleFileEvent(eventType, fullPath);
-        }
-      });
-
-      rootWatcher.on('error', (error) => {
-        // Recursive watch might not be supported on all platforms
-        if (error.code !== 'ERR_FEATURE_UNAVAILABLE_ON_PLATFORM') {
-          console.warn('[FILE-WATCHER] Root watcher error:', error.message);
-        }
-      });
-
-      this.watchers.push(rootWatcher);
-    } catch (error) {
-      // Recursive watching might not be available
-    }
-  }
-
-  _handleFileEvent(eventType, filePath) {
-    // Skip if ignored
-    if (this.shouldIgnore(filePath)) {
-      return;
-    }
-
-    // Debounce rapid events
-    if (this.debounceTimers.has(filePath)) {
-      clearTimeout(this.debounceTimers.get(filePath));
-    }
-
-    this.debounceTimers.set(filePath, setTimeout(() => {
-      this.debounceTimers.delete(filePath);
-      this._processFileEvent(eventType, filePath);
-    }, this.config.debounceMs));
-  }
-
-  _processFileEvent(eventType, filePath) {
-    // Check if file exists
-    const exists = fs.existsSync(filePath);
-    const isFile = exists && fs.statSync(filePath).isFile();
-
-    let event;
-
-    if (!exists) {
-      // File was deleted
-      if (this.watchedFiles.has(filePath)) {
-        this.watchedFiles.delete(filePath);
-        event = {
-          type: 'delete',
-          filePath,
-          timestamp: new Date().toISOString()
-        };
-      }
-    } else if (isFile && this.shouldWatch(filePath)) {
-      if (this.watchedFiles.has(filePath)) {
-        // File was modified
-        event = {
-          type: 'change',
-          filePath,
-          timestamp: new Date().toISOString()
-        };
-      } else {
-        // New file added
-        this.watchedFiles.add(filePath);
-        event = {
-          type: 'add',
-          filePath,
-          timestamp: new Date().toISOString()
-        };
-      }
-    }
-
-    if (event) {
-      this.emit(event.type, event);
-      this.emit('any', event);
-    }
-  }
-
-  _matchPattern(filePath, pattern) {
-    // Simple glob-like pattern matching
-    // Supports: *, **, ?
-
-    // Normalize separators
-    const normalizedPath = filePath.replace(/\\/g, '/');
-    const normalizedPattern = pattern.replace(/\\/g, '/');
-
-    // Convert glob pattern to regex
-    let regexPattern = normalizedPattern
-      .replace(/\./g, '\\.')           // Escape dots
-      .replace(/\*\*/g, '<<<GLOBSTAR>>>')  // Temporarily replace **
-      .replace(/\*/g, '[^/]*')         // * matches anything except /
-      .replace(/<<<GLOBSTAR>>>/g, '.*') // ** matches anything including /
-      .replace(/\?/g, '.');            // ? matches single char
-
-    // Anchor the pattern
-    regexPattern = '^' + regexPattern + '$';
-
-    try {
-      const regex = new RegExp(regexPattern);
-      return regex.test(normalizedPath);
-    } catch (e) {
-      return false;
-    }
-  }
-}
-
-module.exports = FileWatcher;
+/**
+ * File Watcher
+ *
+ * @purpose Event-driven FileWatcher component
+ * @module sentinel
+ * @layer application
+ * @imports-from fs, path, events
+ * @exports-to sentinel
+ * @side-effects File system reads, Console output, Event emission
+ * @critical-for sentinel
+ */
+
+/**
+ * Sentinel File Watcher
+ *
+ * Real-time file system monitoring for the Orion codebase.
+ * Detects file changes, additions, and deletions to trigger scans.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const EventEmitter = require('events');
+
+class FileWatcher extends EventEmitter {
+  constructor(config = {}) {
+    super();
+
+    this.config = {
+      rootPath: config.rootPath || process.cwd(),
+      watchPatterns: config.watchPatterns || ['**/*.js', '**/*.ts', '**/*.json'],
+      ignorePatterns: config.ignorePatterns || [
+        'node_modules/**',
+        '.git/**',
+        'dist/**',
+        'build/**',
+        '.orion/snapshots/**',
+        'coverage/**',
+        '*.log'
+      ],
+      debounceMs: config.debounceMs || 300,
+      ...config
+    };
+
+    this.watchers = [];
+    this.watchedFiles = new Set();
+    this.debounceTimers = new Map();
+    this.isRunning = false;
+  }
+
+  /**
+   * Start watching files
+   */
+  async start() {
+    if (this.isRunning) {
+      return { success: true, message: 'Already watching' };
+    }
+
+    console.log('[FILE-WATCHER] Starting file watcher...');
+    console.log(`[FILE-WATCHER] Root path: ${this.config.rootPath}`);
+
+    try {
+      // Discover files to watch
+      await this._discoverFiles(this.config.rootPath);
+
+      // Set up watchers
+      this._setupWatchers();
+
+      this.isRunning = true;
+      console.log(`[FILE-WATCHER] Watching ${this.watchedFiles.size} files`);
+
+      return {
+        success: true,
+        filesWatched: this.watchedFiles.size
+      };
+    } catch (error) {
+      console.error('[FILE-WATCHER] Start failed:', error.message);
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Stop watching files
+   */
+  async stop() {
+    console.log('[FILE-WATCHER] Stopping file watcher...');
+
+    // Close all watchers
+    for (const watcher of this.watchers) {
+      try {
+        watcher.close();
+      } catch (e) {
+        // Ignore close errors
+      }
+    }
+
+    // Clear debounce timers
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+
+    this.watchers = [];
+    this.debounceTimers.clear();
+    this.isRunning = false;
+
+    console.log('[FILE-WATCHER] Stopped');
+    return { success: true };
+  }
+
+  /**
+   * Get count of watched files
+   */
+  getWatchedCount() {
+    return this.watchedFiles.size;
+  }
+
+  /**
+   * Get list of watched files
+   */
+  getWatchedFiles() {
+    return Array.from(this.watchedFiles);
+  }
+
+  /**
+   * Check if a file path should be ignored
+   */
+  shouldIgnore(filePath) {
+    const relativePath = path.relative(this.config.rootPath, filePath);
+
+    for (const pattern of this.config.ignorePatterns) {
+      if (this._matchPattern(relativePath, pattern)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Check if a file path matches watch patterns
+   */
+  shouldWatch(filePath) {
+    const relativePath = path.relative(this.config.rootPath, filePath);
+
+    // First check if ignored
+    if (this.shouldIgnore(filePath)) {
+      return false;
+    }
+
+    // Then check if matches watch patterns
+    for (const pattern of this.config.watchPatterns) {
+      if (this._matchPattern(relativePath, pattern)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  // Private methods
+
+  async _discoverFiles(dir) {
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+
+        // Skip ignored directories early
+        if (entry.isDirectory()) {
+          if (!this.shouldIgnore(fullPath)) {
+            await this._discoverFiles(fullPath);
+          }
+        } else if (entry.isFile()) {
+          if (this.shouldWatch(fullPath)) {
+            this.watchedFiles.add(fullPath);
+          }
+        }
+      }
+    } catch (error) {
+      // Directory might not exist or be inaccessible
+      if (error.code !== 'ENOENT' && error.code !== 'EACCES') {
+        console.warn(`[FILE-WATCHER] Error scanning ${dir}:`, error.message);
+      }
+    }
+  }
+
+  _setupWatchers() {
+    // Group files by directory for efficient watching
+    const directories = new Set();
+    for (const file of this.watchedFiles) {
+      directories.add(path.dirname(file));
+    }
+
+    // Watch each directory
+    for (const dir of directories) {
+      try {
+        const watcher = fs.watch(dir, { persistent: true }, (eventType, filename) => {
+          if (filename) {
+            const fullPath = path.join(dir, filename);
+            this._handleFileEvent(eventType, fullPath);
+          }
+        });
+
+        watcher.on('error', (error) => {
+          console.warn(`[FILE-WATCHER] Watcher error for ${dir}:`, error.message);
+        });
+
+        this.watchers.push(watcher);
+      } catch (error) {
+        console.warn(`[FILE-WATCHER] Could not watch ${dir}:`, error.message);
+      }
+    }
+
+    // Also set up a recursive watcher for the root (if supported)
+    try {
+      const rootWatcher = fs.watch(this.config.rootPath, { recursive: true }, (eventType, filename) => {
+        if (filename) {
+          const fullPath = path.join(this.config.rootPath, filename);
+          this._handleFileEvent(eventType, fullPath);
+        }
+      });
+
+      rootWatcher.on('error', (error) => {
+        // Recursive watch might not be supported on all platforms
+        if (error.code !== 'ERR_FEATURE_UNAVAILABLE_ON_PLATFORM') {
+          console.warn('[FILE-WATCHER] Root watcher error:', error.message);
+        }
+      });
+
+      this.watchers.push(rootWatcher);
+    } catch (error) {
+      // Recursive watching might not be available
+    }
+  }
+
+  _handleFileEvent(eventType, filePath) {
+    // Skip if ignored
+    if (this.shouldIgnore(filePath)) {
+      return;
+    }
+
+    // Debounce rapid events
+    if (this.debounceTimers.has(filePath)) {
+      clearTimeout(this.debounceTimers.get(filePath));
+    }
+
+    this.debounceTimers.set(filePath, setTimeout(() => {
+      this.debounceTimers.delete(filePath);
+      this._processFileEvent(eventType, filePath);
+    }, this.config.debounceMs));
+  }
+
+  _processFileEvent(eventType, filePath) {
+    // Check if file exists
+    const exists = fs.existsSync(filePath);
+    const isFile = exists && fs.statSync(filePath).isFile();
+
+    let event;
+
+    if (!exists) {
+      // File was deleted
+      if (this.watchedFiles.has(filePath)) {
+        this.watchedFiles.delete(filePath);
+        event = {
+          type: 'delete',
+          filePath,
+          timestamp: new Date().toISOString()
+        };
+      }
+    } else if (isFile && this.shouldWatch(filePath)) {
+      if (this.watchedFiles.has(filePath)) {
+        // File was modified
+        event = {
+          type: 'change',
+          filePath,
+          timestamp: new Date().toISOString()
+        };
+      } else {
+        // New file added
+        this.watchedFiles.add(filePath);
+        event = {
+          type: 'add',
+          filePath,
+          timestamp: new Date().toISOString()
+        };
+      }
+    }
+
+    if (event) {
+      this.emit(event.type, event);
+      this.emit('any', event);
+    }
+  }
+
+  _matchPattern(filePath, pattern) {
+    // Simple glob-like pattern matching
+    // Supports: *, **, ?
+
+    // Normalize separators
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    const normalizedPattern = pattern.replace(/\\/g, '/');
+
+    // Convert glob pattern to regex
+    let regexPattern = normalizedPattern
+      .replace(/\./g, '\\.')           // Escape dots
+      .replace(/\*\*/g, '<<<GLOBSTAR>>>')  // Temporarily replace **
+      .replace(/\*/g, '[^/]*')         // * matches anything except /
+      .replace(/<<<GLOBSTAR>>>/g, '.*') // ** matches anything including /
+      .replace(/\?/g, '.');            // ? matches single char
+
+    // Anchor the pattern
+    regexPattern = '^' + regexPattern + '$';
+
+    try {
+      const regex = new RegExp(regexPattern);
+      return regex.test(normalizedPath);
+    } catch (e) {
+      return false;
+    }
+  }
+}
+
+module.exports = FileWatcher;