vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/monitoring/continuous-scanner.js

@@ -0,0 +1,279 @@
+/**
+ * Continuous Repository Scanner
+ * 
+ * Continuously scans the repository to identify files that exceed the 555-line limit
+ * and triggers appropriate actions for compliance management.
+ */
+
+const { ScannerCore } = require('./scanner-core');
+const { ScannerEventsManager } = require('./scanner-events');
+const { NotificationManager } = require('./notification-manager');
+
+/**
+ * Continuous Scanner - Main orchestrator
+ */
+class ContinuousScanner {
+  constructor(options = {}) {
+    this.options = {
+      autoStart: options.autoStart || false,
+      enableNotifications: options.enableNotifications !== false,
+      notificationThreshold: options.notificationThreshold || 5,
+      ...options
+    };
+    
+    this.core = new ScannerCore(options);
+    this.events = new ScannerEventsManager(options);
+    
+    // Initialize notification manager
+    this.notificationManager = new NotificationManager({
+      enabled: options.enableNotifications !== false,
+      channels: options.notificationChannels || ['console', 'file'],
+      violationThreshold: options.notificationThreshold || 1,
+      criticalViolationThreshold: options.criticalNotificationThreshold || 10,
+      enableDesktop: options.enableDesktopNotifications !== false,
+      logFile: options.notificationLogFile || './logs/continuous-scan-notifications.log'
+    });
+    
+    this._setupEventHandlers();
+    
+    if (this.options.autoStart) {
+      this.start();
+    }
+  }
+
+  /**
+   * Start scanning
+   */
+  start() {
+    this.core.start();
+  }
+
+  /**
+   * Get notification statistics
+   */
+  getNotificationStats() {
+    if (!this.notificationSystem) {
+      return null;
+    }
+    
+    return this.notificationSystem.getStats();
+  }
+
+  /**
+   * Stop scanning
+   */
+  stop() {
+    this.core.stop();
+    
+    // Shutdown notification system
+    if (this.notificationSystem) {
+      this.notificationSystem.shutdown();
+    }
+  }
+
+  /**
+   * Get current status
+   */
+  getStatus() {
+    return {
+      isRunning: this.core.isRunning,
+      results: this.core.getResults(),
+      violations: this.core.getViolations(),
+      eventStats: this.events.getEventStats(),
+      recentEvents: this.events.getRecentEvents(10)
+    };
+  }
+
+  /**
+   * Get compliance report
+   */
+  getComplianceReport() {
+    const results = this.core.getResults();
+    const violations = this.core.getViolations();
+    
+    return {
+      timestamp: new Date().toISOString(),
+      summary: {
+        totalFiles: results.size,
+        compliantFiles: Array.from(results.values()).filter(r => r.violations.length === 0).length,
+        nonCompliantFiles: violations.length,
+        totalViolations: violations.reduce((sum, v) => sum + v.violations.length, 0)
+      },
+      violations: violations,
+      recommendations: this._generateRecommendations(violations)
+    };
+  }
+
+  /**
+   * Setup event handlers
+   */
+  _setupEventHandlers() {
+    // Forward core events to events manager
+    this.core.on('started', () => {
+      this.events.emitWithLogging('scanner_started', {});
+    });
+    
+    this.core.on('stopped', () => {
+      this.events.emitWithLogging('scanner_stopped', {});
+    });
+    
+    this.core.on('scan_completed', async (data) => {
+      this.events.emitWithLogging('scan_completed', data);
+      
+      // Handle violations through notification manager
+      if (data.violations && data.violations.length > 0) {
+        await this.notificationManager.handleNewViolations(data.violations, {
+          scanType: 'continuous',
+          timestamp: data.timestamp
+        });
+        
+        // Check for new violations
+        this.events.emitWithLogging('violations_found', {
+          count: data.violations.length,
+          violations: data.violations
+        });
+        
+        // Send legacy notifications if enabled
+        if (this.options.enableNotifications && data.violations.length >= this.options.notificationThreshold) {
+          this._sendNotification(data);
+        }
+      }
+    });
+    
+    this.core.on('error', (error) => {
+      this.events.emitWithLogging('error', error);
+    });
+    
+    this.core.on('warning', (warning) => {
+      this.events.emitWithLogging('warning', warning);
+    });
+    
+    this.core.on('event', (event) => {
+      this.events.emitWithLogging('file_event', event);
+    });
+  }
+
+  /**
+   * Generate unique scan ID
+   */
+  generateScanId() {
+    return `scan-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  /**
+   * Generate recommendations based on violations
+   */
+  _generateRecommendations(violations) {
+    const recommendations = [];
+    
+    if (violations.length === 0) {
+      recommendations.push({
+        type: 'success',
+        title: 'All Files Compliant',
+        description: 'No files exceed the 555-line limit. Great job!',
+        priority: 'low'
+      });
+      return recommendations;
+    }
+    
+    // Group violations by type
+    const violationTypes = {};
+    for (const violation of violations) {
+      for (const v of violation.violations) {
+        violationTypes[v.rule] = (violationTypes[v.rule] || 0) + 1;
+      }
+    }
+    
+    // Generate recommendations for each violation type
+    if (violationTypes.maxFileSize > 0) {
+      recommendations.push({
+        type: 'action_required',
+        title: 'Refactor Large Files',
+        description: `${violationTypes.maxFileSize} files exceed the 555-line limit`,
+        priority: 'high',
+        action: 'Use the refactoring tools to split large files into smaller modules'
+      });
+    }
+    
+    if (violationTypes.noTrailingWhitespace > 5) {
+      recommendations.push({
+        type: 'suggestion',
+        title: 'Fix Trailing Whitespace',
+        description: `${violationTypes.noTrailingWhitespace} files have trailing whitespace`,
+        priority: 'medium',
+        action: 'Configure your editor to trim trailing whitespace on save'
+      });
+    }
+    
+    if (violationTypes.fileEndsWithNewline > 5) {
+      recommendations.push({
+        type: 'suggestion',
+        title: 'Add Newline to File End',
+        description: `${violationTypes.fileEndsWithNewline} files don\'t end with newline`,
+        priority: 'low',
+        action: 'Configure your editor to add newline at end of file'
+      });
+    }
+    
+    return recommendations;
+  }
+
+  /**
+   * Get notification statistics
+   */
+  getNotificationStats() {
+    return this.notificationManager.getStats();
+  }
+
+  /**
+   * Test notification system
+   */
+  async testNotifications() {
+    return await this.notificationManager.testNotification();
+  }
+  _sendNotification(data) {
+    // Create detailed alert for violations
+    if (data.violations.length > 0) {
+      const alert = {
+        id: `continuous-scan-${Date.now()}`,
+        category: 'file_size',
+        severity: data.violations.length > 10 ? 'critical' : 'warning',
+        title: `Continuous Scan Detected ${data.violations.length} Violations`,
+        message: `${data.violations.length} files exceed the 555-line limit detected during continuous scanning`,
+        description: `Files requiring immediate refactoring attention`,
+        filePath: 'Multiple files',
+        metadata: {
+          timestamp: new Date().toISOString(),
+          source: 'continuous-scanner',
+          scanType: 'continuous',
+          violationCount: data.violations.length,
+          violations: data.violations.map(v => ({
+            filePath: v.filePath,
+            lineCount: v.lineCount,
+            excessLines: v.lineCount - 555
+          }))
+        }
+      };
+      
+      // Emit notification event for external handlers
+      this.events.emitWithLogging('violation_alert', alert);
+    }
+    
+    // Emit notification event for external handlers
+    this.events.emitWithLogging('notification_sent', {
+      type: 'violations_detected',
+      count: data.violations.length,
+      data
+    });
+  }
+}
+
+// Export singleton instance
+const scanner = new ContinuousScanner();
+
+module.exports = {
+  ContinuousScanner,
+  scanner,
+  ScannerCore,
+  ScannerEventsManager
+};

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

