thuban 0.3.3 → 0.4.0

package/packages/scanner/sentinel-core.js

@@ -1,616 +0,0 @@
-/**
- * Sentinel Core
- *
- * @purpose Event-driven SentinelCore component
- * @module sentinel
- * @layer application
- * @imports-from fs, path, events, sentinel/file-watcher.js, sentinel/code-scanner.js, sentinel/drift-detector.js, sentinel/health-checker.js, sentinel/alert-manager.js
- * @exports-to sentinel
- * @side-effects Process termination, Console output, Event emission
- * @critical-for sentinel
- */
-
-/**
- * Sentinel Core - Codebase Monitoring Orchestrator
- *
- * Continuous monitoring system that catches problems before they ship.
- * Coordinates file watching, code scanning, drift detection, and alerting.
- *
- * Part of Orion OS - will be spun out as Thuban SaaS
- *
- * Schedule:
- * - On commit: Security scan, contract validation, dependency update
- * - Every 6 hours: Full AST scan vs widget comparison
- * - Nightly: Complete rescan, CVE database check, architectural drift
- * - Weekly: Deep quality audit, trend report, technical debt assessment
- */
-
-const fs = require('fs');
-const path = require('path');
-const EventEmitter = require('events');
-
-// Sentinel components (will be required when available)
-let FileWatcher, CodeScanner, DriftDetector, HealthChecker, AlertManager, SecretScanner;
-
-class SentinelCore extends EventEmitter {
-  constructor(options = {}) {
-    super();
-
-    this.config = {
-      rootPath: options.rootPath || process.cwd(),
-      watchPatterns: options.watchPatterns || ['**/*.js', '**/*.ts', '**/*.json'],
-      ignorePatterns: options.ignorePatterns || ['node_modules/**', '.git/**', 'dist/**', '.orion/snapshots/**'],
-      scanIntervalHours: options.scanIntervalHours || 6,
-      dailyReportHour: options.dailyReportHour || 8, // 8 AM
-      weeklyReportDay: options.weeklyReportDay || 1, // Monday
-      enableRealtime: options.enableRealtime !== false,
-      enableScheduled: options.enableScheduled !== false,
-      alertThreshold: options.alertThreshold || 'warning', // 'info', 'warning', 'error', 'critical'
-      ...options
-    };
-
-    this.state = {
-      isRunning: false,
-      lastFullScan: null,
-      lastHealthCheck: null,
-      lastDriftCheck: null,
-      filesWatched: 0,
-      issuesFound: [],
-      metrics: {
-        totalScans: 0,
-        issuesDetected: 0,
-        issuesResolved: 0,
-        averageScanTime: 0
-      }
-    };
-
-    this.components = {
-      fileWatcher: null,
-      codeScanner: null,
-      driftDetector: null,
-      healthChecker: null,
-      alertManager: null
-    };
-
-    this.scheduledJobs = [];
-  }
-
-  /**
-   * Initialize all Sentinel components
-   */
-  async initialize() {
-    console.log('[SENTINEL] Initializing Sentinel Core...');
-
-    try {
-      // Load components
-      FileWatcher = require('./file-watcher.js');
-      CodeScanner = require('./code-scanner.js');
-      DriftDetector = require('./drift-detector.js');
-      HealthChecker = require('./health-checker.js');
-      AlertManager = require('./alert-manager.js');
-      SecretScanner = require('./secret-scanner.js');
-
-      // Initialize components
-      this.components.fileWatcher = new FileWatcher(this.config);
-      this.components.codeScanner = new CodeScanner(this.config);
-      this.components.driftDetector = new DriftDetector(this.config);
-      this.components.healthChecker = new HealthChecker(this.config);
-      this.components.alertManager = new AlertManager(this.config);
-      this.components.secretScanner = new SecretScanner(this.config);
-
-      // Wire up event handlers
-      this._setupEventHandlers();
-
-      console.log('[SENTINEL] All components initialized');
-      return { success: true };
-    } catch (error) {
-      console.error('[SENTINEL] Initialization failed:', error.message);
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
-   * Start Sentinel monitoring
-   */
-  async start() {
-    if (this.state.isRunning) {
-      console.log('[SENTINEL] Already running');
-      return { success: true, message: 'Already running' };
-    }
-
-    console.log('[SENTINEL] Starting Sentinel monitoring...');
-
-    try {
-      // Start file watcher for real-time monitoring
-      if (this.config.enableRealtime && this.components.fileWatcher) {
-        await this.components.fileWatcher.start();
-        this.state.filesWatched = this.components.fileWatcher.getWatchedCount();
-      }
-
-      // Set up scheduled jobs
-      if (this.config.enableScheduled) {
-        this._setupScheduledJobs();
-      }
-
-      // Run initial health check
-      await this.runHealthCheck();
-
-      // Run initial scan
-      const initialScan = await this.runFullScan();
-
-      this.state.isRunning = true;
-      this.emit('started', { timestamp: new Date().toISOString() });
-
-      console.log('[SENTINEL] Monitoring active');
-      console.log(`[SENTINEL] Watching ${this.state.filesWatched} files`);
-      console.log(`[SENTINEL] Initial scan found ${initialScan.issues?.length || 0} issues`);
-
-      return {
-        success: true,
-        filesWatched: this.state.filesWatched,
-        initialIssues: initialScan.issues?.length || 0
-      };
-    } catch (error) {
-      console.error('[SENTINEL] Start failed:', error.message);
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
-   * Stop Sentinel monitoring
-   */
-  async stop() {
-    if (!this.state.isRunning) {
-      return { success: true, message: 'Not running' };
-    }
-
-    console.log('[SENTINEL] Stopping Sentinel monitoring...');
-
-    // Stop file watcher
-    if (this.components.fileWatcher) {
-      await this.components.fileWatcher.stop();
-    }
-
-    // Clear scheduled jobs
-    this.scheduledJobs.forEach(job => clearInterval(job));
-    this.scheduledJobs = [];
-
-    this.state.isRunning = false;
-    this.emit('stopped', { timestamp: new Date().toISOString() });
-
-    console.log('[SENTINEL] Monitoring stopped');
-    return { success: true };
-  }
-
-  /**
-   * Run a full codebase scan
-   */
-  async runFullScan(options = {}) {
-    const startTime = Date.now();
-    console.log('[SENTINEL] Starting full codebase scan...');
-
-    const scanResult = {
-      timestamp: new Date().toISOString(),
-      duration: 0,
-      filesScanned: 0,
-      issues: [],
-      summary: {}
-    };
-
-    try {
-      if (!this.components.codeScanner) {
-        throw new Error('Code scanner not initialized');
-      }
-
-      // Run code scanner
-      const codeResults = await this.components.codeScanner.scanAll();
-      scanResult.filesScanned = codeResults.filesScanned || 0;
-      scanResult.issues.push(...(codeResults.issues || []));
-
-      if (this.components.secretScanner) {
-        const secretResults = await this.components.secretScanner.scanAll();
-        scanResult.filesScanned += secretResults.filesScanned || 0;
-        scanResult.issues.push(...(secretResults.issues || []));
-      }
-
-      // Run drift detection
-      if (this.components.driftDetector) {
-        const driftResults = await this.components.driftDetector.detectAll();
-        scanResult.issues.push(...(driftResults.issues || []));
-        this.state.lastDriftCheck = new Date().toISOString();
-      }
-
-      // Calculate duration and update metrics
-      scanResult.duration = Date.now() - startTime;
-      this.state.lastFullScan = scanResult.timestamp;
-      this.state.metrics.totalScans++;
-      this.state.metrics.issuesDetected += scanResult.issues.length;
-
-      // Update running average
-      this.state.metrics.averageScanTime =
-        (this.state.metrics.averageScanTime * (this.state.metrics.totalScans - 1) + scanResult.duration)
-        / this.state.metrics.totalScans;
-
-      // Generate summary
-      scanResult.summary = this._generateScanSummary(scanResult.issues);
-
-      // Store issues
-      this.state.issuesFound = scanResult.issues;
-
-      // Send alerts for critical issues
-      await this._processIssues(scanResult.issues);
-
-      console.log(`[SENTINEL] Scan complete: ${scanResult.filesScanned} files, ${scanResult.issues.length} issues, ${scanResult.duration}ms`);
-      this.emit('scanComplete', scanResult);
-
-      return scanResult;
-    } catch (error) {
-      console.error('[SENTINEL] Full scan failed:', error.message);
-      scanResult.error = error.message;
-      return scanResult;
-    }
-  }
-
-  /**
-   * Run a quick scan on specific files
-   */
-  async runQuickScan(filePaths) {
-    if (!this.components.codeScanner) {
-      return { success: false, error: 'Code scanner not initialized' };
-    }
-
-    console.log(`[SENTINEL] Quick scan on ${filePaths.length} files...`);
-    const results = await this.components.codeScanner.scanFiles(filePaths);
-
-    // Process any issues found
-    if (results.issues && results.issues.length > 0) {
-      await this._processIssues(results.issues);
-    }
-
-    return results;
-  }
-
-  /**
-   * Run health check on all Orion systems
-   */
-  async runHealthCheck() {
-    console.log('[SENTINEL] Running health check...');
-
-    if (!this.components.healthChecker) {
-      return { success: false, error: 'Health checker not initialized' };
-    }
-
-    const healthResult = await this.components.healthChecker.checkAll();
-    this.state.lastHealthCheck = new Date().toISOString();
-
-    // Alert on unhealthy systems
-    if (healthResult.unhealthySystems && healthResult.unhealthySystems.length > 0) {
-      await this.components.alertManager?.sendAlert({
-        level: 'warning',
-        title: 'System Health Issues Detected',
-        message: `${healthResult.unhealthySystems.length} systems are unhealthy`,
-        details: healthResult.unhealthySystems
-      });
-    }
-
-    this.emit('healthCheck', healthResult);
-    return healthResult;
-  }
-
-  /**
-   * Generate daily health digest
-   */
-  async generateDailyDigest() {
-    console.log('[SENTINEL] Generating daily digest...');
-
-    const digest = {
-      date: new Date().toISOString().split('T')[0],
-      timestamp: new Date().toISOString(),
-      summary: {
-        issuesFound: this.state.issuesFound.length,
-        criticalIssues: this.state.issuesFound.filter(i => i.severity === 'critical').length,
-        warningIssues: this.state.issuesFound.filter(i => i.severity === 'warning').length,
-        filesWatched: this.state.filesWatched,
-        lastScan: this.state.lastFullScan,
-        lastHealthCheck: this.state.lastHealthCheck
-      },
-      topIssues: this.state.issuesFound
-        .sort((a, b) => this._severityScore(b.severity) - this._severityScore(a.severity))
-        .slice(0, 10),
-      metrics: this.state.metrics,
-      recommendations: this._generateRecommendations()
-    };
-
-    // Send digest via alert manager
-    if (this.components.alertManager) {
-      await this.components.alertManager.sendDigest(digest);
-    }
-
-    this.emit('dailyDigest', digest);
-    return digest;
-  }
-
-  /**
-   * Generate weekly report
-   */
-  async generateWeeklyReport() {
-    console.log('[SENTINEL] Generating weekly report...');
-
-    const report = {
-      weekOf: new Date().toISOString().split('T')[0],
-      timestamp: new Date().toISOString(),
-      summary: this.state.metrics,
-      issuesTrend: this._calculateTrend(),
-      codeQuality: await this._assessCodeQuality(),
-      technicalDebt: await this._assessTechnicalDebt(),
-      recommendations: this._generateRecommendations(),
-      fullIssueList: this.state.issuesFound
-    };
-
-    // Send report via alert manager
-    if (this.components.alertManager) {
-      await this.components.alertManager.sendWeeklyReport(report);
-    }
-
-    this.emit('weeklyReport', report);
-    return report;
-  }
-
-  /**
-   * Get current Sentinel status
-   */
-  getStatus() {
-    return {
-      isRunning: this.state.isRunning,
-      config: this.config,
-      state: {
-        ...this.state,
-        componentsLoaded: {
-          fileWatcher: !!this.components.fileWatcher,
-          codeScanner: !!this.components.codeScanner,
-          driftDetector: !!this.components.driftDetector,
-          healthChecker: !!this.components.healthChecker,
-          alertManager: !!this.components.alertManager
-        }
-      },
-      uptime: this.state.isRunning ? Date.now() - new Date(this.state.lastFullScan).getTime() : 0
-    };
-  }
-
-  /**
-   * Get all current issues
-   */
-  getIssues(filter = {}) {
-    let issues = [...this.state.issuesFound];
-
-    if (filter.severity) {
-      issues = issues.filter(i => i.severity === filter.severity);
-    }
-    if (filter.category) {
-      issues = issues.filter(i => i.category === filter.category);
-    }
-    if (filter.file) {
-      issues = issues.filter(i => i.file && i.file.includes(filter.file));
-    }
-
-    return issues;
-  }
-
-  // Private methods
-
-  _setupEventHandlers() {
-    // File watcher events
-    if (this.components.fileWatcher) {
-      this.components.fileWatcher.on('change', async (event) => {
-        console.log(`[SENTINEL] File changed: ${event.filePath}`);
-        await this.runQuickScan([event.filePath]);
-      });
-
-      this.components.fileWatcher.on('error', (error) => {
-        console.error('[SENTINEL] File watcher error:', error);
-      });
-    }
-
-    // Code scanner events
-    if (this.components.codeScanner) {
-      this.components.codeScanner.on('issueFound', async (issue) => {
-        await this._processIssues([issue]);
-      });
-    }
-  }
-
-  _setupScheduledJobs() {
-    // Full scan every N hours
-    const scanInterval = this.config.scanIntervalHours * 60 * 60 * 1000;
-    this.scheduledJobs.push(
-      setInterval(() => this.runFullScan(), scanInterval)
-    );
-
-    // Health check every hour
-    this.scheduledJobs.push(
-      setInterval(() => this.runHealthCheck(), 60 * 60 * 1000)
-    );
-
-    // Daily digest (check every hour if it's time)
-    this.scheduledJobs.push(
-      setInterval(() => {
-        const now = new Date();
-        if (now.getHours() === this.config.dailyReportHour && now.getMinutes() < 5) {
-          this.generateDailyDigest();
-        }
-      }, 60 * 60 * 1000)
-    );
-
-    // Weekly report (check daily if it's the right day)
-    this.scheduledJobs.push(
-      setInterval(() => {
-        const now = new Date();
-        if (now.getDay() === this.config.weeklyReportDay &&
-            now.getHours() === this.config.dailyReportHour &&
-            now.getMinutes() < 5) {
-          this.generateWeeklyReport();
-        }
-      }, 60 * 60 * 1000)
-    );
-
-    console.log(`[SENTINEL] Scheduled jobs: scan every ${this.config.scanIntervalHours}h, daily digest at ${this.config.dailyReportHour}:00`);
-  }
-
-  async _processIssues(issues) {
-    for (const issue of issues) {
-      // Check if issue meets alert threshold
-      if (this._meetsThreshold(issue.severity)) {
-        if (this.components.alertManager) {
-          await this.components.alertManager.sendAlert({
-            level: issue.severity,
-            title: `[${issue.category}] ${issue.title || issue.message}`,
-            message: issue.message,
-            file: issue.file,
-            line: issue.line,
-            details: issue
-          });
-        }
-      }
-    }
-  }
-
-  _meetsThreshold(severity) {
-    const levels = ['info', 'warning', 'error', 'critical'];
-    const severityIndex = levels.indexOf(severity);
-    const thresholdIndex = levels.indexOf(this.config.alertThreshold);
-    return severityIndex >= thresholdIndex;
-  }
-
-  _severityScore(severity) {
-    const scores = { info: 1, warning: 2, error: 3, critical: 4 };
-    return scores[severity] || 0;
-  }
-
-  _generateScanSummary(issues) {
-    return {
-      total: issues.length,
-      bySeverity: {
-        critical: issues.filter(i => i.severity === 'critical').length,
-        error: issues.filter(i => i.severity === 'error').length,
-        warning: issues.filter(i => i.severity === 'warning').length,
-        info: issues.filter(i => i.severity === 'info').length
-      },
-      byCategory: issues.reduce((acc, i) => {
-        acc[i.category] = (acc[i.category] || 0) + 1;
-        return acc;
-      }, {})
-    };
-  }
-
-  _generateRecommendations() {
-    const recommendations = [];
-    const issues = this.state.issuesFound;
-
-    // Check for security issues
-    const securityIssues = issues.filter(i => i.category === 'security');
-    if (securityIssues.length > 0) {
-      recommendations.push({
-        priority: 'high',
-        category: 'security',
-        message: `Address ${securityIssues.length} security issues before deploying`,
-        issues: securityIssues.slice(0, 5)
-      });
-    }
-
-    // Check for quality issues
-    const qualityIssues = issues.filter(i => i.category === 'quality');
-    if (qualityIssues.length > 10) {
-      recommendations.push({
-        priority: 'medium',
-        category: 'quality',
-        message: `Consider refactoring - ${qualityIssues.length} quality issues detected`,
-        issues: qualityIssues.slice(0, 5)
-      });
-    }
-
-    // Check for drift
-    const driftIssues = issues.filter(i => i.category === 'drift');
-    if (driftIssues.length > 0) {
-      recommendations.push({
-        priority: 'medium',
-        category: 'drift',
-        message: `${driftIssues.length} files have drifted from their declared contracts`,
-        issues: driftIssues.slice(0, 5)
-      });
-    }
-
-    return recommendations;
-  }
-
-  _calculateTrend() {
-    // Placeholder - would track historical data
-    return {
-      direction: 'stable',
-      change: 0,
-      note: 'Trend analysis requires historical data'
-    };
-  }
-
-  async _assessCodeQuality() {
-    // Placeholder - would calculate code quality score
-    return {
-      score: 75,
-      grade: 'B',
-      factors: {
-        complexity: 70,
-        maintainability: 80,
-        documentation: 65,
-        testCoverage: 40
-      }
-    };
-  }
-
-  async _assessTechnicalDebt() {
-    // Placeholder - would calculate technical debt
-    return {
-      estimatedHours: 40,
-      categories: {
-        refactoring: 20,
-        documentation: 10,
-        testing: 10
-      },
-      priorityItems: []
-    };
-  }
-}
-
-// Factory function for creating Sentinel instance
-function createSentinel(options = {}) {
-  return new SentinelCore(options);
-}
-
-// Main execution if run directly
-async function main() {
-  const sentinel = createSentinel({
-    rootPath: path.resolve(__dirname, '..'),
-    enableRealtime: true,
-    enableScheduled: false // Disable scheduled for testing
-  });
-
-  const initResult = await sentinel.initialize();
-  if (!initResult.success) {
-    console.error('Failed to initialize Sentinel:', initResult.error);
-    process.exit(1);
-  }
-
-  const startResult = await sentinel.start();
-  console.log('Sentinel status:', sentinel.getStatus());
-
-  // Keep running
-  process.on('SIGINT', async () => {
-    console.log('\nShutting down Sentinel...');
-    await sentinel.stop();
-    process.exit(0);
-  });
-}
-
-if (require.main === module) {
-  main().catch(console.error);
-}
-
-module.exports = { SentinelCore, createSentinel };