AI-Powered Code Review — Automated PR Review That Developers Actually Trust

interface CodeDiff {
  filename: string;
  additions: Array<{ lineNum: number; code: string }>;
  deletions: Array<{ lineNum: number; code: string }>;
  beforeContext: string;
  afterContext: string;
}

async function parsePullRequest(prUrl: string): Promise<CodeDiff[]> {
  const diffs = await github.getPullRequestDiff(prUrl);

  const parsed: CodeDiff[] = [];
  for (const diff of diffs) {
    const fullFile = await github.getFileContent(diff.filename);

    parsed.push({
      filename: diff.filename,
      additions: diff.additions,
      deletions: diff.deletions,
      beforeContext: fullFile.content, // Full file for context
      afterContext: applyDiff(fullFile.content, diff)
    });
  }

  return parsed;
}

interface SecurityIssue {
  severity: 'critical' | 'high' | 'medium';
  type: string;
  lineNum: number;
  code: string;
  explanation: string;
  cweId?: string;
}

async function detectSecurityIssues(
  diff: CodeDiff
): Promise<SecurityIssue[]> {
  const prompt = `
    Review this code addition for security issues:

    File: ${diff.filename}
    New code:
    ${diff.additions.map(a => a.code).join('\n')}

    Context:
    ${diff.beforeContext}

    Check for:
    - SQL injection, command injection, code injection
    - Path traversal vulnerabilities
    - Weak cryptography or random number generation
    - Hardcoded secrets or credentials
    - CSRF/CORS misconfigurations
    - Unsafe deserialization
    - XXE attacks

    Return JSON array of issues with severity, type, line number, and explanation.
  `;

  const issues = JSON.parse(await llm.generate(prompt));
  return issues.filter((issue: any) => issue.confidence > 0.85);
}

interface BugPattern {
  pattern: string;
  lineNum: number;
  suggestion: string;
  category: 'logic' | 'nullPointer' | 'asyncIssue' | 'typeError' | 'offByOne';
}

async function detectBugPatterns(diff: CodeDiff): Promise<BugPattern[]> {
  const bugPatternPrompt = `
    Analyze this code diff for common bugs:

    ${diff.additions.map(a => a.code).join('\n')}

    Look for:
    - Null/undefined dereferences without checks
    - Off-by-one errors in loops
    - Incorrect async/await usage
    - Unhandled promise rejections
    - Missing break/return statements
    - Logic inversions (if (x) should be if (!x))
    - Variable shadowing

    Return JSON with confidence scores (0-1).
  `;

  const patterns = JSON.parse(await llm.generate(bugPatternPrompt));
  return patterns.filter((p: any) => p.confidence > 0.80);
}

interface StyleViolation {
  rule: string;
  lineNum: number;
  violation: string;
  suggestion: string;
  autoFixable: boolean;
}

async function checkStyleGuide(
  diff: CodeDiff,
  styleGuide: string
): Promise<StyleViolation[]> {
  // First, run ESLint, Prettier, etc.
  const lintResults = await runLinters(diff.filename);

  // Then add contextual style feedback
  const stylePrompt = `
    Company style guide:
    ${styleGuide}

    New code:
    ${diff.additions.map(a => a.code).join('\n')}

    Does this follow our style guide? Focus on:
    - Naming conventions (camelCase, PascalCase, SCREAMING_SNAKE_CASE)
    - Code organization and file structure
    - Comment conventions
    - Error handling patterns

    Return high-confidence violations only.
  `;

  const styleFeedback = JSON.parse(await llm.generate(stylePrompt));
  return styleFeedback;
}

interface TestSuggestion {
  description: string;
  testCode: string;
  criticality: 'must' | 'should' | 'nice-to-have';
}

async function suggestTests(diff: CodeDiff): Promise<TestSuggestion[]> {
  const testPrompt = `
    These functions were added/modified:
    ${diff.additions.map(a => a.code).join('\n')}

    The existing tests are:
    ${await getExistingTests(diff.filename)}

    Suggest test cases for edge cases:
    1. Null/undefined inputs
    2. Empty arrays or objects
    3. Boundary values
    4. Error conditions
    5. Async failures

    For each suggestion, indicate if it''s critical.
    Return JSON with test code snippets.
  `;

  const suggestions = JSON.parse(await llm.generate(testPrompt));
  return suggestions;
}

