vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/monitoring/file-monitor/file-monitor.js

@@ -0,0 +1,237 @@
+/**
+ * File Monitor - Main Module
+ * 
+ * Main orchestrator for file monitoring functionality.
+ * This file imports and coordinates the modular monitoring components.
+ */
+
+const { FileSystemWatcher } = require('./watcher');
+const { MonitoringFileAnalyzer } = require('./file-analyzer');
+const EventEmitter = require('events');
+
+/**
+ * File monitoring daemon
+ */
+class FileMonitor extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.options = {
+      lineLimit: 555,
+      checkConstitutional: true,
+      checkCommonIssues: true,
+      cacheTimeout: 30000,
+      ...options
+    };
+    
+    this.watcher = new FileSystemWatcher(options);
+    this.analyzer = new MonitoringFileAnalyzer(this.options);
+    this.isRunning = false;
+    this.monitoredPaths = new Set();
+    
+    this.setupWatcherEvents();
+  }
+
+  /**
+   * Start monitoring the specified paths
+   */
+  async start(watchPaths) {
+    if (this.isRunning) {
+      throw new Error('Monitor is already running');
+    }
+
+    try {
+      await this.watcher.start(watchPaths);
+      this.isRunning = true;
+      watchPaths.forEach(p => this.monitoredPaths.add(p));
+      
+      this.emit('started', { 
+        paths: this.monitoredPaths,
+        options: this.options 
+      });
+      
+    } catch (error) {
+      throw new Error(`Failed to start file monitor: ${error.message}`);
+    }
+  }
+
+  /**
+   * Stop monitoring
+   */
+  async stop() {
+    if (!this.isRunning) {
+      return;
+    }
+
+    try {
+      await this.watcher.stop();
+      this.isRunning = false;
+      this.monitoredPaths.clear();
+      
+      this.emit('stopped');
+    } catch (error) {
+      throw new Error(`Failed to stop file monitor: ${error.message}`);
+    }
+  }
+
+  /**
+   * Add a path to monitor
+   */
+  async addPath(watchPath) {
+    if (!this.isRunning) {
+      throw new Error('Monitor is not running');
+    }
+
+    try {
+      await this.watcher.addPath(watchPath);
+      this.monitoredPaths.add(watchPath);
+      
+      this.emit('pathAdded', { path: watchPath });
+    } catch (error) {
+      throw new Error(`Failed to add path ${watchPath}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Remove a path from monitoring
+   */
+  async removePath(watchPath) {
+    if (!this.isRunning) {
+      return;
+    }
+
+    try {
+      await this.watcher.removePath(watchPath);
+      this.monitoredPaths.delete(watchPath);
+      
+      this.emit('pathRemoved', { path: watchPath });
+    } catch (error) {
+      throw new Error(`Failed to remove path ${watchPath}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get current monitoring status
+   */
+  getStatus() {
+    return {
+      isRunning: this.isRunning,
+      monitoredPaths: Array.from(this.monitoredPaths),
+      options: this.options,
+      watcherStatus: this.watcher.getStatus(),
+      analyzerStats: this.analyzer.getCacheStats()
+    };
+  }
+
+  /**
+   * Setup event handlers for the watcher
+   */
+  setupWatcherEvents() {
+    // Handle file changes
+    this.watcher.on('fileChanged', async (event) => {
+      try {
+        const analysis = await this.analyzer.analyzeFile(event.path, 'change');
+        
+        this.emit('fileAnalyzed', {
+          ...event,
+          analysis
+        });
+        
+        // Emit specific events for issues
+        if (!analysis.compliant) {
+          this.emit('complianceIssue', {
+            ...event,
+            analysis
+          });
+        }
+        
+      } catch (error) {
+        this.emit('analysisError', {
+          ...event,
+          error: error.message
+        });
+      }
+    });
+
+    // Handle new files
+    this.watcher.on('fileAdded', async (event) => {
+      try {
+        const analysis = await this.analyzer.analyzeFile(event.path, 'add');
+        
+        this.emit('fileAnalyzed', {
+          ...event,
+          analysis
+        });
+        
+        if (!analysis.compliant) {
+          this.emit('complianceIssue', {
+            ...event,
+            analysis
+          });
+        }
+        
+      } catch (error) {
+        this.emit('analysisError', {
+          ...event,
+          error: error.message
+        });
+      }
+    });
+
+    // Handle file removal
+    this.watcher.on('fileRemoved', (event) => {
+      this.emit('fileRemoved', event);
+      
+      // Clear analysis cache for removed file
+      this.analyzer.clearCache();
+    });
+
+    // Handle watcher errors
+    this.watcher.on('error', (error) => {
+      this.emit('error', error);
+    });
+
+    // Handle watcher lifecycle events
+    this.watcher.on('started', (event) => {
+      this.emit('watcherStarted', event);
+    });
+
+    this.watcher.on('stopped', () => {
+      this.emit('watcherStopped');
+    });
+  }
+
+  /**
+   * Analyze a specific file on demand
+   */
+  async analyzeFile(filePath) {
+    try {
+      const analysis = await this.analyzer.analyzeFile(filePath, 'manual');
+      
+      this.emit('fileAnalyzed', {
+        path: filePath,
+        stats: null,
+        type: 'file',
+        analysis
+      });
+      
+      return analysis;
+    } catch (error) {
+      this.emit('analysisError', {
+        path: filePath,
+        error: error.message
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * Clear the analysis cache
+   */
+  clearCache() {
+    this.analyzer.clearCache();
+    this.emit('cacheCleared');
+  }
+}
+
+module.exports = FileMonitor;

package/src/monitoring/file-monitor/watcher.js

@@ -0,0 +1,194 @@
+/**
+ * File System Watcher
+ * 
+ * Handles the core file system watching functionality using chokidar.
+ */
+
+const chokidar = require('chokidar');
+const EventEmitter = require('events');
+const path = require('path');
+
+/**
+ * File system watcher class
+ */
+class FileSystemWatcher extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.options = {
+      ignored: [
+        '**/node_modules/**',
+        '**/.git/**',
+        '**/dist/**',
+        '**/build/**',
+        '**/coverage/**',
+        '**/.nyc_output/**',
+        '**/*.log',
+        '**/*.tmp',
+        '**/*.cache'
+      ],
+      persistent: true,
+      ignoreInitial: false,
+      followSymlinks: false,
+      cwd: options.cwd || process.cwd(),
+      ...options
+    };
+    
+    this.watcher = null;
+    this.isWatching = false;
+    this.watchedPaths = new Set();
+  }
+
+  /**
+   * Start watching the specified paths
+   */
+  async start(watchPaths) {
+    if (this.isWatching) {
+      throw new Error('Watcher is already running');
+    }
+
+    const paths = Array.isArray(watchPaths) ? watchPaths : [watchPaths];
+    
+    try {
+      this.watcher = chokidar.watch(paths, this.options);
+      
+      this.setupEventHandlers();
+      
+      await new Promise((resolve, reject) => {
+        this.watcher.on('ready', () => {
+          this.isWatching = true;
+          paths.forEach(p => this.watchedPaths.add(path.resolve(p)));
+          this.emit('started', { paths: this.watchedPaths });
+          resolve();
+        });
+        
+        this.watcher.on('error', reject);
+      });
+      
+    } catch (error) {
+      throw new Error(`Failed to start watcher: ${error.message}`);
+    }
+  }
+
+  /**
+   * Stop watching
+   */
+  async stop() {
+    if (!this.isWatching || !this.watcher) {
+      return;
+    }
+
+    try {
+      await this.watcher.close();
+      this.isWatching = false;
+      this.watchedPaths.clear();
+      this.emit('stopped');
+    } catch (error) {
+      throw new Error(`Failed to stop watcher: ${error.message}`);
+    }
+  }
+
+  /**
+   * Add a path to watch
+   */
+  async addPath(watchPath) {
+    if (!this.isWatching) {
+      throw new Error('Watcher is not running');
+    }
+
+    const resolvedPath = path.resolve(watchPath);
+    
+    if (this.watchedPaths.has(resolvedPath)) {
+      return;
+    }
+
+    try {
+      await this.watcher.add(resolvedPath);
+      this.watchedPaths.add(resolvedPath);
+      this.emit('pathAdded', { path: resolvedPath });
+    } catch (error) {
+      throw new Error(`Failed to add path ${watchPath}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Remove a path from watching
+   */
+  async removePath(watchPath) {
+    if (!this.isWatching) {
+      return;
+    }
+
+    const resolvedPath = path.resolve(watchPath);
+    
+    if (!this.watchedPaths.has(resolvedPath)) {
+      return;
+    }
+
+    try {
+      await this.watcher.unwatch(resolvedPath);
+      this.watchedPaths.delete(resolvedPath);
+      this.emit('pathRemoved', { path: resolvedPath });
+    } catch (error) {
+      throw new Error(`Failed to remove path ${watchPath}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get current watch status
+   */
+  getStatus() {
+    return {
+      isWatching: this.isWatching,
+      watchedPaths: Array.from(this.watchedPaths),
+      options: this.options
+    };
+  }
+
+  /**
+   * Setup event handlers for the chokidar watcher
+   */
+  setupEventHandlers() {
+    this.watcher
+      .on('add', (filePath, stats) => {
+        this.emit('fileAdded', { 
+          path: filePath, 
+          stats,
+          type: 'file'
+        });
+      })
+      .on('addDir', (dirPath, stats) => {
+        this.emit('directoryAdded', { 
+          path: dirPath, 
+          stats,
+          type: 'directory'
+        });
+      })
+      .on('change', (filePath, stats) => {
+        this.emit('fileChanged', { 
+          path: filePath, 
+          stats,
+          type: 'file'
+        });
+      })
+      .on('unlink', (filePath) => {
+        this.emit('fileRemoved', { 
+          path: filePath,
+          type: 'file'
+        });
+      })
+      .on('unlinkDir', (dirPath) => {
+        this.emit('directoryRemoved', { 
+          path: dirPath,
+          type: 'directory'
+        });
+      })
+      .on('error', (error) => {
+        this.emit('error', error);
+      });
+  }
+}
+
+module.exports = {
+  FileSystemWatcher
+};

package/src/monitoring/file-monitor.js

@@ -0,0 +1,17 @@
+/**
+ * File Monitor - Main Module
+ * 
+ * Main orchestrator for file monitoring functionality.
+ * This file imports and coordinates the modular monitoring components.
+ */
+
+const FileMonitor = require('./file-monitor/file-monitor');
+const { FileSystemWatcher } = require('./file-monitor/watcher');
+const { MonitoringFileAnalyzer } = require('./file-monitor/file-analyzer');
+
+// Re-export all classes for backward compatibility
+module.exports = FileMonitor;
+
+// Also export individual components for advanced usage
+module.exports.FileSystemWatcher = FileSystemWatcher;
+module.exports.MonitoringFileAnalyzer = MonitoringFileAnalyzer;