vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/monitoring/scanner-core.js

@@ -0,0 +1,368 @@
+/**
+ * Scanner Core
+ * 
+ * Core scanning functionality for continuous repository monitoring.
+ */
+
+const EventEmitter = require('events');
+const fs = require('fs');
+const path = require('path');
+const chokidar = require('chokidar');
+
+const { LineLimitValidator } = require('../validation/line-limit-validator');
+const { ConstitutionValidator } = require('../validation/constitution-validator');
+
+/**
+ * Scanner Core Class
+ */
+class ScannerCore extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.options = {
+      scanInterval: options.scanInterval || 60000, // 1 minute
+      debounceDelay: options.debounceDelay || 1000, // 1 second
+      excludePatterns: options.excludePatterns || [
+        /node_modules/,
+        /\.git/,
+        /dist/,
+        /build/,
+        /coverage/,
+        /\.log$/,
+        /\.tmp/
+      ],
+      includePatterns: options.includePatterns || [],
+      maxFileSize: options.maxFileSize || 555,
+      ...options
+    };
+    
+    this.isRunning = false;
+    this.watcher = null;
+    this.scanTimer = null;
+    this.debounceTimer = null;
+    this.scanResults = new Map();
+    this.lineValidator = new LineLimitValidator({ limit: this.options.maxFileSize });
+    this.constitutionValidator = new ConstitutionValidator({
+      excludePatterns: this.options.excludePatterns,
+      includePatterns: this.options.includePatterns,
+      maxFileSize: this.options.maxFileSize
+    });
+  }
+
+  /**
+   * Start continuous scanning
+   */
+  start() {
+    if (this.isRunning) {
+      this.emit('warning', 'Scanner is already running');
+      return;
+    }
+
+    this.isRunning = true;
+    this.emit('started');
+    
+    // Setup file watcher
+    this._setupWatcher();
+    
+    // Perform initial scan
+    this._performScan();
+    
+    // Setup periodic scanning
+    this.scanTimer = setInterval(() => {
+      this._performScan();
+    }, this.options.scanInterval);
+  }
+
+  /**
+   * Stop continuous scanning
+   */
+  stop() {
+    if (!this.isRunning) {
+      return;
+    }
+
+    this.isRunning = false;
+    
+    // Clear timers
+    if (this.scanTimer) {
+      clearInterval(this.scanTimer);
+      this.scanTimer = null;
+    }
+    
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    
+    // Close watcher
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    
+    this.emit('stopped');
+  }
+
+  /**
+   * Perform immediate scan
+   */
+  async scanNow() {
+    return this._performScan();
+  }
+
+  /**
+   * Get current scan results
+   */
+  getResults() {
+    return new Map(this.scanResults);
+  }
+
+  /**
+   * Get violations (files exceeding limits)
+   */
+  getViolations() {
+    const violations = [];
+    
+    for (const [filePath, result] of this.scanResults) {
+      if (result.violations && result.violations.length > 0) {
+        violations.push({
+          file: filePath,
+          violations: result.violations,
+          lastScanned: result.lastScanned
+        });
+      }
+    }
+    
+    return violations.sort((a, b) => b.violations.length - a.violations.length);
+  }
+
+  /**
+   * Setup file watcher
+   */
+  _setupWatcher() {
+    const watchPaths = this.options.watchPaths || [process.cwd()];
+    
+    this.watcher = chokidar.watch(watchPaths, {
+      ignored: this.options.excludePatterns,
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 2000,
+        pollInterval: 100
+      }
+    });
+    
+    this.watcher.on('add', (filePath) => {
+      this._debounceScan('file_added', filePath);
+    });
+    
+    this.watcher.on('change', (filePath) => {
+      this._debounceScan('file_changed', filePath);
+    });
+    
+    this.watcher.on('unlink', (filePath) => {
+      this.scanResults.delete(filePath);
+      this.emit('file_removed', filePath);
+    });
+    
+    this.watcher.on('error', (error) => {
+      this.emit('error', `Watcher error: ${error.message}`);
+    });
+  }
+
+  /**
+   * Debounce scan to avoid too frequent scans
+   */
+  _debounceScan(event, filePath) {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    
+    this.debounceTimer = setTimeout(() => {
+      this._performScan();
+      this.emit('event', { type: event, file: filePath });
+    }, this.options.debounceDelay);
+  }
+
+  /**
+   * Perform actual scan
+   */
+  async _performScan() {
+    try {
+      const startTime = Date.now();
+      const results = await this._scanDirectory(process.cwd());
+      const scanTime = Date.now() - startTime;
+      
+      // Update results
+      this.scanResults = results;
+      
+      // Calculate statistics
+      const stats = this._calculateStats(results);
+      
+      this.emit('scan_completed', {
+        timestamp: new Date().toISOString(),
+        scanTime,
+        stats,
+        violations: this.getViolations()
+      });
+      
+    } catch (error) {
+      this.emit('error', `Scan failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Scan directory for files
+   */
+  async _scanDirectory(dirPath) {
+    const results = new Map();
+    
+    if (!fs.existsSync(dirPath)) {
+      return results;
+    }
+    
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name);
+      
+      if (entry.isDirectory()) {
+        // Skip excluded directories
+        if (this._shouldExclude(fullPath)) continue;
+        
+        // Recursively scan subdirectory
+        const subResults = await this._scanDirectory(fullPath);
+        for (const [filePath, result] of subResults) {
+          results.set(filePath, result);
+        }
+      } else if (entry.isFile()) {
+        // Skip excluded files
+        if (this._shouldExclude(fullPath)) continue;
+        
+        // Scan file
+        const result = await this._scanFile(fullPath);
+        results.set(fullPath, result);
+      }
+    }
+    
+    return results;
+  }
+
+  /**
+   * Scan individual file
+   */
+  async _scanFile(filePath) {
+    try {
+      const stat = fs.statSync(filePath);
+      const result = {
+        lastScanned: new Date().toISOString(),
+        size: stat.size,
+        violations: []
+      };
+      
+      // Check line limit
+      const lineResult = this.lineValidator.validateFile(filePath);
+      if (lineResult.length > 0) {
+        result.violations.push(...lineResult);
+      }
+      
+      // Check constitutional compliance
+      const complianceResult = this.constitutionValidator.validateFile(filePath);
+      if (complianceResult.length > 0) {
+        result.violations.push(...complianceResult);
+      }
+      
+      return result;
+      
+    } catch (error) {
+      return {
+        lastScanned: new Date().toISOString(),
+        violations: [{
+          rule: 'scan_error',
+          category: 'system',
+          severity: 'error',
+          message: `Failed to scan file: ${error.message}`,
+          line: 0,
+          column: 0
+        }]
+      };
+    }
+  }
+
+  /**
+   * Check if path should be excluded
+   */
+  _shouldExclude(filePath) {
+    const relativePath = path.relative(process.cwd(), filePath);
+    
+    // Check exclude patterns
+    for (const pattern of this.options.excludePatterns) {
+      if (pattern.test(filePath) || pattern.test(relativePath)) {
+        return true;
+      }
+    }
+    
+    // Check include patterns (if specified)
+    if (this.options.includePatterns.length > 0) {
+      for (const pattern of this.options.includePatterns) {
+        if (pattern.test(filePath) || pattern.test(relativePath)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    
+    return false;
+  }
+
+  /**
+   * Calculate scan statistics
+   */
+  _calculateStats(results) {
+    const stats = {
+      totalFiles: results.size,
+      compliantFiles: 0,
+      nonCompliantFiles: 0,
+      totalViolations: 0,
+      violationsByType: {},
+      averageFileSize: 0,
+      largestFile: null,
+      scanTime: 0
+    };
+    
+    let totalSize = 0;
+    let largestSize = 0;
+    let largestFile = null;
+    
+    for (const [filePath, result] of results) {
+      if (result.violations.length === 0) {
+        stats.compliantFiles++;
+      } else {
+        stats.nonCompliantFiles++;
+        stats.totalViolations += result.violations.length;
+        
+        // Count violations by type
+        for (const violation of result.violations) {
+          stats.violationsByType[violation.rule] = 
+            (stats.violationsByType[violation.rule] || 0) + 1;
+        }
+      }
+      
+      // Track file sizes
+      if (result.size) {
+        totalSize += result.size;
+        if (result.size > largestSize) {
+          largestSize = result.size;
+          largestFile = filePath;
+        }
+      }
+    }
+    
+    stats.averageFileSize = stats.totalFiles > 0 ? Math.round(totalSize / stats.totalFiles) : 0;
+    stats.largestFile = largestFile;
+    
+    return stats;
+  }
+}
+
+module.exports = { ScannerCore };

package/src/monitoring/scanner-events.js

@@ -0,0 +1,214 @@
+/**
+ * Scanner Events
+ * 
+ * Event handling and notification system for the continuous scanner.
+ */
+
+const EventEmitter = require('events');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Scanner Events Manager
+ */
+class ScannerEventsManager extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.options = {
+      logFile: options.logFile || './scanner-events.log',
+      enableFileLogging: options.enableFileLogging !== false,
+      enableConsoleLogging: options.enableConsoleLogging !== false,
+      maxLogSize: options.maxLogSize || 10 * 1024 * 1024, // 10MB
+      ...options
+    };
+    
+    this.eventCounts = new Map();
+    this.lastEvents = new Map();
+  }
+
+  /**
+   * Emit event with logging
+   */
+  emitWithLogging(event, data) {
+    // Count events
+    this.eventCounts.set(event, (this.eventCounts.get(event) || 0) + 1);
+    this.lastEvents.set(event, {
+      timestamp: new Date().toISOString(),
+      data
+    });
+    
+    // Log to file if enabled
+    if (this.options.enableFileLogging) {
+      this._logToFile(event, data);
+    }
+    
+    // Log to console if enabled
+    if (this.options.enableConsoleLogging) {
+      this._logToConsole(event, data);
+    }
+    
+    // Emit the event
+    this.emit(event, data);
+  }
+
+  /**
+   * Get event statistics
+   */
+  getEventStats() {
+    const stats = {};
+    
+    for (const [event, count] of this.eventCounts) {
+      stats[event] = {
+        count,
+        lastEvent: this.lastEvents.get(event)
+      };
+    }
+    
+    return stats;
+  }
+
+  /**
+   * Get recent events
+   */
+  getRecentEvents(limit = 50) {
+    const events = [];
+    
+    for (const [event, lastEvent] of this.lastEvents) {
+      events.push({
+        event,
+        timestamp: lastEvent.timestamp,
+        data: lastEvent.data
+      });
+    }
+    
+    return events
+      .sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp))
+      .slice(0, limit);
+  }
+
+  /**
+   * Clear event history
+   */
+  clearHistory() {
+    this.eventCounts.clear();
+    this.lastEvents.clear();
+    this.emit('history_cleared');
+  }
+
+  /**
+   * Log event to file
+   */
+  _logToFile(event, data) {
+    try {
+      const logEntry = {
+        timestamp: new Date().toISOString(),
+        event,
+        data
+      };
+      
+      const logLine = JSON.stringify(logEntry) + '\n';
+      
+      // Check log file size and rotate if necessary
+      if (fs.existsSync(this.options.logFile)) {
+        const stat = fs.statSync(this.options.logFile);
+        if (stat.size > this.options.maxLogSize) {
+          this._rotateLogFile();
+        }
+      }
+      
+      fs.appendFileSync(this.options.logFile, logLine, 'utf8');
+      
+    } catch (error) {
+      // Avoid infinite loops - don't log logging errors
+      console.error('Failed to write to log file:', error.message);
+    }
+  }
+
+  /**
+   * Log event to console
+   */
+  _logToConsole(event, data) {
+    const timestamp = new Date().toISOString();
+    const message = `[${timestamp}] ${event}`;
+    
+    switch (event) {
+      case 'scan_completed':
+        console.log(`${message}: Scan completed in ${data.scanTime}ms, ${data.stats.totalFiles} files scanned`);
+        if (data.stats.nonCompliantFiles > 0) {
+          console.log(`  - ${data.stats.nonCompliantFiles} files have violations`);
+        }
+        break;
+        
+      case 'violation_detected':
+        console.warn(`${message}: Violation in ${data.file}`);
+        console.warn(`  - ${data.violation.message}`);
+        break;
+        
+      case 'error':
+        console.error(`${message}: ${data}`);
+        break;
+        
+      case 'warning':
+        console.warn(`${message}: ${data}`);
+        break;
+        
+      case 'started':
+        console.log(`${message}: Continuous scanner started`);
+        break;
+        
+      case 'stopped':
+        console.log(`${message}: Continuous scanner stopped`);
+        break;
+        
+      default:
+        console.log(`${message}: ${JSON.stringify(data)}`);
+    }
+  }
+
+  /**
+   * Rotate log file
+   */
+  _rotateLogFile() {
+    try {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const rotatedFile = `${this.options.logFile}.${timestamp}`;
+      
+      fs.renameSync(this.options.logFile, rotatedFile);
+      this.emit('log_rotated', { originalFile: this.options.logFile, rotatedFile });
+      
+    } catch (error) {
+      console.error('Failed to rotate log file:', error.message);
+    }
+  }
+
+  /**
+   * Read log file
+   */
+  readLogFile(lines = 100) {
+    try {
+      if (!fs.existsSync(this.options.logFile)) {
+        return [];
+      }
+      
+      const content = fs.readFileSync(this.options.logFile, 'utf8');
+      const logLines = content.trim().split('\n');
+      
+      return logLines
+        .slice(-lines)
+        .map(line => {
+          try {
+            return JSON.parse(line);
+          } catch {
+            return { timestamp: null, event: 'parse_error', data: line };
+          }
+        });
+        
+    } catch (error) {
+      console.error('Failed to read log file:', error.message);
+      return [];
+    }
+  }
+}
+
+module.exports = { ScannerEventsManager };