vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/monitoring/violation-notification-system.js

@@ -0,0 +1,515 @@
+/**
+ * Violation Notification System
+ * 
+ * Sends notifications when new file size violations are detected
+ * or when compliance thresholds are crossed.
+ */
+
+const EventEmitter = require('events');
+const fs = require('fs').promises;
+const path = require('path');
+
+class ViolationNotificationSystem extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.enabled = options.enabled !== false;
+    this.thresholds = {
+      violationCount: options.violationCountThreshold || 5,
+      complianceDrop: options.complianceDropThreshold || 5,
+      criticalFile: options.criticalFileThreshold || 2000,
+      ...options.thresholds
+    };
+    this.channels = this.setupNotificationChannels(options.channels || {});
+    this.cooldownPeriod = options.cooldownPeriod || 300000; // 5 minutes
+    this.lastNotifications = new Map();
+    this.notificationHistory = [];
+    this.maxHistorySize = options.maxHistorySize || 100;
+  }
+
+  /**
+   * Setup notification channels
+   */
+  setupNotificationChannels(channels) {
+    return {
+      console: channels.console !== false,
+      file: channels.file !== false,
+      desktop: channels.desktop || false,
+      email: channels.email || null,
+      webhook: channels.webhook || null,
+      slack: channels.slack || null,
+      ...channels
+    };
+  }
+
+  /**
+   * Process scan results and send notifications if needed
+   */
+  async processScanResults(scanResults, previousResults = null) {
+    if (!this.enabled) return;
+
+    const notifications = [];
+
+    try {
+      // Check for new violations
+      const newViolations = this.findNewViolations(scanResults.violations, previousResults?.violations || []);
+      if (newViolations.length > 0) {
+        notifications.push(await this.createNewViolationsNotification(newViolations, scanResults));
+      }
+
+      // Check violation count threshold
+      if (scanResults.violations.length >= this.thresholds.violationCount) {
+        notifications.push(await this.createViolationCountNotification(scanResults));
+      }
+
+      // Check for critical files
+      const criticalViolations = scanResults.violations.filter(v => v.lineCount >= this.thresholds.criticalFile);
+      if (criticalViolations.length > 0) {
+        notifications.push(await this.createCriticalFilesNotification(criticalViolations));
+      }
+
+      // Check compliance drop
+      if (previousResults) {
+        const complianceDrop = (previousResults.complianceRate - scanResults.complianceRate);
+        if (complianceDrop >= this.thresholds.complianceDrop) {
+          notifications.push(await this.createComplianceDropNotification(complianceDrop, scanResults));
+        }
+      }
+
+      // Check for milestone events
+      notifications.push(...await this.checkMilestones(scanResults));
+
+      // Send notifications
+      for (const notification of notifications) {
+        await this.sendNotification(notification);
+      }
+
+    } catch (error) {
+      console.error('Error processing scan results for notifications:', error);
+      this.emit('error', error);
+    }
+  }
+
+  /**
+   * Find new violations compared to previous scan
+   */
+  findNewViolations(currentViolations, previousViolations) {
+    const previousFiles = new Set(previousViolations.map(v => v.filePath));
+    return currentViolations.filter(v => !previousFiles.has(v.filePath));
+  }
+
+  /**
+   * Create notification for new violations
+   */
+  async createNewViolationsNotification(newViolations, scanResults) {
+    const notification = {
+      type: 'new_violations',
+      title: 'New File Size Violations Detected',
+      message: `${newViolations.length} new file(s) exceed the 555-line limit`,
+      severity: newViolations.some(v => v.lineCount >= this.thresholds.criticalFile) ? 'critical' : 'warning',
+      data: {
+        violations: newViolations,
+        totalViolations: scanResults.violations.length,
+        complianceRate: scanResults.complianceRate
+      },
+      actions: [
+        { label: 'View Details', action: 'view_violations' },
+        { label: 'Generate Tasks', action: 'generate_tasks' }
+      ],
+      timestamp: new Date().toISOString()
+    };
+
+    return notification;
+  }
+
+  /**
+   * Create notification for violation count threshold
+   */
+  async createViolationCountNotification(scanResults) {
+    const notification = {
+      type: 'violation_threshold',
+      title: 'High Number of Violations',
+      message: `${scanResults.violations.length} files exceed the 555-line limit (threshold: ${this.thresholds.violationCount})`,
+      severity: scanResults.violations.length >= this.thresholds.violationCount * 2 ? 'critical' : 'warning',
+      data: {
+        violationCount: scanResults.violations.length,
+        threshold: this.thresholds.violationCount,
+        complianceRate: scanResults.complianceRate
+      },
+      actions: [
+        { label: 'Run Analysis', action: 'run_analysis' },
+        { label: 'View Dashboard', action: 'view_dashboard' }
+      ],
+      timestamp: new Date().toISOString()
+    };
+
+    return notification;
+  }
+
+  /**
+   * Create notification for critical files
+   */
+  async createCriticalFilesNotification(criticalViolations) {
+    const notification = {
+      type: 'critical_files',
+      title: 'Critical File Size Violations',
+      message: `${criticalViolations.length} file(s) exceed ${this.thresholds.criticalFile} lines`,
+      severity: 'critical',
+      data: {
+        criticalViolations,
+        threshold: this.thresholds.criticalFile
+      },
+      actions: [
+        { label: 'Prioritize for Refactoring', action: 'prioritize_refactoring' },
+        { label: 'View Critical Files', action: 'view_critical' }
+      ],
+      timestamp: new Date().toISOString()
+    };
+
+    return notification;
+  }
+
+  /**
+   * Create notification for compliance drop
+   */
+  async createComplianceDropNotification(drop, scanResults) {
+    const notification = {
+      type: 'compliance_drop',
+      title: 'Compliance Rate Drop',
+      message: `Compliance rate dropped by ${drop.toFixed(1)}% to ${scanResults.complianceRate.toFixed(1)}%`,
+      severity: drop >= 10 ? 'critical' : 'warning',
+      data: {
+        dropAmount: drop,
+        currentRate: scanResults.complianceRate,
+        previousRate: scanResults.complianceRate + drop
+      },
+      actions: [
+        { label: 'Investigate Changes', action: 'investigate_changes' },
+        { label: 'View History', action: 'view_history' }
+      ],
+      timestamp: new Date().toISOString()
+    };
+
+    return notification;
+  }
+
+  /**
+   * Check for milestone events
+   */
+  async checkMilestones(scanResults) {
+    const notifications = [];
+
+    // Compliance milestones
+    if (scanResults.complianceRate >= 95) {
+      notifications.push({
+        type: 'milestone',
+        title: '🎉 Compliance Milestone Achieved!',
+        message: `${scanResults.complianceRate.toFixed(1)}% compliance rate achieved!`,
+        severity: 'success',
+        data: { complianceRate: scanResults.complianceRate },
+        timestamp: new Date().toISOString()
+      });
+    }
+
+    // Zero violations milestone
+    if (scanResults.violations.length === 0) {
+      notifications.push({
+        type: 'milestone',
+        title: '🏆 Perfect Compliance Achieved!',
+        message: 'All files are compliant with the 555-line limit!',
+        severity: 'success',
+        data: { totalFiles: scanResults.totalFiles },
+        timestamp: new Date().toISOString()
+      });
+    }
+
+    return notifications;
+  }
+
+  /**
+   * Send notification through all configured channels
+   */
+  async sendNotification(notification) {
+    // Check cooldown period
+    const cooldownKey = `${notification.type}_${notification.title}`;
+    if (this.isInCooldown(cooldownKey)) {
+      return;
+    }
+
+    try {
+      // Console notification
+      if (this.channels.console) {
+        this.sendConsoleNotification(notification);
+      }
+
+      // File notification
+      if (this.channels.file) {
+        await this.sendFileNotification(notification);
+      }
+
+      // Desktop notification
+      if (this.channels.desktop) {
+        await this.sendDesktopNotification(notification);
+      }
+
+      // Email notification
+      if (this.channels.email) {
+        await this.sendEmailNotification(notification);
+      }
+
+      // Webhook notification
+      if (this.channels.webhook) {
+        await this.sendWebhookNotification(notification);
+      }
+
+      // Slack notification
+      if (this.channels.slack) {
+        await this.sendSlackNotification(notification);
+      }
+
+      // Update last notification time
+      this.lastNotifications.set(cooldownKey, Date.now());
+
+      // Add to history
+      this.addToHistory(notification);
+
+      // Emit event
+      this.emit('notification_sent', notification);
+
+    } catch (error) {
+      console.error('Error sending notification:', error);
+      this.emit('notification_error', { notification, error });
+    }
+  }
+
+  /**
+   * Send console notification
+   */
+  sendConsoleNotification(notification) {
+    const colors = {
+      critical: '\x1b[31m', // red
+      warning: '\x1b[33m',  // yellow
+      success: '\x1b[32m',  // green
+      info: '\x1b[36m'       // cyan
+    };
+
+    const reset = '\x1b[0m';
+    const color = colors[notification.severity] || colors.info;
+
+    console.log(`${color}🔔 ${notification.title}${reset}`);
+    console.log(`${notification.message}`);
+    
+    if (notification.data && Object.keys(notification.data).length > 0) {
+      console.log('Data:', JSON.stringify(notification.data, null, 2));
+    }
+    console.log('---');
+  }
+
+  /**
+   * Send file notification
+   */
+  async sendFileNotification(notification) {
+    const logFile = path.join(process.cwd(), '.vibecodingmachine', 'notifications.log');
+    
+    try {
+      await fs.mkdir(path.dirname(logFile), { recursive: true });
+      const logEntry = `${notification.timestamp} [${notification.severity.toUpperCase()}] ${notification.title}: ${notification.message}\n`;
+      await fs.appendFile(logFile, logEntry);
+    } catch (error) {
+      console.error('Failed to write notification to file:', error);
+    }
+  }
+
+  /**
+   * Send desktop notification
+   */
+  async sendDesktopNotification(notification) {
+    try {
+      const { Notification } = require('electron');
+      
+      if (Notification.isSupported()) {
+        const electronNotification = new Notification({
+          title: notification.title,
+          body: notification.message,
+          urgency: notification.severity === 'critical' ? 'critical' : 'normal'
+        });
+
+        electronNotification.on('click', () => {
+          this.emit('notification_clicked', notification);
+        });
+
+        electronNotification.show();
+      }
+    } catch (error) {
+      // Desktop notifications not available, silently fail
+      console.debug('Desktop notifications not available:', error.message);
+    }
+  }
+
+  /**
+   * Send email notification
+   */
+  async sendEmailNotification(notification) {
+    if (!this.channels.email) return;
+
+    // Email implementation would go here
+    // This is a placeholder for actual email sending logic
+    console.log('Email notification would be sent:', notification.title);
+  }
+
+  /**
+   * Send webhook notification
+   */
+  async sendWebhookNotification(notification) {
+    if (!this.channels.webhook) return;
+
+    try {
+      const fetch = require('node-fetch');
+      
+      await fetch(this.channels.webhook, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(notification)
+      });
+    } catch (error) {
+      console.error('Failed to send webhook notification:', error);
+    }
+  }
+
+  /**
+   * Send Slack notification
+   */
+  async sendSlackNotification(notification) {
+    if (!this.channels.slack) return;
+
+    try {
+      const fetch = require('node-fetch');
+      
+      const slackMessage = {
+        text: notification.title,
+        attachments: [{
+          color: this.getSlackColor(notification.severity),
+          text: notification.message,
+          fields: Object.entries(notification.data || {}).map(([key, value]) => ({
+            title: key,
+            value: typeof value === 'object' ? JSON.stringify(value) : String(value),
+            short: true
+          })),
+          ts: Math.floor(new Date(notification.timestamp).getTime() / 1000)
+        }]
+      };
+
+      await fetch(this.channels.slack, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(slackMessage)
+      });
+    } catch (error) {
+      console.error('Failed to send Slack notification:', error);
+    }
+  }
+
+  /**
+   * Get Slack color based on severity
+   */
+  getSlackColor(severity) {
+    switch (severity) {
+      case 'critical': return 'danger';
+      case 'warning': return 'warning';
+      case 'success': return 'good';
+      default: return '#439FE0';
+    }
+  }
+
+  /**
+   * Check if notification type is in cooldown period
+   */
+  isInCooldown(key) {
+    const lastTime = this.lastNotifications.get(key);
+    if (!lastTime) return false;
+    
+    return (Date.now() - lastTime) < this.cooldownPeriod;
+  }
+
+  /**
+   * Add notification to history
+   */
+  addToHistory(notification) {
+    this.notificationHistory.unshift(notification);
+    
+    // Trim history if it exceeds max size
+    if (this.notificationHistory.length > this.maxHistorySize) {
+      this.notificationHistory = this.notificationHistory.slice(0, this.maxHistorySize);
+    }
+  }
+
+  /**
+   * Get notification history
+   */
+  getNotificationHistory(limit = 50) {
+    return this.notificationHistory.slice(0, limit);
+  }
+
+  /**
+   * Get notification statistics
+   */
+  getNotificationStats() {
+    const stats = {
+      total: this.notificationHistory.length,
+      byType: {},
+      bySeverity: {},
+      recent24h: 0
+    };
+
+    const oneDayAgo = Date.now() - (24 * 60 * 60 * 1000);
+
+    this.notificationHistory.forEach(notification => {
+      // Count by type
+      stats.byType[notification.type] = (stats.byType[notification.type] || 0) + 1;
+      
+      // Count by severity
+      stats.bySeverity[notification.severity] = (stats.bySeverity[notification.severity] || 0) + 1;
+      
+      // Count recent notifications
+      if (new Date(notification.timestamp).getTime() > oneDayAgo) {
+        stats.recent24h++;
+      }
+    });
+
+    return stats;
+  }
+
+  /**
+   * Clear notification history
+   */
+  clearHistory() {
+    this.notificationHistory = [];
+    this.lastNotifications.clear();
+  }
+
+  /**
+   * Enable/disable notifications
+   */
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+
+  /**
+   * Update thresholds
+   */
+  updateThresholds(newThresholds) {
+    this.thresholds = { ...this.thresholds, ...newThresholds };
+  }
+
+  /**
+   * Update notification channels
+   */
+  updateChannels(newChannels) {
+    this.channels = { ...this.channels, ...newChannels };
+  }
+}
+
+module.exports = ViolationNotificationSystem;