@@ -0,0 +1,262 @@
+/**
+ * File Analysis for Monitoring
+ * 
+ * Analyzes files for compliance issues during monitoring.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { LineLimitValidator } = require('../../validation/line-limit-validator');
+const ConstitutionValidator = require('../../validation/constitution-validator');
+
+/**
+ * File analyzer for monitoring
+ */
+class MonitoringFileAnalyzer {
+  constructor(options = {}) {
+    this.options = {
+      lineLimit: 555,
+      checkConstitutional: true,
+      checkCommonIssues: true,
+      ...options
+    };
+    
+    this.lineValidator = new LineLimitValidator();
+    this.constitutionValidator = new ConstitutionValidator();
+    
+    // Cache analysis results to avoid repeated work
+    this.analysisCache = new Map();
+    this.cacheTimeout = options.cacheTimeout || 30000; // 30 seconds
+  }
+
+  /**
+   * Analyze a file for compliance issues
+   */
+  async analyzeFile(filePath, eventType = 'change') {
+    const cacheKey = `${filePath}:${eventType}`;
+    
+    // Check cache first
+    if (this.analysisCache.has(cacheKey)) {
+      const cached = this.analysisCache.get(cacheKey);
+      if (Date.now() - cached.timestamp < this.cacheTimeout) {
+        return cached.result;
+      }
+    }
+
+    try {
+      const result = await this.performAnalysis(filePath, eventType);
+      
+      // Cache the result
+      this.analysisCache.set(cacheKey, {
+        result,
+        timestamp: Date.now()
+      });
+      
+      // Clean up old cache entries
+      this.cleanupCache();
+      
+      return result;
+      
+    } catch (error) {
+      const errorResult = {
+        filePath,
+        eventType,
+        success: false,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      };
+      
+      return errorResult;
+    }
+  }
+
+  /**
+   * Perform the actual file analysis
+   */
+  async performAnalysis(filePath, eventType) {
+    const result = {
+      filePath,
+      eventType,
+      success: true,
+      timestamp: new Date().toISOString(),
+      issues: [],
+      metrics: {
+        lineCount: 0,
+        fileSize: 0,
+        lastModified: null
+      }
+    };
+
+    try {
+      // Get file stats
+      const stats = fs.statSync(filePath);
+      result.metrics.fileSize = stats.size;
+      result.metrics.lastModified = stats.mtime.toISOString();
+
+      // Only analyze source code files
+      if (!this.shouldAnalyzeFile(filePath)) {
+        result.skipped = true;
+        result.reason = 'File type not analyzed';
+        return result;
+      }
+
+      // Check line limit compliance
+      if (this.options.checkLineLimit) {
+        const lineResult = this.lineValidator.validateFile(filePath, this.options.lineLimit);
+        result.metrics.lineCount = lineResult.lineCount;
+        
+        if (!lineResult.isValid) {
+          result.issues.push({
+            type: 'line_limit',
+            severity: lineResult.severity,
+            message: `File exceeds ${this.options.lineLimit} line limit (${lineResult.lineCount} lines)`,
+            details: lineResult.getSummary()
+          });
+        }
+      }
+
+      // Check constitutional compliance
+      if (this.options.checkConstitutional) {
+        try {
+          const constitutionResult = this.constitutionValidator.validateFile(filePath);
+          
+          if (!constitutionResult.compliant) {
+            result.issues.push({
+              type: 'constitutional',
+              severity: constitutionResult.severity || 'warning',
+              message: 'Constitutional compliance issues detected',
+              details: constitutionResult.issues || []
+            });
+          }
+        } catch (error) {
+          // Constitutional validation might fail for non-code files
+          // Don't treat this as a critical error
+        }
+      }
+
+      // Check for common issues
+      if (this.options.checkCommonIssues) {
+        const commonIssues = this.checkCommonIssues(filePath);
+        result.issues.push(...commonIssues);
+      }
+
+      result.compliant = result.issues.length === 0;
+      
+    } catch (error) {
+      result.success = false;
+      result.error = error.message;
+    }
+
+    return result;
+  }
+
+  /**
+   * Check if a file should be analyzed
+   */
+  shouldAnalyzeFile(filePath) {
+    const ext = path.extname(filePath);
+    
+    // Source code extensions to analyze
+    const sourceExtensions = new Set([
+      '.js', '.jsx', '.ts', '.tsx', '.vue', '.py', '.java', '.cpp', '.c', '.h',
+      '.cs', '.php', '.rb', '.go', '.rs', '.swift', '.kt', '.scala', '.sh',
+      '.html', '.css', '.scss', '.sass', '.less', '.md', '.yml', '.yaml'
+    ]);
+    
+    return sourceExtensions.has(ext);
+  }
+
+  /**
+   * Check for common file issues
+   */
+  checkCommonIssues(filePath) {
+    const issues = [];
+    
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const lines = content.split('\n');
+      
+      // Check for trailing whitespace
+      let trailingWhitespaceCount = 0;
+      lines.forEach((line, index) => {
+        if (line.endsWith(' ') || line.endsWith('\t')) {
+          trailingWhitespaceCount++;
+        }
+      });
+      
+      if (trailingWhitespaceCount > 0) {
+        issues.push({
+          type: 'trailing_whitespace',
+          severity: 'warning',
+          message: `File has ${trailingWhitespaceCount} lines with trailing whitespace`,
+          count: trailingWhitespaceCount
+        });
+      }
+      
+      // Check if file ends with newline
+      if (content.length > 0 && !content.endsWith('\n')) {
+        issues.push({
+          type: 'missing_newline',
+          severity: 'info',
+          message: 'File does not end with newline character'
+        });
+      }
+      
+      // Check for very long lines
+      let longLineCount = 0;
+      lines.forEach(line => {
+        if (line.length > 200) {
+          longLineCount++;
+        }
+      });
+      
+      if (longLineCount > 0) {
+        issues.push({
+          type: 'long_lines',
+          severity: 'info',
+          message: `File has ${longLineCount} lines over 200 characters`,
+          count: longLineCount
+        });
+      }
+      
+    } catch (error) {
+      // If we can't read the file, skip common issues check
+    }
+    
+    return issues;
+  }
+
+  /**
+   * Clean up old cache entries
+   */
+  cleanupCache() {
+    const now = Date.now();
+    
+    for (const [key, cached] of this.analysisCache.entries()) {
+      if (now - cached.timestamp > this.cacheTimeout) {
+        this.analysisCache.delete(key);
+      }
+    }
+  }
+
+  /**
+   * Clear the analysis cache
+   */
+  clearCache() {
+    this.analysisCache.clear();
+  }
+
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    return {
+      size: this.analysisCache.size,
+      timeout: this.cacheTimeout
+    };
+  }
+}
+
+module.exports = {
+  MonitoringFileAnalyzer
+};