@vibecheckai/cli 3.5.0 → 3.5.2

package/bin/runners/lib/intelligence/cross-repo-intelligence.js

@@ -1,817 +0,0 @@
-/**
- * Cross-Repository Intelligence Engine
- * 
- * ═══════════════════════════════════════════════════════════════════════════════
- * COMPETITIVE MOAT FEATURE - Ecosystem-Wide Learning
- * ═══════════════════════════════════════════════════════════════════════════════
- * 
- * This engine aggregates anonymized patterns and learnings across all Vibecheck
- * users to provide smarter, more accurate detection. Think of it as a 
- * "collective intelligence" for code quality.
- * 
- * Features:
- * - Anonymized pattern sharing (opt-in)
- * - Framework-specific best practices learned from real codebases
- * - Common vulnerability patterns across the ecosystem
- * - False positive patterns that should be auto-dismissed
- * - Trending issues (new CVEs, emerging anti-patterns)
- * - Technology stack fingerprinting for tailored rules
- * 
- * Privacy:
- * - All data is anonymized (hashed patterns, no code snippets)
- * - Opt-in only
- * - Local-first (works offline with periodic sync)
- */
-
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const crypto = require("crypto");
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// INTELLIGENCE DATABASE SCHEMA
-// ═══════════════════════════════════════════════════════════════════════════════
-
-const DEFAULT_INTELLIGENCE_DB = {
-  version: "1.0.0",
-  lastSync: null,
-  
-  // Patterns learned from ecosystem
-  patterns: {
-    // Pattern hash -> { frequency, confidence, frameworks, example }
-  },
-  
-  // Framework-specific intelligence
-  frameworks: {
-    // Framework name -> { patterns, bestPractices, commonIssues }
-  },
-  
-  // Common false positives across ecosystem
-  falsePositives: {
-    // Pattern hash -> { dismissalRate, contexts }
-  },
-  
-  // Trending issues
-  trending: {
-    // Issue type -> { count, growth, severity, firstSeen }
-  },
-  
-  // Technology recommendations
-  recommendations: {
-    // Stack fingerprint -> [recommendations]
-  },
-  
-  // Benchmark data
-  benchmarks: {
-    // Metric -> { p50, p75, p90, p99 }
-  }
-};
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// STACK FINGERPRINTER
-// ═══════════════════════════════════════════════════════════════════════════════
-
-class StackFingerprinter {
-  constructor(projectRoot) {
-    this.projectRoot = projectRoot;
-  }
-
-  /**
-   * Analyze project to determine technology stack
-   */
-  async fingerprint() {
-    const fingerprint = {
-      language: null,
-      framework: null,
-      ui: null,
-      database: null,
-      authentication: null,
-      testing: null,
-      deployment: null,
-      packages: [],
-      patterns: []
-    };
-
-    // Read package.json for Node projects
-    const packageJson = this.readPackageJson();
-    if (packageJson) {
-      fingerprint.language = "javascript";
-      this.analyzePackageJson(packageJson, fingerprint);
-    }
-
-    // Check for other languages
-    if (!fingerprint.language) {
-      fingerprint.language = this.detectLanguage();
-    }
-
-    // Detect patterns from file structure
-    this.analyzeFileStructure(fingerprint);
-
-    // Calculate fingerprint hash
-    fingerprint.hash = this.calculateHash(fingerprint);
-
-    return fingerprint;
-  }
-
-  readPackageJson() {
-    const packagePath = path.join(this.projectRoot, "package.json");
-    if (fs.existsSync(packagePath)) {
-      try {
-        return JSON.parse(fs.readFileSync(packagePath, "utf8"));
-      } catch {
-        return null;
-      }
-    }
-    return null;
-  }
-
-  analyzePackageJson(pkg, fingerprint) {
-    const deps = { 
-      ...pkg.dependencies, 
-      ...pkg.devDependencies 
-    };
-
-    // Framework detection
-    if (deps.next) {
-      fingerprint.framework = "nextjs";
-      fingerprint.ui = "react";
-    } else if (deps.nuxt) {
-      fingerprint.framework = "nuxt";
-      fingerprint.ui = "vue";
-    } else if (deps.react) {
-      fingerprint.framework = deps["react-router"] ? "react-router" : "react";
-      fingerprint.ui = "react";
-    } else if (deps.vue) {
-      fingerprint.framework = deps["vue-router"] ? "vue-router" : "vue";
-      fingerprint.ui = "vue";
-    } else if (deps.angular) {
-      fingerprint.framework = "angular";
-      fingerprint.ui = "angular";
-    } else if (deps.express) {
-      fingerprint.framework = "express";
-    } else if (deps.fastify) {
-      fingerprint.framework = "fastify";
-    } else if (deps.hono) {
-      fingerprint.framework = "hono";
-    }
-
-    // Database detection
-    if (deps.prisma || deps["@prisma/client"]) {
-      fingerprint.database = "prisma";
-    } else if (deps.mongoose) {
-      fingerprint.database = "mongodb";
-    } else if (deps.pg || deps.postgres) {
-      fingerprint.database = "postgresql";
-    } else if (deps.mysql || deps.mysql2) {
-      fingerprint.database = "mysql";
-    } else if (deps.drizzle || deps["drizzle-orm"]) {
-      fingerprint.database = "drizzle";
-    }
-
-    // Auth detection
-    if (deps["next-auth"] || deps["@auth/core"]) {
-      fingerprint.authentication = "next-auth";
-    } else if (deps.passport) {
-      fingerprint.authentication = "passport";
-    } else if (deps["@clerk/nextjs"]) {
-      fingerprint.authentication = "clerk";
-    } else if (deps["@supabase/supabase-js"]) {
-      fingerprint.authentication = "supabase";
-    } else if (deps.firebase) {
-      fingerprint.authentication = "firebase";
-    }
-
-    // Testing detection
-    if (deps.jest) {
-      fingerprint.testing = "jest";
-    } else if (deps.vitest) {
-      fingerprint.testing = "vitest";
-    } else if (deps.playwright) {
-      fingerprint.testing = "playwright";
-    } else if (deps.cypress) {
-      fingerprint.testing = "cypress";
-    }
-
-    // Store top packages for pattern matching
-    fingerprint.packages = Object.keys(deps)
-      .filter(d => !d.startsWith("@types/"))
-      .slice(0, 50);
-  }
-
-  detectLanguage() {
-    const indicators = {
-      "requirements.txt": "python",
-      "pyproject.toml": "python",
-      "Cargo.toml": "rust",
-      "go.mod": "go",
-      "pom.xml": "java",
-      "build.gradle": "java",
-      "Gemfile": "ruby",
-      "composer.json": "php"
-    };
-
-    for (const [file, lang] of Object.entries(indicators)) {
-      if (fs.existsSync(path.join(this.projectRoot, file))) {
-        return lang;
-      }
-    }
-
-    return "unknown";
-  }
-
-  analyzeFileStructure(fingerprint) {
-    const patterns = [];
-
-    // Check for common patterns
-    const checks = [
-      { path: "app", pattern: "app-directory" },
-      { path: "pages", pattern: "pages-router" },
-      { path: "src/components", pattern: "component-structure" },
-      { path: "lib", pattern: "lib-utils" },
-      { path: "utils", pattern: "utils-folder" },
-      { path: "hooks", pattern: "custom-hooks" },
-      { path: "services", pattern: "service-layer" },
-      { path: "api", pattern: "api-layer" },
-      { path: ".github/workflows", pattern: "github-actions" },
-      { path: "docker-compose.yml", pattern: "docker" },
-      { path: "kubernetes", pattern: "kubernetes" },
-      { path: "terraform", pattern: "terraform" }
-    ];
-
-    for (const check of checks) {
-      if (fs.existsSync(path.join(this.projectRoot, check.path))) {
-        patterns.push(check.pattern);
-      }
-    }
-
-    fingerprint.patterns = patterns;
-  }
-
-  calculateHash(fingerprint) {
-    const normalized = JSON.stringify({
-      language: fingerprint.language,
-      framework: fingerprint.framework,
-      database: fingerprint.database,
-      patterns: fingerprint.patterns.sort()
-    });
-    
-    return crypto.createHash("sha256").update(normalized).digest("hex").slice(0, 16);
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// CROSS-REPO INTELLIGENCE ENGINE
-// ═══════════════════════════════════════════════════════════════════════════════
-
-class CrossRepoIntelligence {
-  constructor(options = {}) {
-    this.projectRoot = options.projectRoot || process.cwd();
-    this.dbPath = options.dbPath || 
-      path.join(this.projectRoot, ".vibecheck", "intelligence", "cross-repo.json");
-    this.globalDbPath = options.globalDbPath ||
-      path.join(process.env.HOME || process.env.USERPROFILE, ".vibecheck", "global-intelligence.json");
-    this.syncEndpoint = options.syncEndpoint || "https://api.vibecheck.dev/intelligence";
-    this.optedIn = options.optedIn || false;
-    
-    this.db = this.loadDatabase();
-    this.fingerprinter = new StackFingerprinter(this.projectRoot);
-  }
-
-  /**
-   * Load or initialize the intelligence database
-   */
-  loadDatabase() {
-    // Try project-local DB first
-    if (fs.existsSync(this.dbPath)) {
-      try {
-        return JSON.parse(fs.readFileSync(this.dbPath, "utf8"));
-      } catch {
-        // Fall through to default
-      }
-    }
-
-    // Try global DB
-    if (fs.existsSync(this.globalDbPath)) {
-      try {
-        return JSON.parse(fs.readFileSync(this.globalDbPath, "utf8"));
-      } catch {
-        // Fall through to default
-      }
-    }
-
-    return { ...DEFAULT_INTELLIGENCE_DB };
-  }
-
-  /**
-   * Save the intelligence database
-   */
-  saveDatabase() {
-    try {
-      const dir = path.dirname(this.dbPath);
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-      }
-      
-      fs.writeFileSync(this.dbPath, JSON.stringify(this.db, null, 2), "utf8");
-      
-      // Also save to global
-      const globalDir = path.dirname(this.globalDbPath);
-      if (!fs.existsSync(globalDir)) {
-        fs.mkdirSync(globalDir, { recursive: true });
-      }
-      fs.writeFileSync(this.globalDbPath, JSON.stringify(this.db, null, 2), "utf8");
-    } catch {
-      // Silently fail - intelligence is enhancement not requirement
-    }
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // PATTERN LEARNING
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Learn from a finding
-   */
-  learnFromFinding(finding, outcome) {
-    const patternHash = this.hashPattern(finding);
-    
-    if (!this.db.patterns[patternHash]) {
-      this.db.patterns[patternHash] = {
-        type: finding.type,
-        frequency: 0,
-        fixed: 0,
-        dismissed: 0,
-        confidence: finding.confidence || 0.5,
-        frameworks: [],
-        firstSeen: new Date().toISOString()
-      };
-    }
-
-    const pattern = this.db.patterns[patternHash];
-    pattern.frequency++;
-    pattern.lastSeen = new Date().toISOString();
-
-    switch (outcome) {
-      case "fixed":
-        pattern.fixed++;
-        pattern.confidence = Math.min(1, pattern.confidence + 0.01);
-        break;
-      case "dismissed":
-        pattern.dismissed++;
-        pattern.confidence = Math.max(0, pattern.confidence - 0.02);
-        break;
-    }
-
-    // Track framework association
-    if (finding.framework && !pattern.frameworks.includes(finding.framework)) {
-      pattern.frameworks.push(finding.framework);
-    }
-
-    this.saveDatabase();
-  }
-
-  /**
-   * Learn from multiple findings in a scan
-   */
-  learnFromScan(findings, fingerprint) {
-    // Update framework intelligence
-    if (fingerprint.framework) {
-      if (!this.db.frameworks[fingerprint.framework]) {
-        this.db.frameworks[fingerprint.framework] = {
-          scans: 0,
-          commonIssues: {},
-          bestPractices: [],
-          avgFindingsPerScan: 0
-        };
-      }
-
-      const fwData = this.db.frameworks[fingerprint.framework];
-      fwData.scans++;
-      
-      // Track common issues for this framework
-      for (const finding of findings) {
-        const issueType = finding.type;
-        if (!fwData.commonIssues[issueType]) {
-          fwData.commonIssues[issueType] = { count: 0, severity: finding.severity };
-        }
-        fwData.commonIssues[issueType].count++;
-      }
-
-      // Update average findings
-      fwData.avgFindingsPerScan = 
-        (fwData.avgFindingsPerScan * (fwData.scans - 1) + findings.length) / fwData.scans;
-    }
-
-    // Update trending issues
-    for (const finding of findings) {
-      const issueType = finding.type;
-      if (!this.db.trending[issueType]) {
-        this.db.trending[issueType] = {
-          count: 0,
-          severity: finding.severity,
-          firstSeen: new Date().toISOString(),
-          lastSeen: new Date().toISOString()
-        };
-      }
-      this.db.trending[issueType].count++;
-      this.db.trending[issueType].lastSeen = new Date().toISOString();
-    }
-
-    // Update benchmarks
-    this.updateBenchmarks(findings, fingerprint);
-
-    this.saveDatabase();
-  }
-
-  /**
-   * Track false positive patterns
-   */
-  learnFalsePositive(finding, context) {
-    const patternHash = this.hashPattern(finding);
-    
-    if (!this.db.falsePositives[patternHash]) {
-      this.db.falsePositives[patternHash] = {
-        type: finding.type,
-        dismissals: 0,
-        contexts: [],
-        confidence: 0
-      };
-    }
-
-    const fp = this.db.falsePositives[patternHash];
-    fp.dismissals++;
-    
-    // Track context where this is dismissed
-    if (context && !fp.contexts.includes(context)) {
-      fp.contexts.push(context);
-    }
-
-    // Calculate false positive confidence
-    const pattern = this.db.patterns[patternHash];
-    if (pattern && pattern.frequency > 0) {
-      fp.confidence = fp.dismissals / pattern.frequency;
-    }
-
-    this.saveDatabase();
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // RECOMMENDATIONS
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Get recommendations based on stack fingerprint
-   */
-  async getRecommendations() {
-    const fingerprint = await this.fingerprinter.fingerprint();
-    const recommendations = [];
-
-    // Framework-specific recommendations
-    if (fingerprint.framework && this.db.frameworks[fingerprint.framework]) {
-      const fwData = this.db.frameworks[fingerprint.framework];
-      
-      // Warn about common issues for this framework
-      const sortedIssues = Object.entries(fwData.commonIssues)
-        .sort((a, b) => b[1].count - a[1].count)
-        .slice(0, 5);
-
-      for (const [issueType, data] of sortedIssues) {
-        recommendations.push({
-          type: "framework_common_issue",
-          priority: data.severity === "BLOCK" ? "high" : "medium",
-          message: `${issueType} is commonly found in ${fingerprint.framework} projects`,
-          action: `Consider adding specific rules to catch ${issueType}`
-        });
-      }
-    }
-
-    // Check for missing best practices based on stack
-    const missingPractices = this.checkMissingPractices(fingerprint);
-    for (const practice of missingPractices) {
-      recommendations.push({
-        type: "missing_best_practice",
-        priority: "medium",
-        message: practice.message,
-        action: practice.action
-      });
-    }
-
-    // Trending issue warnings
-    const trending = this.getTrendingIssues(5);
-    for (const issue of trending) {
-      recommendations.push({
-        type: "trending_issue",
-        priority: issue.severity === "BLOCK" ? "high" : "low",
-        message: `${issue.type} is trending (${issue.count} occurrences)`,
-        action: `Review code for ${issue.type} patterns`
-      });
-    }
-
-    // Benchmark comparison
-    const benchmarkRecs = this.compareToBenchmarks(fingerprint);
-    recommendations.push(...benchmarkRecs);
-
-    return {
-      fingerprint,
-      recommendations: recommendations.sort((a, b) => {
-        const priority = { high: 0, medium: 1, low: 2 };
-        return priority[a.priority] - priority[b.priority];
-      })
-    };
-  }
-
-  /**
-   * Check for missing best practices
-   */
-  checkMissingPractices(fingerprint) {
-    const practices = [];
-
-    // Check for common missing patterns
-    if (fingerprint.framework === "nextjs" && !fingerprint.patterns.includes("app-directory")) {
-      practices.push({
-        message: "Consider migrating to App Directory for better performance",
-        action: "Review Next.js 13+ App Router documentation"
-      });
-    }
-
-    if (!fingerprint.testing) {
-      practices.push({
-        message: "No testing framework detected",
-        action: "Add testing with Vitest or Jest"
-      });
-    }
-
-    if (!fingerprint.patterns.includes("github-actions") && 
-        !fingerprint.patterns.includes("docker")) {
-      practices.push({
-        message: "No CI/CD configuration detected",
-        action: "Set up GitHub Actions or similar CI/CD"
-      });
-    }
-
-    return practices;
-  }
-
-  /**
-   * Get trending issues
-   */
-  getTrendingIssues(limit = 10) {
-    return Object.entries(this.db.trending)
-      .map(([type, data]) => ({ type, ...data }))
-      .sort((a, b) => b.count - a.count)
-      .slice(0, limit);
-  }
-
-  /**
-   * Compare to ecosystem benchmarks
-   */
-  compareToBenchmarks(fingerprint) {
-    const recommendations = [];
-    
-    if (!this.db.benchmarks.findingsPerScan) return recommendations;
-
-    const fwData = this.db.frameworks[fingerprint.framework];
-    if (fwData && this.db.benchmarks.findingsPerScan) {
-      const benchmark = this.db.benchmarks.findingsPerScan;
-      
-      if (fwData.avgFindingsPerScan > benchmark.p75) {
-        recommendations.push({
-          type: "above_benchmark",
-          priority: "medium",
-          message: `Your project has more issues than 75% of similar projects`,
-          action: "Focus on reducing findings to improve code quality"
-        });
-      } else if (fwData.avgFindingsPerScan < benchmark.p25) {
-        recommendations.push({
-          type: "below_benchmark",
-          priority: "low",
-          message: `Your project has fewer issues than 75% of similar projects`,
-          action: "Great job! Consider adding stricter rules"
-        });
-      }
-    }
-
-    return recommendations;
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // CONFIDENCE ADJUSTMENT
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Get adjusted confidence based on ecosystem data
-   */
-  getAdjustedConfidence(finding, fingerprint) {
-    const patternHash = this.hashPattern(finding);
-    let adjustment = 0;
-
-    // Check false positive history
-    const fpData = this.db.falsePositives[patternHash];
-    if (fpData && fpData.confidence > 0.5) {
-      adjustment -= fpData.confidence * 0.2;
-    }
-
-    // Check pattern data
-    const patternData = this.db.patterns[patternHash];
-    if (patternData && patternData.frequency >= 10) {
-      const fixRate = patternData.fixed / patternData.frequency;
-      adjustment += (fixRate - 0.5) * 0.1;
-    }
-
-    // Framework-specific adjustment
-    if (fingerprint.framework) {
-      const fwData = this.db.frameworks[fingerprint.framework];
-      if (fwData?.commonIssues[finding.type]) {
-        // Common in framework = slightly higher confidence
-        adjustment += 0.05;
-      }
-    }
-
-    const originalConfidence = finding.confidence || 0.5;
-    const adjustedConfidence = Math.max(0, Math.min(1, originalConfidence + adjustment));
-
-    return {
-      original: originalConfidence,
-      adjusted: adjustedConfidence,
-      adjustment,
-      factors: {
-        falsePositiveHistory: fpData?.confidence || 0,
-        ecosystemFixRate: patternData ? patternData.fixed / Math.max(1, patternData.frequency) : 0,
-        frameworkCommon: !!this.db.frameworks[fingerprint.framework]?.commonIssues[finding.type]
-      }
-    };
-  }
-
-  /**
-   * Check if should auto-dismiss based on ecosystem
-   */
-  shouldAutoDismiss(finding) {
-    const patternHash = this.hashPattern(finding);
-    const fpData = this.db.falsePositives[patternHash];
-
-    // Auto-dismiss if ecosystem false positive rate is very high
-    if (fpData && fpData.confidence > 0.8 && fpData.dismissals >= 100) {
-      return {
-        dismiss: true,
-        reason: `Dismissed by ${fpData.confidence * 100}% of users (${fpData.dismissals} times)`,
-        confidence: 1 - fpData.confidence
-      };
-    }
-
-    return { dismiss: false };
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // BENCHMARKS
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Update benchmarks from scan data
-   */
-  updateBenchmarks(findings, fingerprint) {
-    if (!this.db.benchmarks.findingsPerScan) {
-      this.db.benchmarks.findingsPerScan = {
-        samples: [],
-        p25: 0,
-        p50: 0,
-        p75: 0,
-        p90: 0
-      };
-    }
-
-    const benchmark = this.db.benchmarks.findingsPerScan;
-    benchmark.samples.push(findings.length);
-
-    // Keep only last 1000 samples
-    if (benchmark.samples.length > 1000) {
-      benchmark.samples = benchmark.samples.slice(-1000);
-    }
-
-    // Calculate percentiles
-    const sorted = [...benchmark.samples].sort((a, b) => a - b);
-    benchmark.p25 = sorted[Math.floor(sorted.length * 0.25)];
-    benchmark.p50 = sorted[Math.floor(sorted.length * 0.5)];
-    benchmark.p75 = sorted[Math.floor(sorted.length * 0.75)];
-    benchmark.p90 = sorted[Math.floor(sorted.length * 0.9)];
-  }
-
-  /**
-   * Get benchmark data
-   */
-  getBenchmarks() {
-    return {
-      findingsPerScan: this.db.benchmarks.findingsPerScan 
-        ? {
-            p25: this.db.benchmarks.findingsPerScan.p25,
-            p50: this.db.benchmarks.findingsPerScan.p50,
-            p75: this.db.benchmarks.findingsPerScan.p75,
-            p90: this.db.benchmarks.findingsPerScan.p90,
-            sampleSize: this.db.benchmarks.findingsPerScan.samples?.length || 0
-          }
-        : null
-    };
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // SYNC (Placeholder for cloud sync)
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Sync with cloud intelligence (opt-in)
-   */
-  async sync() {
-    if (!this.optedIn) {
-      return { synced: false, reason: "Not opted in" };
-    }
-
-    // This would sync anonymized data with cloud service
-    // For now, just update timestamp
-    this.db.lastSync = new Date().toISOString();
-    this.saveDatabase();
-
-    return { synced: true, timestamp: this.db.lastSync };
-  }
-
-  /**
-   * Export anonymized intelligence for sharing
-   */
-  exportAnonymized() {
-    return {
-      version: this.db.version,
-      patterns: Object.entries(this.db.patterns)
-        .filter(([, data]) => data.frequency >= 5)
-        .map(([hash, data]) => ({
-          hash,
-          type: data.type,
-          frequency: data.frequency,
-          confidence: data.confidence,
-          frameworks: data.frameworks
-        })),
-      falsePositives: Object.entries(this.db.falsePositives)
-        .filter(([, data]) => data.dismissals >= 10)
-        .map(([hash, data]) => ({
-          hash,
-          type: data.type,
-          confidence: data.confidence
-        })),
-      trending: Object.entries(this.db.trending)
-        .slice(0, 20)
-        .map(([type, data]) => ({
-          type,
-          count: data.count,
-          severity: data.severity
-        })),
-      benchmarks: this.getBenchmarks()
-    };
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // UTILITIES
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Hash a finding pattern
-   */
-  hashPattern(finding) {
-    const normalized = JSON.stringify({
-      type: finding.type,
-      message: finding.message?.replace(/[0-9]+/g, "N").slice(0, 100),
-      severity: finding.severity
-    });
-    
-    return crypto.createHash("sha256").update(normalized).digest("hex").slice(0, 16);
-  }
-
-  /**
-   * Get intelligence summary
-   */
-  getSummary() {
-    return {
-      patternsTracked: Object.keys(this.db.patterns).length,
-      falsePositivesTracked: Object.keys(this.db.falsePositives).length,
-      frameworksTracked: Object.keys(this.db.frameworks).length,
-      trendingIssues: Object.keys(this.db.trending).length,
-      lastSync: this.db.lastSync,
-      optedIn: this.optedIn
-    };
-  }
-
-  /**
-   * Reset intelligence data
-   */
-  reset() {
-    this.db = { ...DEFAULT_INTELLIGENCE_DB };
-    this.saveDatabase();
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// EXPORTS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-module.exports = {
-  CrossRepoIntelligence,
-  StackFingerprinter,
-  DEFAULT_INTELLIGENCE_DB
-};