interface ComplexityIssue {
  functionName: string;
  cyclomaticComplexity: number;
  nestingDepth: number;
  suggestion: string;
}

async function analyzeComplexity(diff: CodeDiff): Promise<ComplexityIssue[]> {
  const issues: ComplexityIssue[] = [];

  for (const addition of diff.additions) {
    const cyclomatic = calculateCyclomaticComplexity(addition.code);
    const nesting = calculateNestingDepth(addition.code);

    if (cyclomatic > 10 || nesting > 4) {
      const refactoringPrompt = `
        This function has cyclomatic complexity ${cyclomatic} and nesting depth ${nesting}.
        Suggest a refactoring to simplify it:
        ${addition.code}
      `;

      const suggestion = await llm.generate(refactoringPrompt);

      issues.push({
        functionName: extractFunctionName(addition.code),
        cyclomaticComplexity: cyclomatic,
        nestingDepth: nesting,
        suggestion
      });
    }
  }

  return issues;
}

interface ReviewComment {
  severity: 'info' | 'warning' | 'error';
  lineNum: number;
  title: string;
  explanation: string;
  suggestion: string;
  exampleCode?: string;
  docsLink?: string;
}

async function generateExplanation(issue: any): Promise<ReviewComment> {
  const explanationPrompt = `
    A code review issue was detected:
    ${JSON.stringify(issue)}

    Explain to a developer:
    1. Why this matters (business or technical impact)
    2. What''s wrong with the current code
    3. How to fix it (concrete suggestion)
    4. Link to relevant documentation

    Keep explanation under 3 sentences. Be respectful.
  `;

  const explanation = await llm.generate(explanationPrompt);

  return {
    severity: issue.severity,
    lineNum: issue.lineNum,
    title: issue.title,
    explanation,
    suggestion: issue.suggestion,
    exampleCode: issue.exampleCode,
    docsLink: issue.docsLink
  };
}

interface ReviewFeedback {
  commentId: string;
  isAccurate: boolean;
  wasFalsePositive: boolean;
  developerNotes?: string;
}

async function trackAccuracy(
  comments: ReviewComment[],
  feedback: ReviewFeedback[]
): Promise<void> {
  const falsePositiveRate = feedback.filter(f => f.wasFalsePositive).length
    / feedback.length;

  if (falsePositiveRate > 0.15) {
    console.warn('False positive rate exceeds 15%. Review prompt.');
  }

  // Log patterns in false positives
  const fps = feedback.filter(f => f.wasFalsePositive);
  for (const fp of fps) {
    await analyticsDb.insert('false_positives', {
      commentType: findCommentType(fp.commentId, comments),
      developerFeedback: fp.developerNotes,
      timestamp: new Date()
    });
  }
}

async function postReviewComments(
  prUrl: string,
  comments: ReviewComment[]
): Promise<void> {
  const pr = github.parsePullRequestUrl(prUrl);

  // Group comments by severity
  const summary = `
    AI Review Summary:
    - ${comments.filter(c => c.severity === 'error').length} errors
    - ${comments.filter(c => c.severity === 'warning').length} warnings
    - ${comments.filter(c => c.severity === 'info').length} suggestions
  `;

  await github.postPullRequestComment(pr, summary);

  // Post individual line comments
  for (const comment of comments) {
    if (comment.severity === 'error') { // Only post high-confidence items
      await github.postLineComment(pr, {
        path: comment.filename,
        line: comment.lineNum,
        body: `**${comment.title}**\n\n${comment.explanation}\n\n**Suggestion:** ${comment.suggestion}`
      });
    }
  }
}

function aggregateComments(comments: ReviewComment[]): ReviewComment[] {
  const grouped = new Map<string, ReviewComment[]>();

  for (const comment of comments) {
    const key = `${comment.title}::${comment.severity}`;
    if (!grouped.has(key)) grouped.set(key, []);
    grouped.get(key)!.push(comment);
  }

  const aggregated: ReviewComment[] = [];
  for (const [, group] of grouped) {
    if (group.length === 1) {
      aggregated.push(group[0]);
    } else {
      // Combine similar issues
      aggregated.push({
        ...group[0],
        explanation: `This issue appears ${group.length} times in this PR. Found on lines: ${group.map(c => c.lineNum).join(', ')}`
      });
    }
  }

  return aggregated;
}