vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/monitoring/alert-system.js

@@ -0,0 +1,834 @@
+/**
+ * Alert System for File Size Compliance
+ * 
+ * Provides intelligent alerting for files approaching or exceeding size limits,
+ * with configurable thresholds, notification channels, and escalation policies.
+ */
+
+const EventEmitter = require('events');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Alert severity levels
+ */
+const ALERT_SEVERITY = {
+  INFO: 'info',
+  WARNING: 'warning',
+  ERROR: 'error',
+  CRITICAL: 'critical'
+};
+
+/**
+ * Alert categories
+ */
+const ALERT_CATEGORIES = {
+  FILE_SIZE: 'file_size',
+  CONSTITUTIONAL: 'constitutional',
+  PERFORMANCE: 'performance',
+  SYSTEM: 'system'
+};
+
+/**
+ * Alert class
+ */
+class Alert {
+  constructor(data = {}) {
+    this.id = data.id || this.generateId();
+    this.category = data.category || ALERT_CATEGORIES.FILE_SIZE;
+    this.severity = data.severity || ALERT_SEVERITY.WARNING;
+    this.title = data.title || '';
+    this.message = data.message || '';
+    this.description = data.description || '';
+    this.filePath = data.filePath || '';
+    this.metadata = {
+      timestamp: data.timestamp || new Date().toISOString(),
+      source: data.source || 'alert-system',
+      version: data.version || '1.0.0',
+      ...data.metadata
+    };
+    this.context = {
+      lineCount: data.lineCount || 0,
+      limit: data.limit || 555,
+      excessLines: data.excessLines || 0,
+      percentage: data.percentage || 0,
+      ...data.context
+    };
+    this.actions = data.actions || [];
+    this.escalationLevel = data.escalationLevel || 0;
+    this.isResolved = data.isResolved || false;
+    this.resolvedAt = data.resolvedAt || null;
+    this.resolvedBy = data.resolvedBy || null;
+  }
+
+  generateId() {
+    return `alert_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  resolve(resolvedBy = 'system') {
+    this.isResolved = true;
+    this.resolvedAt = new Date().toISOString();
+    this.resolvedBy = resolvedBy;
+    return this;
+  }
+
+  escalate() {
+    this.escalationLevel++;
+    return this;
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      category: this.category,
+      severity: this.severity,
+      title: this.title,
+      message: this.message,
+      description: this.description,
+      filePath: this.filePath,
+      metadata: this.metadata,
+      context: this.context,
+      actions: this.actions,
+      escalationLevel: this.escalationLevel,
+      isResolved: this.isResolved,
+      resolvedAt: this.resolvedAt,
+      resolvedBy: this.resolvedBy
+    };
+  }
+
+  static fromJSON(data) {
+    return new Alert(data);
+  }
+}
+
+/**
+ * Alert system class
+ */
+class AlertSystem extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.options = {
+      // Thresholds
+      warningThreshold: options.warningThreshold || 500,
+      errorThreshold: options.errorThreshold || 555,
+      criticalThreshold: options.criticalThreshold || 800,
+      
+      // Alert settings
+      enableNotifications: options.enableNotifications !== false,
+      enableEscalation: options.enableEscalation !== false,
+      enableCooldown: options.enableCooldown !== false,
+      cooldownMs: options.cooldownMs || 300000, // 5 minutes
+      
+      // Escalation settings
+      maxEscalationLevel: options.maxEscalationLevel || 3,
+      escalationIntervalMs: options.escalationIntervalMs || 1800000, // 30 minutes
+      
+      // Notification channels
+      channels: options.channels || ['console', 'file'],
+      logFile: options.logFile || './logs/alerts.log',
+      
+      // Filtering
+      duplicateAlertThresholdMs: options.duplicateAlertThresholdMs || 60000, // 1 minute
+      
+      ...options
+    };
+    
+    this.alerts = new Map(); // active alerts
+    this.alertHistory = []; // all alerts
+    this.cooldownTimers = new Map();
+    this.escalationTimers = new Map();
+    this.lastAlerts = new Map(); // for duplicate detection
+    
+    this.stats = {
+      totalAlerts: 0,
+      alertsBySeverity: { info: 0, warning: 0, error: 0, critical: 0 },
+      alertsByCategory: {},
+      escalatedAlerts: 0,
+      resolvedAlerts: 0,
+      startTime: new Date(),
+      lastAlertTime: null
+    };
+    
+    // Ensure log directory exists
+    if (this.options.channels.includes('file')) {
+      const logDir = path.dirname(this.options.logFile);
+      if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+      }
+    }
+  }
+
+  /**
+   * Process file validation results and generate alerts
+   */
+  processValidationResults(filePath, validationResults) {
+    const alerts = [];
+    
+    // File size alerts
+    if (validationResults.lineLimitValidation) {
+      const lineAlert = this.createFileSizeAlert(filePath, validationResults);
+      if (lineAlert) alerts.push(lineAlert);
+    }
+    
+    // Constitutional compliance alerts
+    if (validationResults.constitutionalValidation) {
+      const constitutionalAlerts = this.createConstitutionalAlerts(filePath, validationResults);
+      alerts.push(...constitutionalAlerts);
+    }
+    
+    // Process all alerts
+    for (const alert of alerts) {
+      this.processAlert(alert);
+    }
+    
+    return alerts;
+  }
+
+  /**
+   * Create file size alert
+   */
+  createFileSizeAlert(filePath, validationResults) {
+    const lineValidation = validationResults.lineLimitValidation;
+    const lineCount = validationResults.lineCount || 0;
+    
+    if (!lineValidation.violation) {
+      return null;
+    }
+    
+    const violation = lineValidation.violation;
+    let severity = ALERT_SEVERITY.WARNING;
+    let title = 'File Size Warning';
+    
+    if (lineCount > this.options.criticalThreshold) {
+      severity = ALERT_SEVERITY.CRITICAL;
+      title = 'Critical File Size Violation';
+    } else if (lineCount > this.options.errorThreshold) {
+      severity = ALERT_SEVERITY.ERROR;
+      title = 'File Size Violation';
+    }
+    
+    return new Alert({
+      category: ALERT_CATEGORIES.FILE_SIZE,
+      severity,
+      title,
+      message: `${filePath} has ${lineCount} lines (limit: ${this.options.errorThreshold})`,
+      description: `File exceeds the 555-line limit by ${violation.excessLines} lines (${violation.percentageOverLimit}% over)`,
+      filePath,
+      lineCount,
+      limit: this.options.errorThreshold,
+      excessLines: violation.excessLines,
+      percentage: violation.percentageOverLimit,
+      actions: [
+        'Refactor file into smaller modules',
+        'Extract related functionality into separate files',
+        'Consider splitting by logical boundaries'
+      ]
+    });
+  }
+
+  /**
+   * Create constitutional compliance alerts
+   */
+  createConstitutionalAlerts(filePath, validationResults) {
+    const alerts = [];
+    const constitutionalValidation = validationResults.constitutionalValidation || [];
+    
+    for (const issue of constitutionalValidation) {
+      if (issue.severity === 'info') continue; // Skip info-level issues
+      
+      const severity = issue.severity === 'critical' ? ALERT_SEVERITY.CRITICAL :
+                     issue.severity === 'error' ? ALERT_SEVERITY.ERROR :
+                     ALERT_SEVERITY.WARNING;
+      
+      const alert = new Alert({
+        category: ALERT_CATEGORIES.CONSTITUTIONAL,
+        severity,
+        title: `${issue.category.charAt(0).toUpperCase() + issue.category.slice(1)} Violation`,
+        message: `${filePath}: ${issue.message}`,
+        description: issue.description || `Constitutional compliance issue in ${issue.category}`,
+        filePath,
+        context: {
+          rule: issue.rule,
+          lineNumber: issue.lineNumber,
+          ...issue.details
+        },
+        actions: issue.suggestion ? [issue.suggestion] : ['Review constitutional requirements']
+      });
+      
+      alerts.push(alert);
+    }
+    
+    return alerts;
+  }
+
+  /**
+   * Process an alert
+   */
+  processAlert(alert) {
+    // Check for duplicates
+    if (this.isDuplicateAlert(alert)) {
+      return null;
+    }
+    
+    // Check cooldown
+    if (this.isInCooldown(alert.filePath, alert.category)) {
+      return null;
+    }
+    
+    // Add to active alerts
+    this.alerts.set(alert.id, alert);
+    this.alertHistory.push(alert);
+    
+    // Update stats
+    this.updateStats(alert);
+    
+    // Set cooldown
+    if (this.options.enableCooldown) {
+      this.setCooldown(alert.filePath, alert.category);
+    }
+    
+    // Setup escalation if enabled
+    if (this.options.enableEscalation && alert.severity !== 'info') {
+      this.setupEscalation(alert);
+    }
+    
+    // Send notifications
+    this.sendNotifications(alert);
+    
+    // Emit events
+    this.emit('alert', alert);
+    this.emit(`alert:${alert.severity}`, alert);
+    this.emit(`alert:${alert.category}`, alert);
+    
+    // Update last alert tracking
+    this.lastAlerts.set(`${alert.filePath}:${alert.category}`, {
+      timestamp: Date.now(),
+      alertId: alert.id
+    });
+    
+    return alert;
+  }
+
+  /**
+   * Check if alert is duplicate
+   */
+  isDuplicateAlert(alert) {
+    const key = `${alert.filePath}:${alert.category}`;
+    const lastAlert = this.lastAlerts.get(key);
+    
+    if (!lastAlert) {
+      return false;
+    }
+    
+    const timeDiff = Date.now() - lastAlert.timestamp;
+    return timeDiff < this.options.duplicateAlertThresholdMs;
+  }
+
+  /**
+   * Check if in cooldown period
+   */
+  isInCooldown(filePath, category) {
+    const key = `${filePath}:${category}`;
+    return this.cooldownTimers.has(key);
+  }
+
+  /**
+   * Set cooldown period
+   */
+  setCooldown(filePath, category) {
+    const key = `${filePath}:${category}`;
+    
+    // Clear existing timer
+    if (this.cooldownTimers.has(key)) {
+      clearTimeout(this.cooldownTimers.get(key));
+    }
+    
+    // Set new timer
+    const timer = setTimeout(() => {
+      this.cooldownTimers.delete(key);
+    }, this.options.cooldownMs);
+    
+    this.cooldownTimers.set(key, timer);
+  }
+
+  /**
+   * Setup escalation for alert
+   */
+  setupEscalation(alert) {
+    if (alert.escalationLevel >= this.options.maxEscalationLevel) {
+      return;
+    }
+    
+    const escalationKey = alert.id;
+    
+    // Clear existing escalation timer
+    if (this.escalationTimers.has(escalationKey)) {
+      clearTimeout(this.escalationTimers.get(escalationKey));
+    }
+    
+    // Set escalation timer
+    const timer = setTimeout(() => {
+      this.escalateAlert(alert);
+    }, this.options.escalationIntervalMs);
+    
+    this.escalationTimers.set(escalationKey, timer);
+  }
+
+  /**
+   * Escalate alert
+   */
+  escalateAlert(alert) {
+    if (alert.escalationLevel >= this.options.maxEscalationLevel) {
+      return;
+    }
+    
+    alert.escalate();
+    this.stats.escalatedAlerts++;
+    
+    // Update severity if needed
+    if (alert.severity === ALERT_SEVERITY.WARNING && alert.escalationLevel >= 1) {
+      alert.severity = ALERT_SEVERITY.ERROR;
+    } else if (alert.severity === ALERT_SEVERITY.ERROR && alert.escalationLevel >= 2) {
+      alert.severity = ALERT_SEVERITY.CRITICAL;
+    }
+    
+    // Update title
+    alert.title = `[ESCALATED L${alert.escalationLevel}] ${alert.title}`;
+    
+    // Send notifications for escalated alert
+    this.sendNotifications(alert);
+    
+    // Emit escalation event
+    this.emit('alertEscalated', alert);
+    
+    // Setup next escalation
+    this.setupEscalation(alert);
+  }
+
+  /**
+   * Handle new violations from continuous scan
+   */
+  handleContinuousScanViolations(violations, scanInfo = {}) {
+    const alerts = [];
+    
+    for (const violation of violations) {
+      // Create alert for each new violation
+      const alert = this.createViolationAlert(violation.filePath, {
+        lineCount: violation.lineCount,
+        lineLimitValidation: violation.lineLimitValidation,
+        constitutionalValidation: violation.constitutionalValidation
+      });
+      
+      if (alert) {
+        // Add continuous scan metadata
+        alert.metadata.source = 'continuous-scan';
+        alert.metadata.scanId = scanInfo.scanId;
+        alert.metadata.scanTimestamp = scanInfo.timestamp;
+        alert.metadata.isNewViolation = true;
+        
+        alerts.push(alert);
+      }
+    }
+    
+    // Send batch notification if multiple violations
+    if (alerts.length > 1) {
+      this.sendBatchViolationAlert(alerts, scanInfo);
+    } else if (alerts.length === 1) {
+      this.sendAlert(alerts[0]);
+    }
+    
+    return alerts;
+  }
+
+  /**
+   * Send batch violation alert
+   */
+  sendBatchViolationAlert(alerts, scanInfo) {
+    const batchAlert = new Alert({
+      category: ALERT_CATEGORIES.FILE_SIZE,
+      severity: ALERT_SEVERITY.WARNING,
+      title: `Batch Violation Alert - ${alerts.length} files`,
+      message: `Continuous scan detected ${alerts.length} files with size violations`,
+      description: `The following files exceeded the 555-line limit: ${alerts.map(a => a.filePath).join(', ')}`,
+      metadata: {
+        source: 'continuous-scan',
+        scanId: scanInfo.scanId,
+        scanTimestamp: scanInfo.timestamp,
+        violationCount: alerts.length,
+        violationFiles: alerts.map(a => ({
+          filePath: a.filePath,
+          lineCount: a.metadata.lineCount,
+          excessLines: a.metadata.excessLines
+        }))
+      }
+    });
+    
+    this.sendAlert(batchAlert);
+  }
+
+  /**
+   * Send notifications through configured channels
+   */
+  sendNotifications(alert) {
+    for (const channel of this.options.channels) {
+      try {
+        switch (channel) {
+          case 'console':
+            this.sendConsoleNotification(alert);
+            break;
+          case 'file':
+            this.sendFileNotification(alert);
+            break;
+          case 'email':
+            this.sendEmailNotification(alert);
+            break;
+          case 'slack':
+            this.sendSlackNotification(alert);
+            break;
+          default:
+            console.warn(`Unknown notification channel: ${channel}`);
+        }
+      } catch (error) {
+        console.error(`Failed to send ${channel} notification:`, error);
+      }
+    }
+  }
+
+  /**
+   * Send console notification
+   */
+  sendConsoleNotification(alert) {
+    const colors = {
+      info: '\x1b[36m',
+      warning: '\x1b[33m',
+      error: '\x1b[31m',
+      critical: '\x1b[35m',
+      reset: '\x1b[0m',
+      bold: '\x1b[1m'
+    };
+    
+    const color = colors[alert.severity] || colors.info;
+    const escalation = alert.escalationLevel > 0 ? ` [L${alert.escalationLevel}]` : '';
+    
+    console.log(`${color}${colors.bold}[ALERT${escalation}] ${alert.title}${colors.reset}`);
+    console.log(`${color}  ${alert.message}${colors.reset}`);
+    console.log(`  File: ${alert.filePath}`);
+    console.log(`  Time: ${new Date(alert.metadata.timestamp).toLocaleString()}`);
+    
+    if (alert.context.lineCount) {
+      console.log(`  Lines: ${alert.context.lineCount}/${alert.context.limit}`);
+    }
+    
+    if (alert.actions.length > 0) {
+      console.log(`  Actions: ${alert.actions.slice(0, 2).join(', ')}`);
+    }
+    
+    console.log('');
+  }
+
+  /**
+   * Send file notification
+   */
+  sendFileNotification(alert) {
+    const logEntry = {
+      timestamp: alert.metadata.timestamp,
+      id: alert.id,
+      severity: alert.severity,
+      category: alert.category,
+      title: alert.title,
+      message: alert.message,
+      filePath: alert.filePath,
+      context: alert.context,
+      escalationLevel: alert.escalationLevel
+    };
+    
+    const logLine = JSON.stringify(logEntry) + '\n';
+    fs.appendFileSync(this.options.logFile, logLine, 'utf8');
+  }
+
+  /**
+   * Send email notification (placeholder)
+   */
+  sendEmailNotification(alert) {
+    // Placeholder for email implementation
+    console.log(`📧 Email notification sent for alert: ${alert.title}`);
+  }
+
+  /**
+   * Send Slack notification (placeholder)
+   */
+  sendSlackNotification(alert) {
+    // Placeholder for Slack implementation
+    console.log(`💬 Slack notification sent for alert: ${alert.title}`);
+  }
+
+  /**
+   * Resolve alert
+   */
+  resolveAlert(alertId, resolvedBy = 'user') {
+    const alert = this.alerts.get(alertId);
+    if (!alert) {
+      return false;
+    }
+    
+    alert.resolve(resolvedBy);
+    this.alerts.delete(alertId);
+    this.stats.resolvedAlerts++;
+    
+    // Clear escalation timer
+    if (this.escalationTimers.has(alertId)) {
+      clearTimeout(this.escalationTimers.get(alertId));
+      this.escalationTimers.delete(alertId);
+    }
+    
+    // Emit resolution event
+    this.emit('alertResolved', alert);
+    
+    return true;
+  }
+
+  /**
+   * Resolve alerts for file
+   */
+  resolveAlertsForFile(filePath, resolvedBy = 'user') {
+    const resolvedAlerts = [];
+    
+    for (const [alertId, alert] of this.alerts.entries()) {
+      if (alert.filePath === filePath) {
+        this.resolveAlert(alertId, resolvedBy);
+        resolvedAlerts.push(alert);
+      }
+    }
+    
+    return resolvedAlerts;
+  }
+
+  /**
+   * Get active alerts
+   */
+  getActiveAlerts(filters = {}) {
+    let alerts = Array.from(this.alerts.values());
+    
+    // Apply filters
+    if (filters.severity) {
+      alerts = alerts.filter(alert => alert.severity === filters.severity);
+    }
+    
+    if (filters.category) {
+      alerts = alerts.filter(alert => alert.category === filters.category);
+    }
+    
+    if (filters.filePath) {
+      alerts = alerts.filter(alert => alert.filePath === filters.filePath);
+    }
+    
+    if (filters.unresolvedOnly) {
+      alerts = alerts.filter(alert => !alert.isResolved);
+    }
+    
+    // Sort by timestamp (newest first)
+    alerts.sort((a, b) => new Date(b.metadata.timestamp) - new Date(a.metadata.timestamp));
+    
+    return alerts;
+  }
+
+  /**
+   * Get alert statistics
+   */
+  getStats() {
+    const uptime = Date.now() - this.stats.startTime.getTime();
+    
+    return {
+      ...this.stats,
+      uptime,
+      activeAlerts: this.alerts.size,
+      alertsInHistory: this.alertHistory.length,
+      averageAlertsPerHour: this.stats.totalAlerts > 0 ? 
+        (this.stats.totalAlerts / (uptime / 1000 / 60 / 60)) : 0,
+      resolutionRate: this.stats.totalAlerts > 0 ? 
+        (this.stats.resolvedAlerts / this.stats.totalAlerts * 100) : 0
+    };
+  }
+
+  /**
+   * Update statistics
+   */
+  updateStats(alert) {
+    this.stats.totalAlerts++;
+    this.stats.alertsBySeverity[alert.severity]++;
+    this.stats.alertsByCategory[alert.category] = 
+      (this.stats.alertsByCategory[alert.category] || 0) + 1;
+    this.stats.lastAlertTime = new Date();
+  }
+
+  /**
+   * Generate alert report
+   */
+  generateReport(format = 'json') {
+    const stats = this.getStats();
+    const activeAlerts = this.getActiveAlerts();
+    
+    const report = {
+      metadata: {
+        generatedAt: new Date().toISOString(),
+        uptime: stats.uptime,
+        system: 'alert-system'
+      },
+      summary: stats,
+      activeAlerts: activeAlerts.map(alert => alert.toJSON()),
+      recentAlerts: this.alertHistory.slice(-10).map(alert => alert.toJSON()),
+      topAlertFiles: this.getTopAlertFiles(),
+      alertTrends: this.getAlertTrends()
+    };
+    
+    switch (format.toLowerCase()) {
+      case 'json':
+        return JSON.stringify(report, null, 2);
+      case 'summary':
+        return this.generateSummaryReport(report);
+      default:
+        return report;
+    }
+  }
+
+  /**
+   * Generate summary report
+   */
+  generateSummaryReport(report) {
+    const summary = report.summary;
+    
+    let text = '# Alert System Summary Report\n\n';
+    text += `**Generated:** ${new Date().toLocaleString()}\n`;
+    text += `**Uptime:** ${Math.floor(summary.uptime / 1000 / 60)} minutes\n\n`;
+    
+    text += `## Summary\n\n`;
+    text += `- **Total Alerts:** ${summary.totalAlerts}\n`;
+    text += `- **Active Alerts:** ${summary.activeAlerts}\n`;
+    text += `- **Resolved Alerts:** ${summary.resolvedAlerts}\n`;
+    text += `- **Escalated Alerts:** ${summary.escalatedAlerts}\n`;
+    text += `- **Resolution Rate:** ${summary.resolutionRate.toFixed(1)}%\n`;
+    text += `- **Avg Alerts/Hour:** ${summary.averageAlertsPerHour.toFixed(1)}\n\n`;
+    
+    text += `## Alerts by Severity\n\n`;
+    for (const [severity, count] of Object.entries(summary.alertsBySeverity)) {
+      text += `- **${severity}:** ${count}\n`;
+    }
+    text += '\n';
+    
+    text += `## Alerts by Category\n\n`;
+    for (const [category, count] of Object.entries(summary.alertsByCategory)) {
+      text += `- **${category}:** ${count}\n`;
+    }
+    text += '\n';
+    
+    if (report.topAlertFiles.length > 0) {
+      text += `## Top Alert Files\n\n`;
+      for (const file of report.topAlertFiles) {
+        text += `- **${file.filePath}:** ${file.alertCount} alerts\n`;
+      }
+      text += '\n';
+    }
+    
+    return text;
+  }
+
+  /**
+   * Get top alert files
+   */
+  getTopAlertFiles() {
+    const fileAlertCounts = {};
+    
+    for (const alert of this.alertHistory) {
+      const filePath = alert.filePath;
+      fileAlertCounts[filePath] = (fileAlertCounts[filePath] || 0) + 1;
+    }
+    
+    return Object.entries(fileAlertCounts)
+      .map(([filePath, alertCount]) => ({ filePath, alertCount }))
+      .sort((a, b) => b.alertCount - a.alertCount)
+      .slice(0, 10);
+  }
+
+  /**
+   * Get alert trends
+   */
+  getAlertTrends() {
+    const now = Date.now();
+    const intervals = {
+      '1h': 60 * 60 * 1000,
+      '6h': 6 * 60 * 60 * 1000,
+      '24h': 24 * 60 * 60 * 1000
+    };
+    
+    const trends = {};
+    
+    for (const [label, intervalMs] of Object.entries(intervals)) {
+      const cutoff = now - intervalMs;
+      const alerts = this.alertHistory.filter(alert => 
+        new Date(alert.metadata.timestamp).getTime() > cutoff
+      );
+      
+      trends[label] = {
+        count: alerts.length,
+        rate: alerts.length / (intervalMs / 1000 / 60 / 60) // per hour
+      };
+    }
+    
+    return trends;
+  }
+
+  /**
+   * Clear all alerts
+   */
+  clearAllAlerts() {
+    // Clear all timers
+    for (const timer of this.cooldownTimers.values()) {
+      clearTimeout(timer);
+    }
+    for (const timer of this.escalationTimers.values()) {
+      clearTimeout(timer);
+    }
+    
+    // Clear data
+    this.alerts.clear();
+    this.cooldownTimers.clear();
+    this.escalationTimers.clear();
+    this.lastAlerts.clear();
+    
+    // Reset stats
+    this.stats = {
+      totalAlerts: 0,
+      alertsBySeverity: { info: 0, warning: 0, error: 0, critical: 0 },
+      alertsByCategory: {},
+      escalatedAlerts: 0,
+      resolvedAlerts: 0,
+      startTime: new Date(),
+      lastAlertTime: null
+    };
+    
+    this.emit('alertsCleared');
+  }
+
+  /**
+   * Shutdown alert system
+   */
+  shutdown() {
+    // Clear all timers
+    for (const timer of this.cooldownTimers.values()) {
+      clearTimeout(timer);
+    }
+    for (const timer of this.escalationTimers.values()) {
+      clearTimeout(timer);
+    }
+    
+    this.emit('shutdown');
+  }
+}
+
+module.exports = {
+  AlertSystem,
+  Alert,
+  ALERT_SEVERITY,
+  ALERT_CATEGORIES
+};