vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/monitoring/alert-system.js

@@ -9,25 +9,8 @@ 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'
-};
+const ALERT_SEVERITY = { INFO: 'info', WARNING: 'warning', ERROR: 'error', CRITICAL: 'critical' };
+const ALERT_CATEGORIES = { FILE_SIZE: 'file_size', CONSTITUTIONAL: 'constitutional', PERFORMANCE: 'performance', SYSTEM: 'system' };
 
 /**
  * Alert class
@@ -61,9 +44,7 @@ class Alert {
     this.resolvedBy = data.resolvedBy || null;
   }
 
-  generateId() {
-    return `alert_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
+  generateId() { return `alert_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`; }
 
   resolve(resolvedBy = 'system') {
     this.isResolved = true;
@@ -72,10 +53,7 @@ class Alert {
     return this;
   }
 
-  escalate() {
-    this.escalationLevel++;
-    return this;
-  }
+  escalate() { this.escalationLevel++; return this; }
 
   toJSON() {
     return {
@@ -338,17 +316,12 @@ class AlertSystem extends EventEmitter {
    */
   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);
   }
 
@@ -359,41 +332,27 @@ class AlertSystem extends EventEmitter {
     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

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

@@ -7,6 +7,13 @@
 
 const { AlertSystem, Alert, ALERT_SEVERITY, ALERT_CATEGORIES } = require('./alert-system');
 const EventEmitter = require('events');
+const {
+  NewViolationHandler,
+  ResolvedViolationHandler,
+  ThresholdHandler,
+  ErrorHandler,
+  ProgressHandler
+} = require('./notification-handlers');
 
 /**
  * Continuous Scan Notification Categories
@@ -63,6 +70,15 @@ class ContinuousScanNotificationSystem extends EventEmitter {
       batchedNotifications: 0
     };
     
+    // Initialize notification handlers
+    this.handlers = {
+      newViolation: new NewViolationHandler(this.options),
+      resolvedViolation: new ResolvedViolationHandler(this.options),
+      threshold: new ThresholdHandler(this.options),
+      error: new ErrorHandler(this.options),
+      progress: new ProgressHandler(this.options)
+    };
+    
     // Initialize alert system if provided
     if (this.options.enableAlertIntegration && this.options.alertSystem) {
       this.alertSystem = this.options.alertSystem;
@@ -88,25 +104,40 @@ class ContinuousScanNotificationSystem extends EventEmitter {
     // Compare with previous scan state
     const changes = this.detectChanges(scanResults, scanStatus);
     
-    // Generate notifications based on changes
+    // Generate notifications based on changes using handlers
     if (changes.newViolations.length > 0) {
-      notifications.push(...this.createNewViolationNotifications(changes.newViolations));
+      notifications.push(...this.handlers.newViolation.createNotifications(
+        changes.newViolations,
+        SCAN_NOTIFICATION_TYPES.NEW_VIOLATIONS_DETECTED
+      ));
     }
     
     if (changes.resolvedViolations.length > 0) {
-      notifications.push(...this.createResolvedViolationNotifications(changes.resolvedViolations));
+      notifications.push(...this.handlers.resolvedViolation.createNotifications(
+        changes.resolvedViolations,
+        SCAN_NOTIFICATION_TYPES.VIOLATIONS_RESOLVED
+      ));
     }
     
     if (changes.thresholdExceeded) {
-      notifications.push(this.createThresholdExceededNotification(changes.thresholdExceeded));
+      notifications.push(this.handlers.threshold.createNotification(
+        changes.thresholdExceeded,
+        SCAN_NOTIFICATION_TYPES.THRESHOLD_EXCEEDED
+      ));
     }
     
     if (changes.scanError) {
-      notifications.push(this.createScanErrorNotification(changes.scanError));
+      notifications.push(this.handlers.error.createNotification(
+        changes.scanError,
+        SCAN_NOTIFICATION_TYPES.SCAN_ERROR
+      ));
     }
     
     if (changes.progressUpdate) {
-      notifications.push(this.createProgressNotification(changes.progressUpdate));
+      notifications.push(this.handlers.progress.createNotification(
+        changes.progressUpdate,
+        SCAN_NOTIFICATION_TYPES.PROGRESS_UPDATE
+      ));
     }
     
     // Process notifications
@@ -183,155 +214,6 @@ class ContinuousScanNotificationSystem extends EventEmitter {
     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
    */
@@ -525,27 +407,6 @@ class ContinuousScanNotificationSystem extends EventEmitter {
     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
    */
@@ -593,21 +454,6 @@ class ContinuousScanNotificationSystem extends EventEmitter {
     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
    */

package/src/monitoring/notification-handlers/base-handler.js

@@ -0,0 +1,58 @@
+/**
+ * Base Notification Handler
+ * 
+ * Base class for all notification handlers
+ */
+
+const { ALERT_SEVERITY } = require('../alert-system');
+
+/**
+ * Base Notification Handler
+ */
+class BaseNotificationHandler {
+  constructor(options = {}) {
+    this.options = {
+      minSignificantChange: options.minSignificantChange || 3,
+      enableSmartNotifications: options.enableSmartNotifications !== false,
+      ...options
+    };
+  }
+
+  /**
+   * Create notification(s) - to be implemented by subclasses
+   */
+  createNotifications(data) {
+    throw new Error('createNotifications must be implemented by subclass');
+  }
+
+  /**
+   * 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';
+  }
+
+  /**
+   * Check if notification should be suppressed
+   */
+  shouldSuppress(count) {
+    return this.options.enableSmartNotifications && 
+           count < this.options.minSignificantChange;
+  }
+}
+
+module.exports = { BaseNotificationHandler };

package/src/monitoring/notification-handlers/error-handler.js

@@ -0,0 +1,36 @@
+/**
+ * Error Notification Handler
+ * 
+ * Handles notifications for scan errors
+ */
+
+const { BaseNotificationHandler } = require('./base-handler');
+const { ALERT_SEVERITY } = require('../alert-system');
+
+/**
+ * Error Notification Handler
+ */
+class ErrorHandler extends BaseNotificationHandler {
+  /**
+   * Create scan error notification
+   */
+  createNotification(error, notificationType) {
+    return {
+      type: notificationType,
+      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'
+      ]
+    };
+  }
+}
+
+module.exports = { ErrorHandler };

package/src/monitoring/notification-handlers/index.js

@@ -0,0 +1,21 @@
+/**
+ * Notification Handlers Index
+ * 
+ * Exports all notification handler modules
+ */
+
+const { BaseNotificationHandler } = require('./base-handler');
+const { NewViolationHandler } = require('./new-violation-handler');
+const { ResolvedViolationHandler } = require('./resolved-violation-handler');
+const { ThresholdHandler } = require('./threshold-handler');
+const { ErrorHandler } = require('./error-handler');
+const { ProgressHandler } = require('./progress-handler');
+
+module.exports = {
+  BaseNotificationHandler,
+  NewViolationHandler,
+  ResolvedViolationHandler,
+  ThresholdHandler,
+  ErrorHandler,
+  ProgressHandler
+};

package/src/monitoring/notification-handlers/new-violation-handler.js

@@ -0,0 +1,91 @@
+/**
+ * New Violation Notification Handler
+ * 
+ * Handles notifications for newly detected file size violations
+ */
+
+const { BaseNotificationHandler } = require('./base-handler');
+const { ALERT_SEVERITY } = require('../alert-system');
+
+/**
+ * New Violation Notification Handler
+ */
+class NewViolationHandler extends BaseNotificationHandler {
+  constructor(options = {}) {
+    super(options);
+    this.options = {
+      ...this.options,
+      enableBatchNotifications: options.enableBatchNotifications !== false,
+      maxBatchSize: options.maxBatchSize || 10
+    };
+    this.stats = {
+      suppressedNotifications: 0
+    };
+  }
+
+  /**
+   * Create notifications for new violations
+   */
+  createNotifications(newViolations, notificationType) {
+    const notifications = [];
+    
+    if (newViolations.length === 0) return notifications;
+    
+    // Smart notification: only notify if significant change
+    if (this.shouldSuppress(newViolations.length)) {
+      this.stats.suppressedNotifications++;
+      return notifications;
+    }
+    
+    if (this.options.enableBatchNotifications && newViolations.length > this.options.maxBatchSize) {
+      // Create batch notification
+      notifications.push({
+        type: notificationType,
+        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: notificationType,
+          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;
+  }
+
+  /**
+   * Get handler statistics
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+}
+
+module.exports = { NewViolationHandler };

package/src/monitoring/notification-handlers/progress-handler.js

@@ -0,0 +1,48 @@
+/**
+ * Progress Notification Handler
+ * 
+ * Handles notifications for scan progress updates
+ */
+
+const { BaseNotificationHandler } = require('./base-handler');
+const { ALERT_SEVERITY } = require('../alert-system');
+
+/**
+ * Progress Notification Handler
+ */
+class ProgressHandler extends BaseNotificationHandler {
+  /**
+   * Create progress notification
+   */
+  createNotification(progressData, notificationType) {
+    const severity = progressData.type === 'initial_scan' ? ALERT_SEVERITY.INFO : ALERT_SEVERITY.INFO;
+    
+    return {
+      type: notificationType,
+      severity,
+      title: progressData.type === 'initial_scan' ? 'Initial Scan Completed' : 'Compliance Progress Update',
+      message: this.formatProgressMessage(progressData),
+      data: {
+        ...progressData,
+        timestamp: new Date().toISOString()
+      }
+    };
+  }
+
+  /**
+   * 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`;
+    }
+  }
+}
+
+module.exports = { ProgressHandler };

package/src/monitoring/notification-handlers/resolved-violation-handler.js

@@ -0,0 +1,54 @@
+/**
+ * Resolved Violation Notification Handler
+ * 
+ * Handles notifications for resolved file size violations
+ */
+
+const { BaseNotificationHandler } = require('./base-handler');
+const { ALERT_SEVERITY } = require('../alert-system');
+
+/**
+ * Resolved Violation Notification Handler
+ */
+class ResolvedViolationHandler extends BaseNotificationHandler {
+  constructor(options = {}) {
+    super(options);
+    this.options = {
+      ...this.options,
+      resolvedViolationsThreshold: options.resolvedViolationsThreshold || 5
+    };
+  }
+
+  /**
+   * Create notifications for resolved violations
+   */
+  createNotifications(resolvedViolations, notificationType) {
+    const notifications = [];
+    
+    if (resolvedViolations.length === 0) return notifications;
+    
+    // Only notify if significant number resolved
+    if (resolvedViolations.length >= this.options.resolvedViolationsThreshold) {
+      notifications.push({
+        type: notificationType,
+        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;
+  }
+}
+
+module.exports = { ResolvedViolationHandler };