vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/monitoring/notification-manager.js

@@ -0,0 +1,437 @@
+/**
+ * Notification System for Continuous Compliance Monitoring
+ * 
+ * Provides intelligent notification management for new violations detected
+ * during continuous scanning, with configurable channels and escalation policies.
+ */
+
+const EventEmitter = require('events');
+const { AlertSystem } = require('./alert-system');
+
+/**
+ * Notification channels
+ */
+const NOTIFICATION_CHANNELS = {
+  CONSOLE: 'console',
+  FILE: 'file',
+  DESKTOP: 'desktop',
+  EMAIL: 'email',
+  SLACK: 'slack'
+};
+
+/**
+ * Notification priorities
+ */
+const NOTIFICATION_PRIORITY = {
+  LOW: 'low',
+  MEDIUM: 'medium',
+  HIGH: 'high',
+  CRITICAL: 'critical'
+};
+
+/**
+ * Notification Manager Class
+ */
+class NotificationManager extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.options = {
+      // Enable/disable notifications
+      enabled: options.enabled !== false,
+      
+      // Notification channels to use
+      channels: options.channels || [NOTIFICATION_CHANNELS.CONSOLE, NOTIFICATION_CHANNELS.FILE],
+      
+      // Notification thresholds
+      violationThreshold: options.violationThreshold || 1,
+      criticalViolationThreshold: options.criticalViolationThreshold || 10,
+      
+      // Rate limiting
+      enableRateLimit: options.enableRateLimit !== false,
+      rateLimitMs: options.rateLimitMs || 300000, // 5 minutes
+      
+      // Desktop notification settings
+      enableDesktop: options.enableDesktop !== false,
+      desktopTitle: options.desktopTitle || 'Vibe Coding Machine',
+      
+      // File logging
+      logFile: options.logFile || './logs/notifications.log',
+      
+      ...options
+    };
+    
+    // Initialize alert system for integration
+    this.alertSystem = new AlertSystem({
+      channels: this.options.channels,
+      enableNotifications: this.options.enabled
+    });
+    
+    // Rate limiting tracking
+    this.lastNotificationTime = new Map();
+    
+    // Statistics
+    this.stats = {
+      totalNotifications: 0,
+      notificationsByChannel: {},
+      notificationsByPriority: {},
+      violationsDetected: 0,
+      lastNotification: null
+    };
+    
+    this._initializeStats();
+  }
+
+  /**
+   * Initialize statistics tracking
+   */
+  _initializeStats() {
+    for (const channel of Object.values(NOTIFICATION_CHANNELS)) {
+      this.stats.notificationsByChannel[channel] = 0;
+    }
+    for (const priority of Object.values(NOTIFICATION_PRIORITY)) {
+      this.stats.notificationsByPriority[priority] = 0;
+    }
+  }
+
+  /**
+   * Handle new violations from continuous scanner
+   */
+  async handleNewViolations(violations, scanInfo = {}) {
+    if (!this.options.enabled || !violations || violations.length === 0) {
+      return;
+    }
+
+    this.stats.violationsDetected += violations.length;
+
+    // Check rate limiting
+    if (this.options.enableRateLimit && this._isRateLimited('violations')) {
+      console.log('Notification rate limited for violations');
+      return;
+    }
+
+    // Determine notification priority
+    const priority = this._determinePriority(violations);
+    
+    // Create notification
+    const notification = this._createViolationNotification(violations, scanInfo, priority);
+    
+    // Send notification through all configured channels
+    await this._sendNotification(notification);
+    
+    // Update statistics
+    this._updateStats(notification);
+    
+    // Emit event for external handlers
+    this.emit('violationNotification', notification);
+  }
+
+  /**
+   * Handle scanner status changes
+   */
+  async handleScannerStatus(status, statusInfo = {}) {
+    if (!this.options.enabled) {
+      return;
+    }
+
+    const notification = this._createStatusNotification(status, statusInfo);
+    
+    if (notification) {
+      await this._sendNotification(notification);
+      this._updateStats(notification);
+      this.emit('statusNotification', notification);
+    }
+  }
+
+  /**
+   * Determine notification priority based on violations
+   */
+  _determinePriority(violations) {
+    if (violations.length >= this.options.criticalViolationThreshold) {
+      return NOTIFICATION_PRIORITY.CRITICAL;
+    } else if (violations.length >= 5) {
+      return NOTIFICATION_PRIORITY.HIGH;
+    } else if (violations.length >= this.options.violationThreshold) {
+      return NOTIFICATION_PRIORITY.MEDIUM;
+    }
+    return NOTIFICATION_PRIORITY.LOW;
+  }
+
+  /**
+   * Create violation notification
+   */
+  _createViolationNotification(violations, scanInfo, priority) {
+    const violationCount = violations.length;
+    const totalExcessLines = violations.reduce((sum, v) => sum + (v.lineCount - 555), 0);
+    
+    return {
+      id: `violation-${Date.now()}`,
+      type: 'violation',
+      priority,
+      title: `${violationCount} File Size Violations Detected`,
+      message: `${violationCount} files exceed the 555-line limit (${totalExcessLines} excess lines total)`,
+      description: this._generateViolationDescription(violations),
+      metadata: {
+        timestamp: new Date().toISOString(),
+        source: 'continuous-scanner',
+        scanInfo,
+        violationCount,
+        totalExcessLines,
+        violations: violations.map(v => ({
+          filePath: v.filePath,
+          lineCount: v.lineCount,
+          excessLines: v.lineCount - 555,
+          severity: v.lineCount > 1000 ? 'critical' : 'warning'
+        }))
+      }
+    };
+  }
+
+  /**
+   * Generate detailed violation description
+   */
+  _generateViolationDescription(violations) {
+    const topViolations = violations
+      .sort((a, b) => b.lineCount - a.lineCount)
+      .slice(0, 5);
+    
+    let description = `Top violations:\n`;
+    topViolations.forEach((v, index) => {
+      description += `${index + 1}. ${v.filePath} (${v.lineCount} lines, ${v.lineCount - 555} over)\n`;
+    });
+    
+    if (violations.length > 5) {
+      description += `... and ${violations.length - 5} more files`;
+    }
+    
+    return description;
+  }
+
+  /**
+   * Create status notification
+   */
+  _createStatusNotification(status, statusInfo) {
+    if (status === 'error') {
+      return {
+        id: `status-error-${Date.now()}`,
+        type: 'status',
+        priority: NOTIFICATION_PRIORITY.HIGH,
+        title: 'Continuous Scanner Error',
+        message: 'Continuous scanner encountered an error',
+        description: statusInfo.error || 'Unknown error occurred',
+        metadata: {
+          timestamp: new Date().toISOString(),
+          source: 'continuous-scanner',
+          status,
+          statusInfo
+        }
+      };
+    }
+    
+    return null;
+  }
+
+  /**
+   * Send notification through configured channels
+   */
+  async _sendNotification(notification) {
+    const results = [];
+    
+    for (const channel of this.options.channels) {
+      try {
+        const result = await this._sendToChannel(channel, notification);
+        results.push({ channel, success: true, result });
+      } catch (error) {
+        console.error(`Failed to send ${channel} notification:`, error);
+        results.push({ channel, success: false, error });
+      }
+    }
+    
+    return results;
+  }
+
+  /**
+   * Send notification to specific channel
+   */
+  async _sendToChannel(channel, notification) {
+    switch (channel) {
+      case NOTIFICATION_CHANNELS.CONSOLE:
+        return this._sendConsoleNotification(notification);
+      case NOTIFICATION_CHANNELS.FILE:
+        return this._sendFileNotification(notification);
+      case NOTIFICATION_CHANNELS.DESKTOP:
+        return this._sendDesktopNotification(notification);
+      case NOTIFICATION_CHANNELS.EMAIL:
+        return this._sendEmailNotification(notification);
+      case NOTIFICATION_CHANNELS.SLACK:
+        return this._sendSlackNotification(notification);
+      default:
+        throw new Error(`Unknown notification channel: ${channel}`);
+    }
+  }
+
+  /**
+   * Send console notification
+   */
+  _sendConsoleNotification(notification) {
+    const colors = {
+      low: '\x1b[36m',    // Cyan
+      medium: '\x1b[33m', // Yellow
+      high: '\x1b[31m',   // Red
+      critical: '\x1b[35m' // Magenta
+    };
+    
+    const reset = '\x1b[0m';
+    const color = colors[notification.priority] || '';
+    
+    console.log(`${color}🔔 ${notification.title}${reset}`);
+    console.log(`${notification.message}`);
+    if (notification.description) {
+      console.log(`${notification.description}`);
+    }
+    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.metadata.timestamp,
+      id: notification.id,
+      type: notification.type,
+      priority: notification.priority,
+      title: notification.title,
+      message: notification.message,
+      metadata: notification.metadata
+    };
+    
+    fs.appendFileSync(this.options.logFile, JSON.stringify(logEntry) + '\n');
+  }
+
+  /**
+   * Send desktop notification
+   */
+  _sendDesktopNotification(notification) {
+    if (!this.options.enableDesktop) {
+      return;
+    }
+    
+    try {
+      // Try to use system notification library
+      const notifier = require('node-notifier');
+      
+      notifier.notify({
+        title: this.options.desktopTitle,
+        subtitle: notification.title,
+        message: notification.message,
+        priority: notification.priority === 'critical' ? 'critical' : 'normal',
+        sound: notification.priority === 'critical' ? 'Bottle' : 'Glass',
+        wait: notification.priority === 'critical'
+      });
+    } catch (error) {
+      console.log('Desktop notifications not available:', error.message);
+    }
+  }
+
+  /**
+   * Send email notification (placeholder)
+   */
+  _sendEmailNotification(notification) {
+    // Placeholder for email implementation
+    console.log(`📧 Email notification would be sent for: ${notification.title}`);
+  }
+
+  /**
+   * Send Slack notification (placeholder)
+   */
+  _sendSlackNotification(notification) {
+    // Placeholder for Slack implementation
+    console.log(`💬 Slack notification would be sent for: ${notification.title}`);
+  }
+
+  /**
+   * Check if notification is rate limited
+   */
+  _isRateLimitKey(key) {
+    const now = Date.now();
+    const lastTime = this.lastNotificationTime.get(key);
+    
+    if (lastTime && (now - lastTime) < this.options.rateLimitMs) {
+      return true;
+    }
+    
+    this.lastNotificationTime.set(key, now);
+    return false;
+  }
+
+  /**
+   * Update notification statistics
+   */
+  _updateStats(notification) {
+    this.stats.totalNotifications++;
+    this.stats.lastNotification = new Date().toISOString();
+    
+    // Update channel stats (would be tracked in _sendToChannel)
+    // Update priority stats
+    this.stats.notificationsByPriority[notification.priority] = 
+      (this.stats.notificationsByPriority[notification.priority] || 0) + 1;
+  }
+
+  /**
+   * Get notification statistics
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      enabled: this.options.enabled,
+      channels: this.options.channels,
+      rateLimitActive: this.options.enableRateLimit
+    };
+  }
+
+  /**
+   * Test notification system
+   */
+  async testNotification() {
+    const testNotification = {
+      id: `test-${Date.now()}`,
+      type: 'test',
+      priority: NOTIFICATION_PRIORITY.MEDIUM,
+      title: 'Test Notification',
+      message: 'This is a test notification from the continuous scan notification system',
+      description: 'If you see this, notifications are working correctly',
+      metadata: {
+        timestamp: new Date().toISOString(),
+        source: 'test'
+      }
+    };
+    
+    return await this._sendNotification(testNotification);
+  }
+
+  /**
+   * Shutdown notification manager
+   */
+  shutdown() {
+    this.removeAllListeners();
+    if (this.alertSystem) {
+      this.alertSystem.shutdown();
+    }
+  }
+}
+
+module.exports = {
+  NotificationManager,
+  NOTIFICATION_CHANNELS,
+  NOTIFICATION_PRIORITY
+};