vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/monitoring/continuous-scan-notifications.js

@@ -0,0 +1,661 @@
+/**
+ * Continuous Scan Notification System
+ * 
+ * Specialized notification system for continuous compliance scanning,
+ * providing intelligent alerts for new file size violations detected during scans.
+ */
+
+const { AlertSystem, Alert, ALERT_SEVERITY, ALERT_CATEGORIES } = require('./alert-system');
+const EventEmitter = require('events');
+
+/**
+ * Continuous Scan Notification Categories
+ */
+const SCAN_NOTIFICATION_TYPES = {
+  NEW_VIOLATIONS_DETECTED: 'new_violations_detected',
+  VIOLATIONS_RESOLVED: 'violations_resolved',
+  SCAN_COMPLETED: 'scan_completed',
+  SCAN_ERROR: 'scan_error',
+  THRESHOLD_EXCEEDED: 'threshold_exceeded',
+  PROGRESS_UPDATE: 'progress_update'
+};
+
+/**
+ * Continuous Scan Notification System
+ */
+class ContinuousScanNotificationSystem extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.options = {
+      // Notification thresholds
+      newViolationsThreshold: options.newViolationsThreshold || 1,
+      resolvedViolationsThreshold: options.resolvedViolationsThreshold || 5,
+      
+      // Batch notifications
+      enableBatchNotifications: options.enableBatchNotifications !== false,
+      batchIntervalMs: options.batchIntervalMs || 30000, // 30 seconds
+      maxBatchSize: options.maxBatchSize || 10,
+      
+      // Smart notifications
+      enableSmartNotifications: options.enableSmartNotifications !== false,
+      minSignificantChange: options.minSignificantChange || 3, // minimum change to trigger notification
+      
+      // Notification channels
+      channels: options.channels || ['console', 'file'],
+      logFile: options.logFile || './logs/continuous-scan-notifications.log',
+      
+      // Alert integration
+      enableAlertIntegration: options.enableAlertIntegration !== false,
+      alertSystem: options.alertSystem || null,
+      
+      ...options
+    };
+    
+    this.notificationHistory = [];
+    this.batchQueue = [];
+    this.batchTimer = null;
+    this.lastScanState = null;
+    this.notificationStats = {
+      totalNotifications: 0,
+      notificationsByType: {},
+      suppressedNotifications: 0,
+      batchedNotifications: 0
+    };
+    
+    // Initialize alert system if provided
+    if (this.options.enableAlertIntegration && this.options.alertSystem) {
+      this.alertSystem = this.options.alertSystem;
+    } else if (this.options.enableAlertIntegration) {
+      this.alertSystem = new AlertSystem({
+        channels: this.options.channels,
+        enableNotifications: true
+      });
+    }
+    
+    // Setup batch processing
+    if (this.options.enableBatchNotifications) {
+      this.setupBatchProcessing();
+    }
+  }
+
+  /**
+   * Process continuous scan results and generate notifications
+   */
+  processScanResults(scanResults, scanStatus) {
+    const notifications = [];
+    
+    // Compare with previous scan state
+    const changes = this.detectChanges(scanResults, scanStatus);
+    
+    // Generate notifications based on changes
+    if (changes.newViolations.length > 0) {
+      notifications.push(...this.createNewViolationNotifications(changes.newViolations));
+    }
+    
+    if (changes.resolvedViolations.length > 0) {
+      notifications.push(...this.createResolvedViolationNotifications(changes.resolvedViolations));
+    }
+    
+    if (changes.thresholdExceeded) {
+      notifications.push(this.createThresholdExceededNotification(changes.thresholdExceeded));
+    }
+    
+    if (changes.scanError) {
+      notifications.push(this.createScanErrorNotification(changes.scanError));
+    }
+    
+    if (changes.progressUpdate) {
+      notifications.push(this.createProgressNotification(changes.progressUpdate));
+    }
+    
+    // Process notifications
+    for (const notification of notifications) {
+      this.processNotification(notification);
+    }
+    
+    // Update scan state
+    this.lastScanState = {
+      timestamp: new Date().toISOString(),
+      scanResults,
+      scanStatus,
+      changes
+    };
+    
+    return notifications;
+  }
+
+  /**
+   * Detect changes between current and previous scan results
+   */
+  detectChanges(scanResults, scanStatus) {
+    const changes = {
+      newViolations: [],
+      resolvedViolations: [],
+      thresholdExceeded: null,
+      scanError: scanStatus.error || null,
+      progressUpdate: null
+    };
+    
+    if (!this.lastScanState) {
+      // First scan - all violations are "new"
+      changes.newViolations = scanResults.violations || [];
+      changes.progressUpdate = {
+        type: 'initial_scan',
+        totalFiles: scanResults.summary?.totalFiles || 0,
+        violationCount: scanResults.summary?.nonCompliantFiles || 0
+      };
+      return changes;
+    }
+    
+    const previousViolations = this.lastScanState.scanResults.violations || [];
+    const currentViolations = scanResults.violations || [];
+    
+    // Find new violations
+    const previousFilePaths = new Set(previousViolations.map(v => v.filePath));
+    changes.newViolations = currentViolations.filter(v => !previousFilePaths.has(v.filePath));
+    
+    // Find resolved violations
+    const currentFilePaths = new Set(currentViolations.map(v => v.filePath));
+    changes.resolvedViolations = previousViolations.filter(v => !currentFilePaths.has(v.filePath));
+    
+    // Check for threshold exceeded
+    const violationCount = scanResults.summary?.nonCompliantFiles || 0;
+    if (violationCount >= this.options.newViolationsThreshold) {
+      changes.thresholdExceeded = {
+        currentCount: violationCount,
+        threshold: this.options.newViolationsThreshold,
+        previousCount: this.lastScanState.scanResults.summary?.nonCompliantFiles || 0
+      };
+    }
+    
+    // Progress update
+    const previousCount = this.lastScanState.scanResults.summary?.nonCompliantFiles || 0;
+    if (violationCount !== previousCount) {
+      changes.progressUpdate = {
+        type: 'count_change',
+        previousCount,
+        currentCount: violationCount,
+        change: violationCount - previousCount
+      };
+    }
+    
+    return changes;
+  }
+
+  /**
+   * Create notifications for new violations
+   */
+  createNewViolationNotifications(newViolations) {
+    const notifications = [];
+    
+    if (newViolations.length === 0) return notifications;
+    
+    // Smart notification: only notify if significant change
+    if (this.options.enableSmartNotifications && 
+        newViolations.length < this.options.minSignificantChange) {
+      this.notificationStats.suppressedNotifications++;
+      return notifications;
+    }
+    
+    if (this.options.enableBatchNotifications && newViolations.length > this.options.maxBatchSize) {
+      // Create batch notification
+      notifications.push({
+        type: SCAN_NOTIFICATION_TYPES.NEW_VIOLATIONS_DETECTED,
+        severity: newViolations.length > 10 ? ALERT_SEVERITY.ERROR : ALERT_SEVERITY.WARNING,
+        title: `${newViolations.length} New File Size Violations Detected`,
+        message: `Continuous scan detected ${newViolations.length} files exceeding the 555-line limit`,
+        data: {
+          violationCount: newViolations.length,
+          violations: newViolations.slice(0, 5), // Include first 5 for details
+          totalViolations: newViolations.length,
+          timestamp: new Date().toISOString()
+        },
+        actions: [
+          'Review violation details in compliance dashboard',
+          'Run refactoring tools on largest violations',
+          'Update task list with new violations'
+        ]
+      });
+    } else {
+      // Create individual notifications
+      for (const violation of newViolations) {
+        notifications.push({
+          type: SCAN_NOTIFICATION_TYPES.NEW_VIOLATIONS_DETECTED,
+          severity: this.getViolationSeverity(violation),
+          title: `New File Size Violation: ${violation.filePath}`,
+          message: `${violation.filePath} has ${violation.lineCount} lines (${this.getExcessLines(violation)} over limit)`,
+          data: {
+            violation,
+            timestamp: new Date().toISOString()
+          },
+          actions: [
+            'Refactor this file',
+            'Add to refactoring task list',
+            'View detailed analysis'
+          ]
+        });
+      }
+    }
+    
+    return notifications;
+  }
+
+  /**
+   * Create notifications for resolved violations
+   */
+  createResolvedViolationNotifications(resolvedViolations) {
+    const notifications = [];
+    
+    if (resolvedViolations.length === 0) return notifications;
+    
+    // Only notify if significant number resolved
+    if (resolvedViolations.length >= this.options.resolvedViolationsThreshold) {
+      notifications.push({
+        type: SCAN_NOTIFICATION_TYPES.VIOLATIONS_RESOLVED,
+        severity: ALERT_SEVERITY.INFO,
+        title: `${resolvedViolations.length} File Size Violations Resolved`,
+        message: `Great progress! ${resolvedViolations.length} files are now compliant with the 555-line limit`,
+        data: {
+          resolvedCount: resolvedViolations.length,
+          resolvedFiles: resolvedViolations.map(v => v.filePath),
+          timestamp: new Date().toISOString()
+        },
+        actions: [
+          'Review compliance progress',
+          'Update project status',
+          'Continue with remaining violations'
+        ]
+      });
+    }
+    
+    return notifications;
+  }
+
+  /**
+   * Create threshold exceeded notification
+   */
+  createThresholdExceededNotification(thresholdData) {
+    return {
+      type: SCAN_NOTIFICATION_TYPES.THRESHOLD_EXCEEDED,
+      severity: thresholdData.currentCount > thresholdData.threshold * 2 ? ALERT_SEVERITY.CRITICAL : ALERT_SEVERITY.ERROR,
+      title: `File Size Violation Threshold Exceeded`,
+      message: `${thresholdData.currentCount} files exceed the 555-line limit (threshold: ${thresholdData.threshold})`,
+      data: {
+        ...thresholdData,
+        timestamp: new Date().toISOString()
+      },
+      actions: [
+        'Immediate refactoring required',
+        'Escalate to team lead',
+        'Schedule refactoring sprint'
+      ]
+    };
+  }
+
+  /**
+   * Create scan error notification
+   */
+  createScanErrorNotification(error) {
+    return {
+      type: SCAN_NOTIFICATION_TYPES.SCAN_ERROR,
+      severity: ALERT_SEVERITY.ERROR,
+      title: 'Continuous Scan Error',
+      message: `Error during continuous scan: ${error.message || error}`,
+      data: {
+        error,
+        timestamp: new Date().toISOString()
+      },
+      actions: [
+        'Check scan configuration',
+        'Review error logs',
+        'Restart continuous scanner'
+      ]
+    };
+  }
+
+  /**
+   * Create progress notification
+   */
+  createProgressNotification(progressData) {
+    const severity = progressData.type === 'initial_scan' ? ALERT_SEVERITY.INFO : ALERT_SEVERITY.INFO;
+    
+    return {
+      type: SCAN_NOTIFICATION_TYPES.PROGRESS_UPDATE,
+      severity,
+      title: progressData.type === 'initial_scan' ? 'Initial Scan Completed' : 'Compliance Progress Update',
+      message: this.formatProgressMessage(progressData),
+      data: {
+        ...progressData,
+        timestamp: new Date().toISOString()
+      }
+    };
+  }
+
+  /**
+   * Process a notification
+   */
+  processNotification(notification) {
+    // Add to history
+    this.notificationHistory.push(notification);
+    this.notificationStats.totalNotifications++;
+    this.notificationStats.notificationsByType[notification.type] = 
+      (this.notificationStats.notificationsByType[notification.type] || 0) + 1;
+    
+    // Handle batching
+    if (this.options.enableBatchNotifications) {
+      this.addToBatch(notification);
+    } else {
+      this.sendNotification(notification);
+    }
+    
+    // Emit event
+    this.emit('notification', notification);
+    this.emit(`notification:${notification.type}`, notification);
+  }
+
+  /**
+   * Add notification to batch
+   */
+  addToBatch(notification) {
+    this.batchQueue.push(notification);
+    this.notificationStats.batchedNotifications++;
+    
+    // Send immediately if high severity or batch is full
+    if (notification.severity === ALERT_SEVERITY.CRITICAL || 
+        this.batchQueue.length >= this.options.maxBatchSize) {
+      this.sendBatch();
+    }
+  }
+
+  /**
+   * Setup batch processing
+   */
+  setupBatchProcessing() {
+    this.batchTimer = setInterval(() => {
+      if (this.batchQueue.length > 0) {
+        this.sendBatch();
+      }
+    }, this.options.batchIntervalMs);
+  }
+
+  /**
+   * Send batch notifications
+   */
+  sendBatch() {
+    if (this.batchQueue.length === 0) return;
+    
+    const batch = [...this.batchQueue];
+    this.batchQueue = [];
+    
+    // Create batch summary notification
+    const batchNotification = {
+      type: 'batch_summary',
+      severity: this.getBatchSeverity(batch),
+      title: `Scan Notification Summary (${batch.length} items)`,
+      message: this.formatBatchSummary(batch),
+      data: {
+        batchSize: batch.length,
+        notifications: batch,
+        timestamp: new Date().toISOString()
+      }
+    };
+    
+    this.sendNotification(batchNotification);
+    
+    // Also send individual notifications to alert system
+    if (this.alertSystem) {
+      for (const notification of batch) {
+        this.sendToAlertSystem(notification);
+      }
+    }
+  }
+
+  /**
+   * Send notification
+   */
+  sendNotification(notification) {
+    for (const channel of this.options.channels) {
+      try {
+        switch (channel) {
+          case 'console':
+            this.sendConsoleNotification(notification);
+            break;
+          case 'file':
+            this.sendFileNotification(notification);
+            break;
+          case 'alert':
+            if (this.alertSystem) {
+              this.sendToAlertSystem(notification);
+            }
+            break;
+          default:
+            console.warn(`Unknown notification channel: ${channel}`);
+        }
+      } catch (error) {
+        console.error(`Failed to send ${channel} notification:`, error);
+      }
+    }
+  }
+
+  /**
+   * Send console notification
+   */
+  sendConsoleNotification(notification) {
+    const colors = {
+      info: '\x1b[36m',
+      warning: '\x1b[33m',
+      error: '\x1b[31m',
+      critical: '\x1b[35m',
+      reset: '\x1b[0m',
+      bold: '\x1b[1m'
+    };
+    
+    const color = colors[notification.severity] || colors.info;
+    const icon = this.getNotificationIcon(notification.type);
+    
+    console.log(`${color}${colors.bold}[SCAN NOTIFY] ${icon} ${notification.title}${colors.reset}`);
+    console.log(`${color}  ${notification.message}${colors.reset}`);
+    console.log(`  Time: ${new Date(notification.data.timestamp).toLocaleString()}`);
+    
+    if (notification.data.violationCount) {
+      console.log(`  Violations: ${notification.data.violationCount}`);
+    }
+    
+    if (notification.actions && notification.actions.length > 0) {
+      console.log(`  Actions: ${notification.actions.slice(0, 2).join(', ')}`);
+    }
+    
+    console.log('');
+  }
+
+  /**
+   * Send file notification
+   */
+  sendFileNotification(notification) {
+    const fs = require('fs');
+    const path = require('path');
+    
+    // Ensure log directory exists
+    const logDir = path.dirname(this.options.logFile);
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+    
+    const logEntry = {
+      timestamp: notification.data.timestamp,
+      type: notification.type,
+      severity: notification.severity,
+      title: notification.title,
+      message: notification.message,
+      data: notification.data
+    };
+    
+    const logLine = JSON.stringify(logEntry) + '\n';
+    fs.appendFileSync(this.options.logFile, logLine, 'utf8');
+  }
+
+  /**
+   * Send to alert system
+   */
+  sendToAlertSystem(notification) {
+    if (!this.alertSystem) return;
+    
+    const alert = new Alert({
+      category: ALERT_CATEGORIES.FILE_SIZE,
+      severity: notification.severity,
+      title: notification.title,
+      message: notification.message,
+      description: notification.data.violations ? 
+        `Details: ${notification.data.violations.length} violations detected` : 
+        notification.message,
+      filePath: notification.data.violation?.filePath || 'Multiple files',
+      metadata: {
+        timestamp: notification.data.timestamp,
+        source: 'continuous-scan-notifier',
+        notificationType: notification.type
+      },
+      context: {
+        ...notification.data,
+        notificationActions: notification.actions
+      },
+      actions: notification.actions || []
+    });
+    
+    this.alertSystem.processAlert(alert);
+  }
+
+  /**
+   * Get violation severity based on line count
+   */
+  getViolationSeverity(violation) {
+    const lineCount = violation.lineCount || 0;
+    
+    if (lineCount > 1000) return ALERT_SEVERITY.CRITICAL;
+    if (lineCount > 800) return ALERT_SEVERITY.ERROR;
+    if (lineCount > 555) return ALERT_SEVERITY.WARNING;
+    return ALERT_SEVERITY.INFO;
+  }
+
+  /**
+   * Get excess lines for violation
+   */
+  getExcessLines(violation) {
+    const lineCount = violation.lineCount || 0;
+    const excessLines = lineCount - 555;
+    return excessLines > 0 ? `${excessLines} lines` : '0 lines';
+  }
+
+  /**
+   * Get notification icon
+   */
+  getNotificationIcon(type) {
+    const icons = {
+      [SCAN_NOTIFICATION_TYPES.NEW_VIOLATIONS_DETECTED]: '🚨',
+      [SCAN_NOTIFICATION_TYPES.VIOLATIONS_RESOLVED]: '✅',
+      [SCAN_NOTIFICATION_TYPES.SCAN_COMPLETED]: '🔍',
+      [SCAN_NOTIFICATION_TYPES.SCAN_ERROR]: '❌',
+      [SCAN_NOTIFICATION_TYPES.THRESHOLD_EXCEEDED]: '⚠️',
+      [SCAN_NOTIFICATION_TYPES.PROGRESS_UPDATE]: '📊',
+      'batch_summary': '📋'
+    };
+    
+    return icons[type] || '📢';
+  }
+
+  /**
+   * Get batch severity
+   */
+  getBatchSeverity(batch) {
+    if (batch.some(n => n.severity === ALERT_SEVERITY.CRITICAL)) return ALERT_SEVERITY.CRITICAL;
+    if (batch.some(n => n.severity === ALERT_SEVERITY.ERROR)) return ALERT_SEVERITY.ERROR;
+    if (batch.some(n => n.severity === ALERT_SEVERITY.WARNING)) return ALERT_SEVERITY.WARNING;
+    return ALERT_SEVERITY.INFO;
+  }
+
+  /**
+   * Format batch summary
+   */
+  formatBatchSummary(batch) {
+    const typeCounts = {};
+    for (const notification of batch) {
+      typeCounts[notification.type] = (typeCounts[notification.type] || 0) + 1;
+    }
+    
+    let summary = `Batch contains ${batch.length} notifications: `;
+    const items = [];
+    
+    for (const [type, count] of Object.entries(typeCounts)) {
+      items.push(`${count} ${type}`);
+    }
+    
+    summary += items.join(', ');
+    return summary;
+  }
+
+  /**
+   * Format progress message
+   */
+  formatProgressMessage(progressData) {
+    switch (progressData.type) {
+      case 'initial_scan':
+        return `Initial scan completed: ${progressData.totalFiles} files scanned, ${progressData.violationCount} violations found`;
+      case 'count_change':
+        const direction = progressData.change > 0 ? 'increased' : 'decreased';
+        return `File size violations ${direction} by ${Math.abs(progressData.change)} (now ${progressData.currentCount})`;
+      default:
+        return `Scan progress updated`;
+    }
+  }
+
+  /**
+   * Get notification statistics
+   */
+  getStats() {
+    return {
+      ...this.notificationStats,
+      queueSize: this.batchQueue.length,
+      lastScanState: this.lastScanState ? {
+        timestamp: this.lastScanState.timestamp,
+        violationCount: this.lastScanState.scanResults.summary?.nonCompliantFiles || 0
+      } : null
+    };
+  }
+
+  /**
+   * Clear notification history
+   */
+  clearHistory() {
+    this.notificationHistory = [];
+    this.batchQueue = [];
+    this.notificationStats = {
+      totalNotifications: 0,
+      notificationsByType: {},
+      suppressedNotifications: 0,
+      batchedNotifications: 0
+    };
+    this.emit('historyCleared');
+  }
+
+  /**
+   * Shutdown notification system
+   */
+  shutdown() {
+    if (this.batchTimer) {
+      clearInterval(this.batchTimer);
+      this.batchTimer = null;
+    }
+    
+    // Send any remaining batch notifications
+    if (this.batchQueue.length > 0) {
+      this.sendBatch();
+    }
+    
+    this.emit('shutdown');
+  }
+}
+
+module.exports = {
+  ContinuousScanNotificationSystem,
+  SCAN_NOTIFICATION_TYPES
+};