@vibecheckai/cli 3.5.0 → 3.5.2

package/bin/runners/lib/review/ai-code-review.js

@@ -1,832 +0,0 @@
-/**
- * AI Code Review Agent
- * 
- * ═══════════════════════════════════════════════════════════════════════════════
- * COMPETITIVE MOAT FEATURE - Intelligent Automated Code Review
- * ═══════════════════════════════════════════════════════════════════════════════
- * 
- * This engine provides automated code review capabilities that go beyond linting.
- * It understands context, business logic, and provides actionable suggestions.
- * 
- * Review Categories:
- * - Security vulnerabilities (injection, XSS, auth issues)
- * - Performance anti-patterns (N+1 queries, memory leaks)
- * - Code quality (complexity, maintainability)
- * - Best practices (framework-specific patterns)
- * - Business logic issues (state management, race conditions)
- * - Test coverage gaps
- * - Documentation needs
- * 
- * Features:
- * - Context-aware review (understands the full PR)
- * - Suggested fixes with confidence levels
- * - PR comment generation
- * - Learning from feedback
- * - Custom review rules
- */
-
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const crypto = require("crypto");
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// REVIEW CATEGORIES AND RULES
-// ═══════════════════════════════════════════════════════════════════════════════
-
-const REVIEW_CATEGORIES = {
-  security: {
-    name: "Security",
-    icon: "🔒",
-    rules: [
-      {
-        id: "sql-injection",
-        name: "SQL Injection Risk",
-        severity: "critical",
-        pattern: /(\$\{.*\}|`.*\$\{.*\}`)\s*(?:SELECT|INSERT|UPDATE|DELETE|FROM|WHERE)/i,
-        message: "Potential SQL injection vulnerability. Use parameterized queries.",
-        fix: "Use prepared statements or an ORM with parameterized queries"
-      },
-      {
-        id: "xss-risk",
-        name: "Cross-Site Scripting Risk",
-        severity: "critical",
-        pattern: /innerHTML\s*=|dangerouslySetInnerHTML|v-html/,
-        message: "Potential XSS vulnerability. Avoid direct HTML injection.",
-        fix: "Sanitize input or use safe rendering methods"
-      },
-      {
-        id: "hardcoded-secret",
-        name: "Hardcoded Secret",
-        severity: "critical",
-        pattern: /(api[_-]?key|secret|password|token)\s*[:=]\s*['"][^'"]{8,}['"]/i,
-        message: "Possible hardcoded secret detected.",
-        fix: "Move secrets to environment variables"
-      },
-      {
-        id: "eval-usage",
-        name: "Dangerous eval() Usage",
-        severity: "high",
-        pattern: /\beval\s*\(|new\s+Function\s*\(/,
-        message: "eval() and Function constructor can execute arbitrary code.",
-        fix: "Avoid eval() - use safer alternatives like JSON.parse()"
-      },
-      {
-        id: "crypto-weak",
-        name: "Weak Cryptography",
-        severity: "high",
-        pattern: /createHash\(['"]md5['"]\)|createHash\(['"]sha1['"]\)/,
-        message: "MD5 and SHA1 are cryptographically weak.",
-        fix: "Use SHA-256 or stronger hash algorithms"
-      }
-    ]
-  },
-
-  performance: {
-    name: "Performance",
-    icon: "⚡",
-    rules: [
-      {
-        id: "n-plus-one",
-        name: "Potential N+1 Query",
-        severity: "high",
-        pattern: /for\s*\([^)]*\)\s*\{[^}]*await[^}]*(?:findOne|findById|query|fetch)/,
-        message: "Possible N+1 query pattern. Consider batch loading.",
-        fix: "Use batch queries or eager loading"
-      },
-      {
-        id: "sync-fs",
-        name: "Synchronous File Operation",
-        severity: "medium",
-        pattern: /fs\.(readFileSync|writeFileSync|appendFileSync|existsSync)/,
-        message: "Synchronous file operations block the event loop.",
-        fix: "Use async versions: fs.promises.readFile, etc."
-      },
-      {
-        id: "missing-memo",
-        name: "Missing React.memo",
-        severity: "low",
-        pattern: /export\s+(?:default\s+)?function\s+\w+.*\(\s*\{\s*\w+/,
-        context: /\.tsx?$/,
-        message: "Component receiving props might benefit from React.memo.",
-        fix: "Wrap with React.memo() if re-renders are expensive"
-      },
-      {
-        id: "large-bundle-import",
-        name: "Large Bundle Import",
-        severity: "medium",
-        pattern: /import\s+(?:\*\s+as\s+\w+|{\s*\w+(?:,\s*\w+)*\s*})\s+from\s+['"](?:lodash|moment|date-fns|rxjs)['"]/,
-        message: "Importing from large libraries can bloat bundle size.",
-        fix: "Use tree-shakeable imports: import debounce from 'lodash/debounce'"
-      },
-      {
-        id: "missing-cleanup",
-        name: "Missing useEffect Cleanup",
-        severity: "medium",
-        pattern: /useEffect\(\s*\(\)\s*=>\s*\{[^}]*(?:addEventListener|setInterval|setTimeout|subscribe)[^}]*\}\s*,/,
-        negativePattern: /return\s*\(\s*\)\s*=>/,
-        message: "useEffect with subscriptions should return a cleanup function.",
-        fix: "Add return () => cleanup() to prevent memory leaks"
-      }
-    ]
-  },
-
-  quality: {
-    name: "Code Quality",
-    icon: "✨",
-    rules: [
-      {
-        id: "high-complexity",
-        name: "High Cyclomatic Complexity",
-        severity: "medium",
-        check: (code) => {
-          const branches = (code.match(/if|else|switch|case|\?|&&|\|\||for|while|catch/g) || []).length;
-          return branches > 15;
-        },
-        message: "Function has high cyclomatic complexity.",
-        fix: "Break down into smaller functions"
-      },
-      {
-        id: "long-function",
-        name: "Long Function",
-        severity: "low",
-        check: (code, lines) => lines > 50,
-        message: "Function is longer than 50 lines.",
-        fix: "Extract logic into separate functions"
-      },
-      {
-        id: "magic-numbers",
-        name: "Magic Numbers",
-        severity: "low",
-        pattern: /(?<![a-zA-Z_$])(?:86400|3600|1000|60|24|365|100|1024)\b/,
-        message: "Consider using named constants for magic numbers.",
-        fix: "Extract to named constant: const SECONDS_PER_DAY = 86400"
-      },
-      {
-        id: "console-left",
-        name: "Console Statement",
-        severity: "low",
-        pattern: /console\.(log|warn|error|debug|info)\(/,
-        message: "Console statements should be removed before production.",
-        fix: "Remove or replace with proper logging"
-      },
-      {
-        id: "todo-fixme",
-        name: "TODO/FIXME Comment",
-        severity: "info",
-        pattern: /\/\/\s*(TODO|FIXME|XXX|HACK|BUG):/i,
-        message: "Unresolved TODO/FIXME comment.",
-        fix: "Address the TODO or create a ticket"
-      }
-    ]
-  },
-
-  bestPractices: {
-    name: "Best Practices",
-    icon: "📚",
-    rules: [
-      {
-        id: "any-type",
-        name: "TypeScript 'any' Type",
-        severity: "medium",
-        pattern: /:\s*any\b|as\s+any\b/,
-        context: /\.tsx?$/,
-        message: "Using 'any' type defeats TypeScript's type safety.",
-        fix: "Use proper types or 'unknown' with type guards"
-      },
-      {
-        id: "async-await-consistency",
-        name: "Mixed Async Patterns",
-        severity: "low",
-        pattern: /\.then\s*\([^)]*\).*await|await.*\.then\s*\(/,
-        message: "Mixing .then() and await can be confusing.",
-        fix: "Use consistent async/await pattern"
-      },
-      {
-        id: "empty-catch",
-        name: "Empty Catch Block",
-        severity: "medium",
-        pattern: /catch\s*\([^)]*\)\s*\{\s*\}/,
-        message: "Empty catch blocks swallow errors silently.",
-        fix: "Log the error or rethrow if can't handle"
-      },
-      {
-        id: "var-usage",
-        name: "Using 'var' Declaration",
-        severity: "low",
-        pattern: /\bvar\s+\w+/,
-        message: "Prefer 'const' or 'let' over 'var'.",
-        fix: "Replace var with const (preferred) or let"
-      },
-      {
-        id: "prop-drilling",
-        name: "Excessive Prop Drilling",
-        severity: "low",
-        check: (code) => {
-          const props = code.match(/\{[^}]*\.\.\.[a-z]/gi) || [];
-          return props.length > 3;
-        },
-        message: "Consider using Context or state management for deep prop passing.",
-        fix: "Use React Context, Redux, or Zustand"
-      }
-    ]
-  },
-
-  testing: {
-    name: "Testing",
-    icon: "🧪",
-    rules: [
-      {
-        id: "missing-test",
-        name: "Missing Test File",
-        severity: "info",
-        checkFile: (filePath) => {
-          if (filePath.includes(".test.") || filePath.includes(".spec.")) return false;
-          const testPath = filePath.replace(/\.(ts|tsx|js|jsx)$/, ".test.$1");
-          const specPath = filePath.replace(/\.(ts|tsx|js|jsx)$/, ".spec.$1");
-          return !fs.existsSync(testPath) && !fs.existsSync(specPath);
-        },
-        message: "No corresponding test file found.",
-        fix: "Add unit tests for this file"
-      },
-      {
-        id: "test-implementation",
-        name: "Test Implementation Details",
-        severity: "low",
-        pattern: /getByTestId|querySelector|\.className/,
-        context: /\.(test|spec)\./,
-        message: "Testing implementation details can make tests brittle.",
-        fix: "Test behavior, not implementation. Use accessible queries."
-      },
-      {
-        id: "mock-not-restored",
-        name: "Mock Not Restored",
-        severity: "medium",
-        pattern: /jest\.spyOn|jest\.mock|vi\.spyOn|vi\.mock/,
-        negativePattern: /afterEach|afterAll|\.mockRestore\(\)/,
-        context: /\.(test|spec)\./,
-        message: "Mocks should be restored after each test.",
-        fix: "Add jest.restoreAllMocks() in afterEach"
-      }
-    ]
-  },
-
-  documentation: {
-    name: "Documentation",
-    icon: "📝",
-    rules: [
-      {
-        id: "missing-jsdoc",
-        name: "Missing JSDoc",
-        severity: "info",
-        pattern: /export\s+(?:async\s+)?function\s+[A-Z]\w+/,
-        negativePattern: /\/\*\*[\s\S]*?\*\/\s*export/,
-        message: "Exported function missing JSDoc documentation.",
-        fix: "Add JSDoc with @param and @returns"
-      },
-      {
-        id: "outdated-comment",
-        name: "Potentially Outdated Comment",
-        severity: "info",
-        check: (code) => {
-          const hasOldDate = /(?:19|20)\d{2}/.test(code);
-          const hasVersion = /v?\d+\.\d+\.\d+/.test(code);
-          return hasOldDate || hasVersion;
-        },
-        message: "Comment may contain outdated version/date references.",
-        fix: "Verify comment accuracy"
-      }
-    ]
-  }
-};
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// CODE REVIEW ENGINE
-// ═══════════════════════════════════════════════════════════════════════════════
-
-class AICodeReviewEngine {
-  constructor(options = {}) {
-    this.projectRoot = options.projectRoot || process.cwd();
-    this.categories = { ...REVIEW_CATEGORIES, ...options.customCategories };
-    this.ignorePaths = options.ignorePaths || [
-      "**/node_modules/**",
-      "**/dist/**",
-      "**/build/**",
-      "**/*.min.js",
-      "**/coverage/**"
-    ];
-    this.results = [];
-    this.feedback = new Map(); // Store feedback for learning
-  }
-
-  /**
-   * Review a single file
-   */
-  reviewFile(filePath, content = null) {
-    const findings = [];
-    
-    // Read file if content not provided
-    if (content === null) {
-      const fullPath = path.isAbsolute(filePath) 
-        ? filePath 
-        : path.join(this.projectRoot, filePath);
-      
-      if (!fs.existsSync(fullPath)) {
-        return { file: filePath, findings: [], error: "File not found" };
-      }
-      
-      content = fs.readFileSync(fullPath, "utf8");
-    }
-
-    const lines = content.split("\n");
-
-    // Apply each category's rules
-    for (const [categoryId, category] of Object.entries(this.categories)) {
-      for (const rule of category.rules) {
-        // Check file context match
-        if (rule.context && !rule.context.test(filePath)) {
-          continue;
-        }
-
-        // Check file-level rules
-        if (rule.checkFile) {
-          if (rule.checkFile(filePath)) {
-            findings.push(this.createFinding(rule, categoryId, filePath, 0, null));
-          }
-          continue;
-        }
-
-        // Check custom function
-        if (rule.check) {
-          if (rule.check(content, lines.length)) {
-            findings.push(this.createFinding(rule, categoryId, filePath, 0, null));
-          }
-          continue;
-        }
-
-        // Check pattern match
-        if (rule.pattern) {
-          const regex = new RegExp(rule.pattern.source, "gm");
-          let match;
-          
-          while ((match = regex.exec(content)) !== null) {
-            // Check negative pattern (should NOT match)
-            if (rule.negativePattern) {
-              const surrounding = content.substring(
-                Math.max(0, match.index - 500),
-                Math.min(content.length, match.index + match[0].length + 500)
-              );
-              if (rule.negativePattern.test(surrounding)) {
-                continue; // Skip - negative pattern found
-              }
-            }
-
-            const line = content.substring(0, match.index).split("\n").length;
-            findings.push(this.createFinding(
-              rule, 
-              categoryId, 
-              filePath, 
-              line, 
-              match[0]
-            ));
-          }
-        }
-      }
-    }
-
-    return {
-      file: filePath,
-      findings,
-      summary: this.summarizeFindings(findings)
-    };
-  }
-
-  /**
-   * Review multiple files (e.g., a PR diff)
-   */
-  reviewFiles(files) {
-    this.results = [];
-    
-    for (const file of files) {
-      // Skip ignored paths
-      if (this.shouldIgnore(file.path || file)) {
-        continue;
-      }
-
-      const result = this.reviewFile(
-        file.path || file,
-        file.content || null
-      );
-      
-      if (result.findings.length > 0) {
-        this.results.push(result);
-      }
-    }
-
-    return {
-      files: this.results,
-      totalFindings: this.results.reduce((sum, r) => sum + r.findings.length, 0),
-      summary: this.generateOverallSummary()
-    };
-  }
-
-  /**
-   * Review a git diff
-   */
-  async reviewDiff(diffContent) {
-    const files = this.parseDiff(diffContent);
-    return this.reviewFiles(files);
-  }
-
-  /**
-   * Parse git diff format
-   */
-  parseDiff(diffContent) {
-    const files = [];
-    const diffRegex = /diff --git a\/(.+?) b\/(.+?)$/gm;
-    const hunkRegex = /@@\s*-\d+,?\d*\s*\+(\d+),?(\d*)\s*@@/g;
-    
-    let match;
-    let lastIndex = 0;
-    const diffs = [];
-    
-    // Find all file diffs
-    while ((match = diffRegex.exec(diffContent)) !== null) {
-      if (diffs.length > 0) {
-        diffs[diffs.length - 1].end = match.index;
-      }
-      diffs.push({
-        path: match[2],
-        start: match.index,
-        end: diffContent.length
-      });
-    }
-
-    // Extract added content for each file
-    for (const diff of diffs) {
-      const diffSection = diffContent.substring(diff.start, diff.end);
-      const addedLines = [];
-      
-      // Get added lines (starting with +)
-      const lines = diffSection.split("\n");
-      for (const line of lines) {
-        if (line.startsWith("+") && !line.startsWith("+++")) {
-          addedLines.push(line.substring(1));
-        }
-      }
-
-      if (addedLines.length > 0) {
-        files.push({
-          path: diff.path,
-          content: addedLines.join("\n"),
-          isPartial: true
-        });
-      }
-    }
-
-    return files;
-  }
-
-  /**
-   * Create a finding object
-   */
-  createFinding(rule, categoryId, filePath, line, match) {
-    const category = this.categories[categoryId];
-    
-    return {
-      id: crypto.randomBytes(4).toString("hex"),
-      ruleId: rule.id,
-      ruleName: rule.name,
-      category: categoryId,
-      categoryName: category.name,
-      categoryIcon: category.icon,
-      severity: rule.severity,
-      file: filePath,
-      line,
-      match: match ? match.substring(0, 100) : null,
-      message: rule.message,
-      fix: rule.fix,
-      confidence: this.calculateConfidence(rule, match)
-    };
-  }
-
-  /**
-   * Calculate confidence based on rule and match
-   */
-  calculateConfidence(rule, match) {
-    let confidence = 0.8; // Base confidence
-
-    // Adjust based on severity
-    if (rule.severity === "critical") confidence += 0.1;
-    if (rule.severity === "info") confidence -= 0.1;
-
-    // Adjust based on previous feedback
-    const feedbackKey = rule.id;
-    const feedback = this.feedback.get(feedbackKey);
-    if (feedback) {
-      confidence += (feedback.accepted - feedback.rejected) * 0.05;
-    }
-
-    return Math.max(0.3, Math.min(0.99, confidence));
-  }
-
-  /**
-   * Check if path should be ignored
-   */
-  shouldIgnore(filePath) {
-    for (const pattern of this.ignorePaths) {
-      const regex = new RegExp(
-        pattern
-          .replace(/\*\*/g, ".*")
-          .replace(/\*/g, "[^/]*")
-      );
-      if (regex.test(filePath)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /**
-   * Summarize findings for a file
-   */
-  summarizeFindings(findings) {
-    const bySeverity = {
-      critical: findings.filter(f => f.severity === "critical").length,
-      high: findings.filter(f => f.severity === "high").length,
-      medium: findings.filter(f => f.severity === "medium").length,
-      low: findings.filter(f => f.severity === "low").length,
-      info: findings.filter(f => f.severity === "info").length
-    };
-
-    return {
-      total: findings.length,
-      bySeverity,
-      needsAttention: bySeverity.critical > 0 || bySeverity.high > 0
-    };
-  }
-
-  /**
-   * Generate overall summary
-   */
-  generateOverallSummary() {
-    const allFindings = this.results.flatMap(r => r.findings);
-    
-    const bySeverity = {
-      critical: allFindings.filter(f => f.severity === "critical"),
-      high: allFindings.filter(f => f.severity === "high"),
-      medium: allFindings.filter(f => f.severity === "medium"),
-      low: allFindings.filter(f => f.severity === "low"),
-      info: allFindings.filter(f => f.severity === "info")
-    };
-
-    const byCategory = {};
-    for (const finding of allFindings) {
-      if (!byCategory[finding.category]) {
-        byCategory[finding.category] = [];
-      }
-      byCategory[finding.category].push(finding);
-    }
-
-    return {
-      filesReviewed: this.results.length,
-      totalFindings: allFindings.length,
-      bySeverity: {
-        critical: bySeverity.critical.length,
-        high: bySeverity.high.length,
-        medium: bySeverity.medium.length,
-        low: bySeverity.low.length,
-        info: bySeverity.info.length
-      },
-      byCategory: Object.fromEntries(
-        Object.entries(byCategory).map(([k, v]) => [k, v.length])
-      ),
-      blockers: bySeverity.critical.length + bySeverity.high.length,
-      verdict: this.calculateVerdict(bySeverity)
-    };
-  }
-
-  /**
-   * Calculate review verdict
-   */
-  calculateVerdict(bySeverity) {
-    if (bySeverity.critical.length > 0) {
-      return {
-        status: "BLOCK",
-        message: `${bySeverity.critical.length} critical issue(s) must be fixed`,
-        icon: "🛑"
-      };
-    }
-    
-    if (bySeverity.high.length > 2) {
-      return {
-        status: "REQUEST_CHANGES",
-        message: `${bySeverity.high.length} high-severity issues need attention`,
-        icon: "⚠️"
-      };
-    }
-    
-    if (bySeverity.high.length > 0 || bySeverity.medium.length > 5) {
-      return {
-        status: "COMMENT",
-        message: "Some issues to consider before merging",
-        icon: "💬"
-      };
-    }
-    
-    return {
-      status: "APPROVE",
-      message: "Code looks good!",
-      icon: "✅"
-    };
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // PR COMMENT GENERATION
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Generate PR comment markdown
-   */
-  generatePRComment() {
-    const summary = this.generateOverallSummary();
-    
-    let comment = `## ${summary.verdict.icon} Code Review - ${summary.verdict.status}\n\n`;
-    comment += `${summary.verdict.message}\n\n`;
-    
-    // Summary table
-    comment += `### Summary\n`;
-    comment += `| Metric | Value |\n`;
-    comment += `|--------|-------|\n`;
-    comment += `| Files Reviewed | ${summary.filesReviewed} |\n`;
-    comment += `| Total Findings | ${summary.totalFindings} |\n`;
-    comment += `| Critical | ${summary.bySeverity.critical} |\n`;
-    comment += `| High | ${summary.bySeverity.high} |\n`;
-    comment += `| Medium | ${summary.bySeverity.medium} |\n`;
-    comment += `| Low + Info | ${summary.bySeverity.low + summary.bySeverity.info} |\n\n`;
-
-    // Critical and high severity findings
-    const urgent = this.results.flatMap(r => r.findings)
-      .filter(f => f.severity === "critical" || f.severity === "high");
-    
-    if (urgent.length > 0) {
-      comment += `### 🚨 Issues Requiring Attention\n\n`;
-      
-      for (const finding of urgent.slice(0, 10)) {
-        comment += `<details>\n`;
-        comment += `<summary><strong>${finding.categoryIcon} ${finding.ruleName}</strong> - ${finding.file}:${finding.line}</summary>\n\n`;
-        comment += `**Severity:** ${finding.severity.toUpperCase()}\n\n`;
-        comment += `**Issue:** ${finding.message}\n\n`;
-        if (finding.match) {
-          comment += `**Code:**\n\`\`\`\n${finding.match}\n\`\`\`\n\n`;
-        }
-        comment += `**Suggested Fix:** ${finding.fix}\n\n`;
-        comment += `</details>\n\n`;
-      }
-      
-      if (urgent.length > 10) {
-        comment += `\n_...and ${urgent.length - 10} more urgent issues_\n\n`;
-      }
-    }
-
-    // Other findings grouped by category
-    comment += `### Other Findings by Category\n\n`;
-    
-    for (const [categoryId, category] of Object.entries(this.categories)) {
-      const categoryFindings = this.results.flatMap(r => r.findings)
-        .filter(f => f.category === categoryId && 
-                    f.severity !== "critical" && 
-                    f.severity !== "high");
-      
-      if (categoryFindings.length > 0) {
-        comment += `<details>\n`;
-        comment += `<summary>${category.icon} ${category.name} (${categoryFindings.length})</summary>\n\n`;
-        
-        for (const finding of categoryFindings.slice(0, 5)) {
-          comment += `- **${finding.ruleName}** - \`${finding.file}:${finding.line}\`\n`;
-          comment += `  ${finding.message}\n\n`;
-        }
-        
-        if (categoryFindings.length > 5) {
-          comment += `_...and ${categoryFindings.length - 5} more_\n`;
-        }
-        
-        comment += `</details>\n\n`;
-      }
-    }
-
-    // Footer
-    comment += `---\n`;
-    comment += `_Automated review by Vibecheck AI Code Review_\n`;
-
-    return comment;
-  }
-
-  /**
-   * Generate inline comments for PR
-   */
-  generateInlineComments() {
-    const comments = [];
-    
-    for (const result of this.results) {
-      for (const finding of result.findings) {
-        comments.push({
-          path: finding.file,
-          line: finding.line,
-          body: `${finding.categoryIcon} **${finding.ruleName}**\n\n` +
-                `${finding.message}\n\n` +
-                `**Suggested fix:** ${finding.fix}\n\n` +
-                `_Severity: ${finding.severity} | Confidence: ${(finding.confidence * 100).toFixed(0)}%_`
-        });
-      }
-    }
-    
-    return comments;
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // FEEDBACK & LEARNING
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Record feedback on a finding
-   */
-  recordFeedback(findingId, accepted) {
-    const finding = this.results
-      .flatMap(r => r.findings)
-      .find(f => f.id === findingId);
-    
-    if (!finding) return;
-
-    const key = finding.ruleId;
-    if (!this.feedback.has(key)) {
-      this.feedback.set(key, { accepted: 0, rejected: 0 });
-    }
-    
-    const fb = this.feedback.get(key);
-    if (accepted) {
-      fb.accepted++;
-    } else {
-      fb.rejected++;
-    }
-  }
-
-  /**
-   * Export feedback for persistence
-   */
-  exportFeedback() {
-    return Object.fromEntries(this.feedback);
-  }
-
-  /**
-   * Import feedback from persistence
-   */
-  importFeedback(data) {
-    this.feedback = new Map(Object.entries(data));
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // CUSTOM RULES
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Add a custom rule
-   */
-  addRule(categoryId, rule) {
-    if (!this.categories[categoryId]) {
-      this.categories[categoryId] = {
-        name: categoryId,
-        icon: "📋",
-        rules: []
-      };
-    }
-    
-    // Compile pattern if string
-    if (typeof rule.pattern === "string") {
-      rule.pattern = new RegExp(rule.pattern, "gm");
-    }
-    
-    this.categories[categoryId].rules.push(rule);
-  }
-
-  /**
-   * Add a custom category
-   */
-  addCategory(categoryId, category) {
-    this.categories[categoryId] = {
-      name: category.name || categoryId,
-      icon: category.icon || "📋",
-      rules: category.rules || []
-    };
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// EXPORTS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-module.exports = {
-  AICodeReviewEngine,
-  REVIEW_CATEGORIES
-};