thuban 0.3.2 → 0.3.3

package/packages/scanner/sentinel-core.js

@@ -1,608 +1,616 @@
-/**
- * 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;
-
-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');
-
-      // 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);
-
-      // 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 || []));
-
-      // 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 };
+/**
+ * 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 };