thuban 0.3.3 → 0.4.0

package/packages/scanner/ai-confidence-scorer.js

@@ -1,260 +0,0 @@
-/**
- * Thuban AI Confidence Scorer
- *
- * @purpose Score each function's probability of being AI-generated
- * @module thuban
- * @layer scanner
- * @exports-to cli
- * @critical-for USP — nobody else gives per-function AI probability scores
- */
-
-const fs = require('fs');
-const path = require('path');
-
-// Signals that indicate AI-generated code
-const AI_SIGNALS = {
-  // Naming patterns AI tends to use
-  genericNames: ['data', 'result', 'response', 'output', 'input', 'temp', 'item', 'element', 'val', 'obj', 'arr', 'str', 'num', 'flag', 'status'],
-
-  // Comment patterns AI adds
-  aiCommentPatterns: [
-    /\/\/\s*TODO:?\s*implement/i,
-    /\/\/\s*handle\s+error/i,
-    /\/\/\s*add\s+error\s+handling/i,
-    /\/\/\s*you\s+(can|may|might|should)/i,
-    /\/\/\s*replace\s+(this|with)/i,
-    /\/\/\s*this\s+(function|method|class)\s+(takes|accepts|returns|handles)/i,
-    /\/\/\s*example\s+usage/i,
-    /\/\/\s*note:?\s*this/i,
-    /\/\*\*[\s\S]*?@description\s/,
-    /\/\/\s*import.*if\s+needed/i,
-  ],
-
-  // Structural patterns
-  aiStructurePatterns: [
-    /try\s*\{[\s\S]*?\}\s*catch\s*\(\s*(?:error|err|e)\s*\)\s*\{[\s\S]*?console\.(log|error)\s*\(\s*(?:error|err|e)\s*\)/,  // Generic try/catch with console.log
-    /if\s*\(!.*\)\s*\{?\s*(?:return|throw)\s/,  // Guard clause pattern (AI loves these)
-  ],
-};
-
-class AIConfidenceScorer {
-  constructor(opts = {}) {
-    this.rootPath = opts.rootPath || process.cwd();
-  }
-
-  /**
-   * Score all functions in the given files
-   */
-  scan(files) {
-    const results = [];
-
-    for (const file of files) {
-      let content;
-      try {
-        const stat = fs.statSync(file);
-        if (stat.size > 512 * 1024) continue;
-        content = fs.readFileSync(file, 'utf-8');
-      } catch (e) {
-        continue;
-      }
-
-      const relPath = path.relative(this.rootPath, file);
-      if (this._isSkippable(relPath)) continue;
-
-      const functions = this._extractFunctions(content, relPath);
-      results.push(...functions);
-    }
-
-    // Sort by confidence descending
-    results.sort((a, b) => b.confidence - a.confidence);
-
-    const highConfidence = results.filter(r => r.confidence >= 70);
-    const mediumConfidence = results.filter(r => r.confidence >= 40 && r.confidence < 70);
-
-    return {
-      functions: results,
-      highConfidence,
-      mediumConfidence,
-      totalFunctions: results.length,
-      aiLikelyCount: highConfidence.length,
-      aiPossibleCount: mediumConfidence.length,
-      aiPercentage: results.length > 0
-        ? Math.round((highConfidence.length / results.length) * 100)
-        : 0,
-    };
-  }
-
-  // ─── Private ─────────────────────────────────────────────
-
-  _extractFunctions(content, filePath) {
-    const lines = content.split('\n');
-    const functions = [];
-
-    for (let i = 0; i < lines.length; i++) {
-      const fn = this._detectFunction(lines, i);
-      if (!fn) continue;
-
-      const endLine = this._findFunctionEnd(lines, i);
-      const body = lines.slice(i, endLine + 1).join('\n');
-      const bodyLines = lines.slice(i, endLine + 1);
-
-      const signals = this._scoreFunction(fn.name, body, bodyLines, lines, i);
-
-      functions.push({
-        file: filePath,
-        name: fn.name,
-        line: i + 1,
-        lineCount: endLine - i + 1,
-        confidence: signals.score,
-        signals: signals.reasons,
-        testCoverage: this._hasTests(fn.name, filePath) ? 'found' : 'none',
-        category: 'ai_confidence',
-        severity: signals.score >= 80 ? 'high' : signals.score >= 50 ? 'medium' : 'low',
-      });
-
-      i = endLine; // Skip past the function
-    }
-
-    return functions;
-  }
-
-  _scoreFunction(name, body, bodyLines, allLines, startLine) {
-    let score = 0;
-    const reasons = [];
-
-    // Signal 1: Generic variable names (0-15 points)
-    const genericCount = AI_SIGNALS.genericNames.filter(g => {
-      const regex = new RegExp(`\\b${g}\\b`, 'g');
-      return (body.match(regex) || []).length >= 2;
-    }).length;
-    if (genericCount >= 3) {
-      score += 15;
-      reasons.push(`${genericCount} generic variable names (data, result, response...)`);
-    } else if (genericCount >= 1) {
-      score += 8;
-      reasons.push(`${genericCount} generic variable name(s)`);
-    }
-
-    // Signal 2: AI-style comments (0-20 points)
-    const aiComments = AI_SIGNALS.aiCommentPatterns.filter(p => p.test(body)).length;
-    if (aiComments >= 2) {
-      score += 20;
-      reasons.push(`${aiComments} AI-style comments (TODO: implement, handle error, etc.)`);
-    } else if (aiComments >= 1) {
-      score += 10;
-      reasons.push('AI-style comment detected');
-    }
-
-    // Signal 3: Overly thorough JSDoc (0-10 points)
-    if (startLine > 0) {
-      const precedingLines = allLines.slice(Math.max(0, startLine - 10), startLine).join('\n');
-      if (/\/\*\*[\s\S]*@param[\s\S]*@returns?[\s\S]*@(?:throws|example)/s.test(precedingLines)) {
-        score += 10;
-        reasons.push('Exhaustive JSDoc (params + returns + throws/example)');
-      }
-    }
-
-    // Signal 4: Perfect error handling pattern (0-10 points)
-    const tryCatchCount = (body.match(/try\s*\{/g) || []).length;
-    if (tryCatchCount >= 2) {
-      score += 10;
-      reasons.push('Multiple try/catch blocks (AI over-handles errors)');
-    }
-
-    // Signal 5: Function is long and self-contained (0-15 points)
-    const lineCount = bodyLines.length;
-    if (lineCount >= 50) {
-      score += 15;
-      reasons.push(`${lineCount} lines — large self-contained function`);
-    } else if (lineCount >= 25) {
-      score += 8;
-      reasons.push(`${lineCount} lines`);
-    }
-
-    // Signal 6: No references to other functions in the same file (0-10 points)
-    // AI tends to generate isolated, self-contained functions
-    const internalCalls = allLines
-      .slice(0, startLine)
-      .concat(allLines.slice(startLine + lineCount))
-      .filter(l => l.includes(name)).length;
-    if (internalCalls === 0 && lineCount > 10) {
-      score += 10;
-      reasons.push('Isolated — no internal references');
-    }
-
-    // Signal 7: console.log in error handling (0-10 points)
-    if (/catch\s*\([^)]*\)\s*\{[^}]*console\.(log|error)\s*\(/.test(body)) {
-      score += 8;
-      reasons.push('console.log/error in catch block (AI default pattern)');
-    }
-
-    // Signal 8: Arrow functions with immediate destructuring (0-5 points)
-    if (/=>\s*\{[\s\n\r]*const\s*\{/.test(body)) {
-      score += 5;
-      reasons.push('Immediate destructuring after arrow (common AI pattern)');
-    }
-
-    // Signal 9: Template literal heavy (0-5 points)
-    const templateCount = (body.match(/`[^`]*\$\{/g) || []).length;
-    if (templateCount >= 4) {
-      score += 5;
-      reasons.push('Heavy template literal usage');
-    }
-
-    // Cap at 100
-    score = Math.min(100, score);
-
-    return { score, reasons };
-  }
-
-  _detectFunction(lines, lineIndex) {
-    const line = lines[lineIndex].trim();
-
-    let match = line.match(/^(?:export\s+)?(?:async\s+)?function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/);
-    if (match) return { name: match[1] };
-
-    match = line.match(/^(?:export\s+)?(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(?:async\s+)?(?:function|\()/);
-    if (match && (line.includes('=>') || line.includes('function'))) return { name: match[1] };
-
-    return null;
-  }
-
-  _findFunctionEnd(lines, startLine) {
-    let depth = 0;
-    let started = false;
-
-    for (let i = startLine; i < lines.length && i < startLine + 300; i++) {
-      for (const ch of lines[i]) {
-        if (ch === '{') { depth++; started = true; }
-        if (ch === '}') depth--;
-      }
-      if (started && depth <= 0) return i;
-    }
-
-    return Math.min(startLine + 20, lines.length - 1);
-  }
-
-  _hasTests(funcName, filePath) {
-    // Check if a test file exists for this file
-    const testVariants = [
-      filePath.replace(/\.(js|ts)$/, '.test.$1'),
-      filePath.replace(/\.(js|ts)$/, '.spec.$1'),
-      filePath.replace(/src\//, 'test/'),
-      filePath.replace(/src\//, '__tests__/'),
-    ];
-    return testVariants.some(t => {
-      try { return fs.existsSync(path.resolve(this.rootPath, t)); } catch (e) { return false; }
-    });
-  }
-
-  _isSkippable(relPath) {
-    const skip = [
-      /\.test\./i, /\.spec\./i, /test[\/\\]/i, /spec[\/\\]/i,
-      /__test__/i, /__mocks__/i, /\.config\./i, /\.d\.ts$/,
-      /node_modules/i, /\.min\./i,
-    ];
-    return skip.some(r => r.test(relPath));
-  }
-}
-
-module.exports = AIConfidenceScorer;

package/packages/scanner/alert-manager.js

@@ -1,398 +0,0 @@
-/**
- * Alert Manager
- *
- * @purpose Event-driven AlertManager component
- * @module sentinel
- * @layer application
- * @imports-from fs, path, events
- * @exports-to sentinel
- * @side-effects File system writes, File system reads, Console output, Event emission
- * @critical-for sentinel
- */
-
-/**
- * Sentinel Alert Manager
- *
- * Handles alerting and reporting for the Sentinel system.
- * Outputs: Console, files, and future integrations (Slack, email, GitHub issues)
- */
-
-const fs = require('fs');
-const path = require('path');
-const EventEmitter = require('events');
-
-class AlertManager extends EventEmitter {
-  constructor(config = {}) {
-    super();
-
-    this.config = {
-      rootPath: config.rootPath || process.cwd(),
-      alertsDir: config.alertsDir || path.join(config.rootPath || process.cwd(), 'sentinel', 'alerts'),
-      reportsDir: config.reportsDir || path.join(config.rootPath || process.cwd(), 'sentinel', 'reports'),
-      consoleOutput: config.consoleOutput !== false,
-      fileOutput: config.fileOutput !== false,
-      maxAlertsPerFile: config.maxAlertsPerFile || 1000,
-      slackWebhook: config.slackWebhook || null,
-      emailConfig: config.emailConfig || null,
-      ...config
-    };
-
-    // Ensure directories exist
-    this._ensureDirectories();
-
-    // Alert history for deduplication
-    this.recentAlerts = new Map();
-    this.alertDedupeWindowMs = config.alertDedupeWindowMs || 60000; // 1 minute
-  }
-
-  /**
-   * Send an alert
-   */
-  async sendAlert(alert) {
-    const normalizedAlert = this._normalizeAlert(alert);
-
-    // Check for duplicate
-    if (this._isDuplicate(normalizedAlert)) {
-      return { sent: false, reason: 'duplicate' };
-    }
-
-    // Record alert
-    this._recordAlert(normalizedAlert);
-
-    // Output to configured channels
-    const results = {
-      console: false,
-      file: false,
-      slack: false,
-      email: false
-    };
-
-    // Console output
-    if (this.config.consoleOutput) {
-      results.console = this._outputToConsole(normalizedAlert);
-    }
-
-    // File output
-    if (this.config.fileOutput) {
-      results.file = await this._outputToFile(normalizedAlert);
-    }
-
-    // Slack output (if configured and critical/error)
-    if (this.config.slackWebhook && ['critical', 'error'].includes(normalizedAlert.level)) {
-      results.slack = await this._outputToSlack(normalizedAlert);
-    }
-
-    this.emit('alertSent', { alert: normalizedAlert, results });
-
-    return { sent: true, alert: normalizedAlert, results };
-  }
-
-  /**
-   * Send daily digest
-   */
-  async sendDigest(digest) {
-    console.log('\n' + '='.repeat(60));
-    console.log('[SENTINEL] DAILY DIGEST - ' + digest.date);
-    console.log('='.repeat(60));
-
-    console.log(`\nSummary:`);
-    console.log(`  Issues Found: ${digest.summary.issuesFound}`);
-    console.log(`  Critical: ${digest.summary.criticalIssues}`);
-    console.log(`  Warnings: ${digest.summary.warningIssues}`);
-    console.log(`  Files Watched: ${digest.summary.filesWatched}`);
-    console.log(`  Last Scan: ${digest.summary.lastScan || 'N/A'}`);
-
-    if (digest.topIssues && digest.topIssues.length > 0) {
-      console.log(`\nTop Issues:`);
-      for (const issue of digest.topIssues.slice(0, 5)) {
-        console.log(`  [${issue.severity.toUpperCase()}] ${issue.message}`);
-        if (issue.file) {
-          console.log(`    File: ${path.relative(this.config.rootPath, issue.file)}`);
-        }
-      }
-    }
-
-    if (digest.recommendations && digest.recommendations.length > 0) {
-      console.log(`\nRecommendations:`);
-      for (const rec of digest.recommendations) {
-        console.log(`  [${rec.priority.toUpperCase()}] ${rec.message}`);
-      }
-    }
-
-    console.log('\n' + '='.repeat(60) + '\n');
-
-    // Save digest to file
-    if (this.config.fileOutput) {
-      const digestPath = path.join(
-        this.config.reportsDir,
-        `digest-${digest.date}.json`
-      );
-      fs.writeFileSync(digestPath, JSON.stringify(digest, null, 2));
-    }
-
-    this.emit('digestSent', digest);
-    return { sent: true };
-  }
-
-  /**
-   * Send weekly report
-   */
-  async sendWeeklyReport(report) {
-    console.log('\n' + '='.repeat(70));
-    console.log('[SENTINEL] WEEKLY REPORT - Week of ' + report.weekOf);
-    console.log('='.repeat(70));
-
-    console.log(`\nMetrics:`);
-    console.log(`  Total Scans: ${report.summary.totalScans}`);
-    console.log(`  Issues Detected: ${report.summary.issuesDetected}`);
-    console.log(`  Issues Resolved: ${report.summary.issuesResolved}`);
-    console.log(`  Avg Scan Time: ${report.summary.averageScanTime}ms`);
-
-    console.log(`\nCode Quality:`);
-    console.log(`  Score: ${report.codeQuality.score}/100 (${report.codeQuality.grade})`);
-    console.log(`  Complexity: ${report.codeQuality.factors.complexity}`);
-    console.log(`  Maintainability: ${report.codeQuality.factors.maintainability}`);
-    console.log(`  Test Coverage: ${report.codeQuality.factors.testCoverage}%`);
-
-    console.log(`\nTechnical Debt:`);
-    console.log(`  Estimated Hours: ${report.technicalDebt.estimatedHours}`);
-    console.log(`  Refactoring: ${report.technicalDebt.categories.refactoring}h`);
-    console.log(`  Documentation: ${report.technicalDebt.categories.documentation}h`);
-    console.log(`  Testing: ${report.technicalDebt.categories.testing}h`);
-
-    if (report.recommendations && report.recommendations.length > 0) {
-      console.log(`\nRecommendations:`);
-      for (const rec of report.recommendations) {
-        console.log(`  [${rec.priority.toUpperCase()}] ${rec.message}`);
-      }
-    }
-
-    console.log('\n' + '='.repeat(70) + '\n');
-
-    // Save report to file
-    if (this.config.fileOutput) {
-      const reportPath = path.join(
-        this.config.reportsDir,
-        `weekly-report-${report.weekOf}.json`
-      );
-      fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
-    }
-
-    this.emit('weeklyReportSent', report);
-    return { sent: true };
-  }
-
-  /**
-   * Get alert history
-   */
-  getAlertHistory(options = {}) {
-    const { days = 7, level = null, category = null } = options;
-
-    const cutoff = new Date();
-    cutoff.setDate(cutoff.getDate() - days);
-
-    // Read from alert files
-    const alerts = [];
-
-    try {
-      if (fs.existsSync(this.config.alertsDir)) {
-        const files = fs.readdirSync(this.config.alertsDir)
-          .filter(f => f.startsWith('alerts-') && f.endsWith('.json'))
-          .sort()
-          .reverse();
-
-        for (const file of files) {
-          const fileDate = file.match(/alerts-(\d{4}-\d{2}-\d{2})/);
-          if (fileDate && new Date(fileDate[1]) < cutoff) {
-            break;
-          }
-
-          try {
-            const content = JSON.parse(fs.readFileSync(
-              path.join(this.config.alertsDir, file),
-              'utf8'
-            ));
-            alerts.push(...(content.alerts || []));
-          } catch (e) {
-            // Skip corrupted files
-          }
-        }
-      }
-    } catch (error) {
-      console.error('[ALERT-MANAGER] Error reading alert history:', error.message);
-    }
-
-    // Filter
-    let filtered = alerts;
-    if (level) {
-      filtered = filtered.filter(a => a.level === level);
-    }
-    if (category) {
-      filtered = filtered.filter(a => a.category === category);
-    }
-
-    return filtered;
-  }
-
-  /**
-   * Clear old alerts
-   */
-  async clearOldAlerts(daysToKeep = 30) {
-    const cutoff = new Date();
-    cutoff.setDate(cutoff.getDate() - daysToKeep);
-
-    let deletedCount = 0;
-
-    try {
-      if (fs.existsSync(this.config.alertsDir)) {
-        const files = fs.readdirSync(this.config.alertsDir);
-
-        for (const file of files) {
-          const fileDate = file.match(/(\d{4}-\d{2}-\d{2})/);
-          if (fileDate && new Date(fileDate[1]) < cutoff) {
-            fs.unlinkSync(path.join(this.config.alertsDir, file));
-            deletedCount++;
-          }
-        }
-      }
-    } catch (error) {
-      console.error('[ALERT-MANAGER] Error clearing old alerts:', error.message);
-    }
-
-    return { deleted: deletedCount };
-  }
-
-  // Private methods
-
-  _ensureDirectories() {
-    try {
-      if (!fs.existsSync(this.config.alertsDir)) {
-        fs.mkdirSync(this.config.alertsDir, { recursive: true });
-      }
-      if (!fs.existsSync(this.config.reportsDir)) {
-        fs.mkdirSync(this.config.reportsDir, { recursive: true });
-      }
-    } catch (error) {
-      console.warn('[ALERT-MANAGER] Could not create directories:', error.message);
-    }
-  }
-
-  _normalizeAlert(alert) {
-    return {
-      id: alert.id || this._generateAlertId(),
-      timestamp: alert.timestamp || new Date().toISOString(),
-      level: alert.level || 'info',
-      category: alert.category || 'general',
-      title: alert.title || 'Alert',
-      message: alert.message || '',
-      file: alert.file || null,
-      line: alert.line || null,
-      details: alert.details || {}
-    };
-  }
-
-  _generateAlertId() {
-    return `alert-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-  }
-
-  _isDuplicate(alert) {
-    const key = `${alert.level}:${alert.message}:${alert.file}`;
-    const lastSeen = this.recentAlerts.get(key);
-
-    if (lastSeen && (Date.now() - lastSeen) < this.alertDedupeWindowMs) {
-      return true;
-    }
-
-    return false;
-  }
-
-  _recordAlert(alert) {
-    const key = `${alert.level}:${alert.message}:${alert.file}`;
-    this.recentAlerts.set(key, Date.now());
-
-    // Cleanup old entries
-    const cutoff = Date.now() - this.alertDedupeWindowMs;
-    for (const [k, v] of this.recentAlerts) {
-      if (v < cutoff) {
-        this.recentAlerts.delete(k);
-      }
-    }
-  }
-
-  _outputToConsole(alert) {
-    const levelColors = {
-      critical: '\x1b[31m', // Red
-      error: '\x1b[31m',    // Red
-      warning: '\x1b[33m',  // Yellow
-      info: '\x1b[36m'      // Cyan
-    };
-
-    const reset = '\x1b[0m';
-    const color = levelColors[alert.level] || '';
-
-    console.log(`${color}[SENTINEL:${alert.level.toUpperCase()}]${reset} ${alert.title}`);
-    console.log(`  ${alert.message}`);
-
-    if (alert.file) {
-      const relPath = path.relative(this.config.rootPath, alert.file);
-      console.log(`  File: ${relPath}${alert.line ? ':' + alert.line : ''}`);
-    }
-
-    return true;
-  }
-
-  async _outputToFile(alert) {
-    try {
-      const dateStr = new Date().toISOString().split('T')[0];
-      const filePath = path.join(this.config.alertsDir, `alerts-${dateStr}.json`);
-
-      let fileData = { date: dateStr, alerts: [] };
-
-      if (fs.existsSync(filePath)) {
-        try {
-          fileData = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-        } catch (e) {
-          // File corrupted, start fresh
-        }
-      }
-
-      fileData.alerts.push(alert);
-
-      // Limit alerts per file
-      if (fileData.alerts.length > this.config.maxAlertsPerFile) {
-        fileData.alerts = fileData.alerts.slice(-this.config.maxAlertsPerFile);
-      }
-
-      fs.writeFileSync(filePath, JSON.stringify(fileData, null, 2));
-      return true;
-    } catch (error) {
-      console.error('[ALERT-MANAGER] File output failed:', error.message);
-      return false;
-    }
-  }
-
-  async _outputToSlack(alert) {
-    if (!this.config.slackWebhook) {
-      return false;
-    }
-
-    try {
-      // Would use fetch or axios here
-      // For now, just log that we would send to Slack
-      console.log(`[ALERT-MANAGER] Would send to Slack: ${alert.title}`);
-      return true;
-    } catch (error) {
-      console.error('[ALERT-MANAGER] Slack output failed:', error.message);
-      return false;
-    }
-  }
-
-  async _createGitHubIssue(alert) {
-    // Future: Create GitHub issues for critical alerts
-    // Would use GitHub API or gh CLI
-    console.log(`[ALERT-MANAGER] Would create GitHub issue: ${alert.title}`);
-    return false;
-  }
-}
-
-module.exports = AlertManager;