AI Code Review Automation with GitHub Actions

# .github/workflows/ai-code-review.yml
name: AI Code Review

on:
  pull_request:
    types: [opened, synchronize, reopened]
    branches: [main, develop]
  pull_request_review:
    types: [submitted]

env:
  OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

jobs:
  ai-code-review:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
      issues: write
    
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
        with:
          fetch-depth: 0
          token: ${{ secrets.GITHUB_TOKEN }}

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '18'
          cache: 'npm'

      - name: Install dependencies
        run: |
          npm install @octokit/rest openai @anthropic-ai/sdk
          npm install --save-dev @types/node typescript

      - name: Get changed files
        id: changed-files
        uses: tj-actions/changed-files@v39
        with:
          files: |
            **/*.{js,ts,jsx,tsx,py,java,go,rs,cpp,c,php,rb}
          separator: ","

      - name: Run AI Code Review
        if: steps.changed-files.outputs.any_changed == 'true'
        run: |
          node scripts/ai-code-review.js
        env:
          CHANGED_FILES: ${{ steps.changed-files.outputs.all_changed_files }}
          PR_NUMBER: ${{ github.event.pull_request.number }}
          REPO_OWNER: ${{ github.repository_owner }}
          REPO_NAME: ${{ github.event.repository.name }}
          BASE_SHA: ${{ github.event.pull_request.base.sha }}
          HEAD_SHA: ${{ github.event.pull_request.head.sha }}

      - name: Update PR with AI Review Summary
        if: steps.changed-files.outputs.any_changed == 'true'
        run: |
          node scripts/update-pr-summary.js
        env:
          PR_NUMBER: ${{ github.event.pull_request.number }}
          REPO_OWNER: ${{ github.repository_owner }}
          REPO_NAME: ${{ github.event.repository.name }}

// scripts/ai-code-review.js
const { Octokit } = require('@octokit/rest');
const OpenAI = require('openai');
const fs = require('fs');
const path = require('path');

class AICodeReviewer {
  constructor() {
    this.octokit = new Octokit({
      auth: process.env.GITHUB_TOKEN,
    });
    
    this.openai = new OpenAI({
      apiKey: process.env.OPENAI_API_KEY,
    });
    
    this.config = {
      maxFileSize: 50000, // 50KB limit
      maxTokensPerRequest: 4000,
      supportedExtensions: ['.js', '.ts', '.jsx', '.tsx', '.py', '.java', '.go'],
      excludePatterns: [
        'node_modules/',
        'dist/',
        'build/',
        '.git/',
        '*.min.js',
        '*.bundle.js'
      ]
    };
  }

  async reviewPullRequest() {
    const {
      REPO_OWNER: owner,
      REPO_NAME: repo,
      PR_NUMBER: pullNumber,
      BASE_SHA: baseSha,
      HEAD_SHA: headSha,
      CHANGED_FILES: changedFilesStr
    } = process.env;

    const changedFiles = changedFilesStr.split(',').filter(Boolean);
    console.log(`Reviewing ${changedFiles.length} changed files`);

    const reviewResults = [];

    for (const filePath of changedFiles) {
      if (this.shouldSkipFile(filePath)) {
        console.log(`Skipping ${filePath}`);
        continue;
      }

      try {
        const fileContent = await this.getFileContent(filePath);
        const fileDiff = await this.getFileDiff(owner, repo, baseSha, headSha, filePath);
        
        if (!fileContent || !fileDiff) continue;

        const review = await this.analyzeFile(filePath, fileContent, fileDiff);
        
        if (review && review.issues.length > 0) {
          reviewResults.push({
            filePath,
            review,
            diff: fileDiff
          });
        }
      } catch (error) {
        console.error(`Error reviewing ${filePath}:`, error);
      }
    }

    // Post review comments
    await this.postReviewComments(owner, repo, pullNumber, reviewResults);
    
    // Generate summary
    await this.generateReviewSummary(reviewResults);
  }

  shouldSkipFile(filePath) {
    // Check file size
    try {
      const stats = fs.statSync(filePath);
      if (stats.size > this.config.maxFileSize) {
        return true;
      }
    } catch (error) {
      return true; // File doesn't exist or can't be read
    }

    // Check extension
    const ext = path.extname(filePath);
    if (!this.config.supportedExtensions.includes(ext)) {
      return true;
    }

    // Check exclude patterns
    return this.config.excludePatterns.some(pattern => 
      filePath.includes(pattern)
    );
  }

  async getFileContent(filePath) {
    try {
      return fs.readFileSync(filePath, 'utf8');
    } catch (error) {
      console.error(`Failed to read file ${filePath}:`, error);
      return null;
    }
  }

  async getFileDiff(owner, repo, baseSha, headSha, filePath) {
    try {
      const response = await this.octokit.repos.compareCommits({
        owner,
        repo,
        base: baseSha,
        head: headSha,
      });

      const file = response.data.files.find(f => f.filename === filePath);
      return file ? file.patch : null;
    } catch (error) {
      console.error(`Failed to get diff for ${filePath}:`, error);
      return null;
    }
  }

  async analyzeFile(filePath, content, diff) {
    const language = this.detectLanguage(filePath);
    
    const prompt = this.buildAnalysisPrompt(filePath, content, diff, language);
    
    try {
      const response = await this.openai.chat.completions.create({
        model: 'gpt-4',
        messages: [
          {
            role: 'system',
            content: this.getSystemPrompt(language)
          },
          {
            role: 'user',
            content: prompt
          }
        ],
        max_tokens: 2000,
        temperature: 0.1,
        response_format: { type: 'json_object' }
      });

      const analysis = JSON.parse(response.choices[0].message.content);
      return this.processAnalysis(analysis, filePath);
    } catch (error) {
      console.error(`AI analysis failed for ${filePath}:`, error);
      return null;
    }
  }

  getSystemPrompt(language) {
    return `You are an expert code reviewer specializing in ${language}. 
    Analyze the provided code changes and identify:

    1. **Security vulnerabilities** - SQL injection, XSS, authentication issues
    2. **Performance issues** - Inefficient algorithms, memory leaks, blocking operations
    3. **Code quality** - Maintainability, readability, best practices
    4. **Bug potential** - Logic errors, edge cases, null pointer issues
    5. **Architecture concerns** - Design patterns, separation of concerns

    Respond with a JSON object containing:
    {
      "overall_score": 1-10,
      "issues": [
        {
          "type": "security|performance|quality|bug|architecture",
          "severity": "critical|high|medium|low",
          "line": line_number_or_null,
          "title": "Brief issue title",
          "description": "Detailed explanation",
          "suggestion": "How to fix this issue",
          "code_snippet": "Problem code if applicable"
        }
      ],
      "positive_aspects": ["List of good practices found"],
      "summary": "Overall assessment and recommendations"
    }

    Be constructive and specific. Focus on changes in the diff, not the entire file.
    Only report significant issues that impact functionality, security, or maintainability.`;
  }

  buildAnalysisPrompt(filePath, content, diff, language) {
    return `File: ${filePath}
Language: ${language}

DIFF (focus your review on these changes):
\`\`\`diff
${diff}
\`\`\`

FULL FILE CONTENT (for context):
\`\`\`${language}
${content}
\`\`\`

Please analyze the changes in the diff and provide feedback on potential issues.`;
  }

  detectLanguage(filePath) {
    const ext = path.extname(filePath);
    const languageMap = {
      '.js': 'javascript',
      '.jsx': 'javascript',
      '.ts': 'typescript',
      '.tsx': 'typescript',
      '.py': 'python',
      '.java': 'java',
      '.go': 'go',
      '.rs': 'rust',
      '.cpp': 'cpp',
      '.c': 'c',
      '.php': 'php',
      '.rb': 'ruby'
    };
    
    return languageMap[ext] || 'text';
  }

  processAnalysis(analysis, filePath) {
    // Filter and prioritize issues
    const prioritizedIssues = analysis.issues
      .filter(issue => issue.severity === 'critical' || issue.severity === 'high')
      .sort((a, b) => {
        const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
        return severityOrder[a.severity] - severityOrder[b.severity];
      });

    return {
      ...analysis,
      issues: prioritizedIssues,
      filePath
    };
  }

  async postReviewComments(owner, repo, pullNumber, reviewResults) {
    const comments = [];

    for (const result of reviewResults) {
      for (const issue of result.review.issues) {
        if (issue.line && issue.severity !== 'low') {
          const comment = this.formatComment(issue, result.filePath);
          
          try {
            await this.octokit.pulls.createReviewComment({
              owner,
              repo,
              pull_number: pullNumber,
              body: comment,
              path: result.filePath,
              line: issue.line,
              side: 'RIGHT'
            });
            
            comments.push(comment);
          } catch (error) {
            console.error(`Failed to post comment on ${result.filePath}:${issue.line}`, error);
          }
        }
      }
    }

    console.log(`Posted ${comments.length} review comments`);
  }

  formatComment(issue, filePath) {
    const severityEmoji = {
      critical: '🚨',
      high: '⚠️',
      medium: '💡',
      low: 'ℹ️'
    };

    const typeEmoji = {
      security: '🔒',
      performance: '⚡',
      quality: '✨',
      bug: '🐛',
      architecture: '🏗️'
    };

    return `${severityEmoji[issue.severity]} ${typeEmoji[issue.type]} **${issue.title}**

${issue.description}

${issue.suggestion ? `**Suggestion:**\n${issue.suggestion}` : ''}

${issue.code_snippet ? `\n\`\`\`\n${issue.code_snippet}\n\`\`\`` : ''}

---
*Generated by AI Code Review*`;
  }

  async generateReviewSummary(reviewResults) {
    const summary = {
      totalFiles: reviewResults.length,
      criticalIssues: 0,
      highIssues: 0,
      mediumIssues: 0,
      lowIssues: 0,
      categories: {
        security: 0,
        performance: 0,
        quality: 0,
        bug: 0,
        architecture: 0
      }
    };

    reviewResults.forEach(result => {
      result.review.issues.forEach(issue => {
        summary[`${issue.severity}Issues`]++;
        summary.categories[issue.type]++;
      });
    });

    // Save summary for the PR update script
    fs.writeFileSync('review-summary.json', JSON.stringify(summary, null, 2));
    
    console.log('Review Summary:', summary);
  }
}

// Run the code review
async function main() {
  try {
    const reviewer = new AICodeReviewer();
    await reviewer.reviewPullRequest();
    console.log('AI code review completed successfully');
  } catch (error) {
    console.error('AI code review failed:', error);
    process.exit(1);
  }
}

main();

// scripts/security-analyzer.js
class SecurityAnalyzer {
  constructor() {
    this.vulnerabilityPatterns = {
      sql_injection: [
        /querys*+s*['"].*['"].*+/gi,
        /executes*(s*['"].*+.*['"]/gi,
        /${.*}.*FROM.*WHERE/gi
      ],
      xss: [
        /innerHTMLs*=s*.*+/gi,
        /document.writes*(.*+/gi,
        /evals*(.*+/gi
      ],
      hardcoded_secrets: [
        /passwords*=s*['"][^'"]{8,}['"]/gi,
        /api[_-]?keys*=s*['"][^'"]{20,}['"]/gi,
        /secrets*=s*['"][^'"]{16,}['"]/gi,
        /tokens*=s*['"][^'"]{32,}['"]/gi
      ],
      path_traversal: [
        /..[/\\]/g,
        /path.join(.*../gi
      ],
      weak_crypto: [
        /md5s*(/gi,
        /sha1s*(/gi,
        /Math.random()/gi
      ]
    };
  }

  analyzeCode(content, filePath) {
    const vulnerabilities = [];
    const lines = content.split('\n');

    Object.entries(this.vulnerabilityPatterns).forEach(([category, patterns]) => {
      patterns.forEach(pattern => {
        lines.forEach((line, index) => {
          const matches = line.match(pattern);
          if (matches) {
            vulnerabilities.push({
              type: 'security',
              category,
              severity: this.getSeverity(category),
              line: index + 1,
              code: line.trim(),
              message: this.getSecurityMessage(category),
              suggestion: this.getSecuritySuggestion(category)
            });
          }
        });
      });
    });

    return vulnerabilities;
  }

  getSeverity(category) {
    const severityMap = {
      sql_injection: 'critical',
      xss: 'critical',
      hardcoded_secrets: 'critical',
      path_traversal: 'high',
      weak_crypto: 'medium'
    };
    return severityMap[category] || 'medium';
  }

  getSecurityMessage(category) {
    const messages = {
      sql_injection: 'Potential SQL injection vulnerability detected',
      xss: 'Potential Cross-Site Scripting (XSS) vulnerability',
      hardcoded_secrets: 'Hardcoded credentials detected',
      path_traversal: 'Potential path traversal vulnerability',
      weak_crypto: 'Weak cryptographic function usage'
    };
    return messages[category];
  }

  getSecuritySuggestion(category) {
    const suggestions = {
      sql_injection: 'Use parameterized queries or prepared statements',
      xss: 'Use proper input sanitization and output encoding',
      hardcoded_secrets: 'Use environment variables or secure key management',
      path_traversal: 'Validate and sanitize file paths',
      weak_crypto: 'Use cryptographically secure functions (e.g., crypto.randomBytes)'
    };
    return suggestions[category];
  }

  async analyzeWithAI(content, filePath) {
    const securityPrompt = `
    Analyze this code for security vulnerabilities. Focus on:
    
    1. Authentication and authorization flaws
    2. Input validation issues
    3. Cryptographic vulnerabilities
    4. Session management problems
    5. Error handling that exposes sensitive information
    6. Business logic vulnerabilities
    
    File: ${filePath}
    
    Code:
    \`\`\`
    ${content}
    \`\`\`
    
    Provide specific line numbers and remediation steps.
    `;

    try {
      const response = await this.openai.chat.completions.create({
        model: 'gpt-4',
        messages: [
          {
            role: 'system',
            content: 'You are a cybersecurity expert specializing in code security analysis.'
          },
          {
            role: 'user',
            content: securityPrompt
          }
        ],
        max_tokens: 1500,
        temperature: 0.1
      });

      return this.parseSecurityResponse(response.choices[0].message.content);
    } catch (error) {
      console.error('AI security analysis failed:', error);
      return [];
    }
  }

  parseSecurityResponse(response) {
    // Parse the AI response and extract structured security findings
    const vulnerabilities = [];
    const lines = response.split('\n');
    
    let currentVuln = null;
    
    lines.forEach(line => {
      if (line.includes('Vulnerability:') || line.includes('Issue:')) {
        if (currentVuln) {
          vulnerabilities.push(currentVuln);
        }
        currentVuln = {
          type: 'security',
          severity: 'medium',
          title: line.replace(/.*(?:Vulnerability|Issue):\s*/, ''),
          description: '',
          suggestion: ''
        };
      } else if (currentVuln) {
        if (line.includes('Line:')) {
          currentVuln.line = parseInt(line.match(/\d+/)?.[0]);
        } else if (line.includes('Severity:')) {
          currentVuln.severity = line.toLowerCase().includes('critical') ? 'critical' :
                                 line.toLowerCase().includes('high') ? 'high' :
                                 line.toLowerCase().includes('low') ? 'low' : 'medium';
        } else if (line.includes('Description:')) {
          currentVuln.description = line.replace(/.*Description:\s*/, '');
        } else if (line.includes('Recommendation:')) {
          currentVuln.suggestion = line.replace(/.*Recommendation:\s*/, '');
        }
      }
    });
    
    if (currentVuln) {
      vulnerabilities.push(currentVuln);
    }
    
    return vulnerabilities;
  }
}

// Performance analyzer
class PerformanceAnalyzer {
  constructor() {
    this.performancePatterns = {
      n_plus_one: [
        /fors*(.*)s*{.*await.*}/gs,
        /.maps*(.*await.*)/gs,
        /.forEachs*(.*await.*)/gs
      ],
      blocking_operations: [
        /fs.readFileSync/gi,
        /fs.writeFileSync/gi,
        /JSON.parses*(.*)/gi
      ],
      memory_leaks: [
        /setIntervals*(/gi,
        /setTimeouts*(/gi,
        /addEventListeners*(/gi
      ],
      inefficient_dom: [
        /getElementById.*loop/gi,
        /querySelector.*fors*(/gi,
        /innerHTMLs*+=.*fors*(/gi
      ]
    };
  }

  analyzePerformance(content, diff) {
    const issues = [];
    const lines = content.split('\n');

    // Analyze for performance anti-patterns
    Object.entries(this.performancePatterns).forEach(([category, patterns]) => {
      patterns.forEach(pattern => {
        lines.forEach((line, index) => {
          if (pattern.test(line)) {
            issues.push({
              type: 'performance',
              category,
              severity: this.getPerformanceSeverity(category),
              line: index + 1,
              code: line.trim(),
              message: this.getPerformanceMessage(category),
              suggestion: this.getPerformanceSuggestion(category)
            });
          }
        });
      });
    });

    return issues;
  }

  getPerformanceSeverity(category) {
    const severityMap = {
      n_plus_one: 'high',
      blocking_operations: 'medium',
      memory_leaks: 'high',
      inefficient_dom: 'medium'
    };
    return severityMap[category] || 'medium';
  }

  getPerformanceMessage(category) {
    const messages = {
      n_plus_one: 'Potential N+1 query problem detected',
      blocking_operations: 'Synchronous operation may block the event loop',
      memory_leaks: 'Potential memory leak - missing cleanup',
      inefficient_dom: 'Inefficient DOM manipulation detected'
    };
    return messages[category];
  }

  getPerformanceSuggestion(category) {
    const suggestions = {
      n_plus_one: 'Consider batching queries or using Promise.all()',
      blocking_operations: 'Use async versions of file operations',
      memory_leaks: 'Add proper cleanup (clearInterval, removeEventListener)',
      inefficient_dom: 'Cache DOM queries or use document fragments'
    };
    return suggestions[category];
  }
}

// scripts/multi-model-analyzer.js
class MultiModelAnalyzer {
  constructor() {
    this.openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
    
    // Could also integrate Claude, Gemini, or local models
    this.models = {
      security: 'gpt-4', // Best for security analysis
      performance: 'gpt-3.5-turbo', // Faster for performance checks
      quality: 'gpt-4', // Best for code quality
      bugs: 'gpt-3.5-turbo' // Good enough for bug detection
    };
  }

  async analyzeWithMultipleModels(filePath, content, diff) {
    const analyses = await Promise.allSettled([
      this.securityAnalysis(content, diff),
      this.performanceAnalysis(content, diff),
      this.qualityAnalysis(content, diff),
      this.bugAnalysis(content, diff)
    ]);

    return this.consolidateAnalyses(analyses, filePath);
  }

  async securityAnalysis(content, diff) {
    const prompt = `Focus ONLY on security vulnerabilities in this code diff:

DIFF:
${diff}

CONTEXT:
${content.substring(0, 2000)}...

Identify:
1. Authentication/authorization issues
2. Input validation problems
3. SQL injection risks
4. XSS vulnerabilities
5. Hardcoded secrets
6. Cryptographic weaknesses

Return JSON: { "issues": [{"type": "security", "severity": "critical|high|medium|low", "line": number, "title": "...", "description": "...", "suggestion": "..."}] }`;

    return this.callModel(this.models.security, prompt);
  }

  async performanceAnalysis(content, diff) {
    const prompt = `Focus ONLY on performance issues in this code diff:

DIFF:
${diff}

CONTEXT:
${content.substring(0, 2000)}...

Identify:
1. N+1 query problems
2. Blocking operations
3. Memory leaks
4. Inefficient algorithms
5. Resource not being freed
6. Unnecessary re-renders (React)

Return JSON: { "issues": [{"type": "performance", "severity": "critical|high|medium|low", "line": number, "title": "...", "description": "...", "suggestion": "..."}] }`;

    return this.callModel(this.models.performance, prompt);
  }

  async qualityAnalysis(content, diff) {
    const prompt = `Focus ONLY on code quality issues in this code diff:

DIFF:
${diff}

CONTEXT:
${content.substring(0, 2000)}...

Identify:
1. Code duplication
2. Complex functions (high cyclomatic complexity)
3. Poor naming conventions
4. Missing error handling
5. Lack of documentation
6. Design pattern violations

Return JSON: { "issues": [{"type": "quality", "severity": "critical|high|medium|low", "line": number, "title": "...", "description": "...", "suggestion": "..."}] }`;

    return this.callModel(this.models.quality, prompt);
  }

  async bugAnalysis(content, diff) {
    const prompt = `Focus ONLY on potential bugs in this code diff:

DIFF:
${diff}

CONTEXT:
${content.substring(0, 2000)}...

Identify:
1. Null pointer exceptions
2. Array index out of bounds
3. Logic errors
4. Race conditions
5. Edge case handling
6. Type mismatches

Return JSON: { "issues": [{"type": "bug", "severity": "critical|high|medium|low", "line": number, "title": "...", "description": "...", "suggestion": "..."}] }`;

    return this.callModel(this.models.bugs, prompt);
  }

  async callModel(model, prompt) {
    try {
      const response = await this.openai.chat.completions.create({
        model,
        messages: [
          {
            role: 'system',
            content: 'You are an expert code reviewer. Return only valid JSON as requested.'
          },
          {
            role: 'user',
            content: prompt
          }
        ],
        max_tokens: 1500,
        temperature: 0.1,
        response_format: { type: 'json_object' }
      });

      return JSON.parse(response.choices[0].message.content);
    } catch (error) {
      console.error(`Model call failed for ${model}:`, error);
      return { issues: [] };
    }
  }

  consolidateAnalyses(analyses, filePath) {
    const allIssues = [];
    const duplicateTracker = new Set();

    analyses.forEach((result, index) => {
      if (result.status === 'fulfilled' && result.value.issues) {
        result.value.issues.forEach(issue => {
          // Simple deduplication based on line and title
          const key = `${issue.line}-${issue.title}`;
          
          if (!duplicateTracker.has(key)) {
            duplicateTracker.add(key);
            allIssues.push({
              ...issue,
              confidence: this.calculateConfidence(issue, index),
              filePath
            });
          }
        });
      }
    });

    // Sort by severity and confidence
    return allIssues.sort((a, b) => {
      const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
      const severityDiff = severityOrder[a.severity] - severityOrder[b.severity];
      
      if (severityDiff === 0) {
        return b.confidence - a.confidence;
      }
      
      return severityDiff;
    });
  }

  calculateConfidence(issue, modelIndex) {
    // Different models have different strengths
    const modelConfidence = {
      0: 0.9, // Security model
      1: 0.85, // Performance model
      2: 0.8, // Quality model
      3: 0.75  // Bug model
    };

    const severityBoost = {
      critical: 0.1,
      high: 0.05,
      medium: 0,
      low: -0.05
    };

    return Math.min(0.95, 
      modelConfidence[modelIndex] + severityBoost[issue.severity]
    );
  }
}

// Cost optimization
class CostOptimizer {
  constructor() {
    this.pricePerToken = {
      'gpt-4': { input: 0.03, output: 0.06 },
      'gpt-3.5-turbo': { input: 0.001, output: 0.002 }
    };
    
    this.monthlyBudget = 100; // $100 per month
    this.dailySpent = 0;
    this.requestCount = 0;
  }

  estimateCost(content, model = 'gpt-4') {
    const tokenCount = Math.ceil(content.length / 4); // Rough estimation
    const pricing = this.pricePerToken[model];
    
    return (tokenCount * pricing.input / 1000) + (500 * pricing.output / 1000);
  }

  shouldSkipAnalysis(content, filePath) {
    const estimatedCost = this.estimateCost(content);
    const dailyBudget = this.monthlyBudget / 30;
    
    // Skip if would exceed daily budget
    if (this.dailySpent + estimatedCost > dailyBudget) {
      console.log(`Skipping ${filePath} - would exceed daily budget`);
      return true;
    }
    
    // Skip very large files
    if (content.length > 50000) {
      console.log(`Skipping ${filePath} - file too large`);
      return true;
    }
    
    // Skip generated files
    if (filePath.includes('generated') || filePath.includes('.min.')) {
      return true;
    }
    
    return false;
  }

  trackSpending(cost) {
    this.dailySpent += cost;
    this.requestCount++;
    
    console.log(`Cost: $${cost.toFixed(4)}, Daily total: $${this.dailySpent.toFixed(2)}`);
  }
}

// scripts/update-pr-summary.js
const { Octokit } = require('@octokit/rest');
const fs = require('fs');

class PRSummaryGenerator {
  constructor() {
    this.octokit = new Octokit({
      auth: process.env.GITHUB_TOKEN,
    });
  }

  async updatePRWithSummary() {
    const {
      REPO_OWNER: owner,
      REPO_NAME: repo,
      PR_NUMBER: pullNumber
    } = process.env;

    try {
      // Read the review summary generated by the main script
      const summaryData = JSON.parse(fs.readFileSync('review-summary.json', 'utf8'));
      
      // Generate comprehensive summary
      const summaryComment = this.generateSummaryComment(summaryData);
      
      // Check if AI summary comment already exists
      const existingComments = await this.octokit.issues.listComments({
        owner,
        repo,
        issue_number: pullNumber,
      });

      const aiCommentMarker = '<!-- AI-CODE-REVIEW-SUMMARY -->';
      const existingAIComment = existingComments.data.find(comment => 
        comment.body.includes(aiCommentMarker)
      );

      if (existingAIComment) {
        // Update existing comment
        await this.octokit.issues.updateComment({
          owner,
          repo,
          comment_id: existingAIComment.id,
          body: summaryComment,
        });
        console.log('Updated existing AI review summary');
      } else {
        // Create new comment
        await this.octokit.issues.createComment({
          owner,
          repo,
          issue_number: pullNumber,
          body: summaryComment,
        });
        console.log('Created new AI review summary');
      }

      // Add labels based on severity
      await this.addLabelsBasedOnSeverity(owner, repo, pullNumber, summaryData);

    } catch (error) {
      console.error('Failed to update PR summary:', error);
    }
  }

  generateSummaryComment(summaryData) {
    const {
      totalFiles,
      criticalIssues,
      highIssues,
      mediumIssues,
      lowIssues,
      categories
    } = summaryData;

    const totalIssues = criticalIssues + highIssues + mediumIssues + lowIssues;
    
    let overallStatus = '✅ Good';
    let statusColor = '#28a745';
    
    if (criticalIssues > 0) {
      overallStatus = '🚨 Critical Issues Found';
      statusColor = '#dc3545';
    } else if (highIssues > 0) {
      overallStatus = '⚠️ Issues Need Attention';
      statusColor = '#ffc107';
    } else if (mediumIssues > 0) {
      overallStatus = '💡 Minor Improvements';
      statusColor = '#17a2b8';
    }

    const categoryIcons = {
      security: '🔒',
      performance: '⚡',
      quality: '✨',
      bug: '🐛',
      architecture: '🏗️'
    };

    const categorySection = Object.entries(categories)
      .filter(([, count]) => count > 0)
      .map(([category, count]) => 
        `${categoryIcons[category]} ${category.charAt(0).toUpperCase() + category.slice(1)}: ${count}`
      )
      .join(' | ');

    return `<!-- AI-CODE-REVIEW-SUMMARY -->
## 🤖 AI Code Review Summary

<table>
<tr>
<td align="center">
<img src="https://img.shields.io/badge/Status-${overallStatus.replace(/\s/g, '%20')}-${statusColor.substring(1)}" alt="Status" />
</td>
<td align="center">
<img src="https://img.shields.io/badge/Files%20Reviewed-${totalFiles}-blue" alt="Files" />
</td>
<td align="center">
<img src="https://img.shields.io/badge/Issues%20Found-${totalIssues}-${totalIssues > 0 ? 'orange' : 'green'}" alt="Issues" />
</td>
</tr>
</table>

### 📊 Issue Breakdown

| Severity | Count | Action Required |
|----------|-------|-----------------|
| 🚨 Critical | ${criticalIssues} | ${criticalIssues > 0 ? '**Must fix before merge**' : 'None'} |
| ⚠️ High | ${highIssues} | ${highIssues > 0 ? '**Should fix before merge**' : 'None'} |
| 💡 Medium | ${mediumIssues} | ${mediumIssues > 0 ? 'Consider fixing' : 'None'} |
| ℹ️ Low | ${lowIssues} | ${lowIssues > 0 ? 'Optional improvements' : 'None'} |

### 🎯 Issue Categories

${categorySection || 'No issues found'}

### 📝 Review Guidelines

${this.getReviewGuidelines(summaryData)}

### 🔄 Next Steps

${this.getNextSteps(summaryData)}

---

<details>
<summary>📈 Review Metrics</summary>

- **Review Coverage**: ${totalFiles} files analyzed
- **Analysis Time**: ~${Math.ceil(totalFiles * 2)} seconds
- **AI Model**: GPT-4 (security, quality) + GPT-3.5-turbo (performance, bugs)
- **Confidence Score**: ${this.calculateConfidenceScore(summaryData)}%

</details>

<sub>🤖 Generated by AI Code Review | Last updated: ${new Date().toISOString()}</sub>
`;
  }

  getReviewGuidelines(summaryData) {
    if (summaryData.criticalIssues > 0) {
      return `
- ⚠️ **Critical issues must be addressed** before merging
- Review all security vulnerabilities carefully
- Test fixes thoroughly before requesting re-review
- Consider pair programming for complex fixes`;
    }
    
    if (summaryData.highIssues > 0) {
      return `
- 🔍 **High priority issues should be fixed** before merging
- Review performance implications
- Validate suggested improvements
- Update tests if necessary`;
    }
    
    if (summaryData.mediumIssues > 0) {
      return `
- 💡 **Consider addressing medium priority items** for better code quality
- These improvements will enhance maintainability
- Safe to merge after review if time constraints exist`;
    }
    
    return `
- ✅ **Code looks good!** No critical issues found
- Optional improvements suggested
- Ready for human review and merge`;
  }

  getNextSteps(summaryData) {
    const steps = [];
    
    if (summaryData.criticalIssues > 0) {
      steps.push('1. 🚨 **Address critical security/bug issues immediately**');
      steps.push('2. 🧪 **Add tests for critical fixes**');
    }
    
    if (summaryData.highIssues > 0) {
      steps.push(`${steps.length + 1}. ⚠️ **Review and fix high priority items**`);
    }
    
    if (summaryData.categories.performance > 0) {
      steps.push(`${steps.length + 1}. ⚡ **Performance test changes with load testing**`);
    }
    
    steps.push(`${steps.length + 1}. 👀 **Request human code review**`);
    steps.push(`${steps.length + 1}. ✅ **Merge when all issues are resolved**`);
    
    return steps.join('\n');
  }

  calculateConfidenceScore(summaryData) {
    // Higher confidence for more comprehensive analysis
    let score = 75; // Base score
    
    if (summaryData.totalFiles > 5) score += 10;
    if (summaryData.categories.security > 0) score += 5;
    if (summaryData.categories.performance > 0) score += 5;
    
    return Math.min(95, score);
  }

  async addLabelsBasedOnSeverity(owner, repo, pullNumber, summaryData) {
    const labelsToAdd = [];
    
    if (summaryData.criticalIssues > 0) {
      labelsToAdd.push('⚠️ critical-issues');
    }
    
    if (summaryData.categories.security > 0) {
      labelsToAdd.push('🔒 security');
    }
    
    if (summaryData.categories.performance > 0) {
      labelsToAdd.push('⚡ performance');
    }
    
    if (summaryData.categories.bug > 0) {
      labelsToAdd.push('🐛 bug');
    }

    if (labelsToAdd.length > 0) {
      try {
        await this.octokit.issues.addLabels({
          owner,
          repo,
          issue_number: pullNumber,
          labels: labelsToAdd,
        });
        console.log(`Added labels: ${labelsToAdd.join(', ')}`);
      } catch (error) {
        console.error('Failed to add labels:', error);
      }
    }
  }
}

// Run the summary update
async function main() {
  try {
    const generator = new PRSummaryGenerator();
    await generator.updatePRWithSummary();
    console.log('PR summary updated successfully');
  } catch (error) {
    console.error('Failed to update PR summary:', error);
  }
}

main();

// .github/ai-review-config.json
{
  "enabled": true,
  "models": {
    "primary": "gpt-4",
    "fallback": "gpt-3.5-turbo",
    "security": "gpt-4",
    "performance": "gpt-3.5-turbo"
  },
  "analysis": {
    "security": {
      "enabled": true,
      "severity_threshold": "medium",
      "patterns": [
        "sql_injection",
        "xss",
        "hardcoded_secrets",
        "weak_crypto"
      ]
    },
    "performance": {
      "enabled": true,
      "check_loops": true,
      "check_async": true,
      "memory_analysis": true
    },
    "quality": {
      "enabled": true,
      "complexity_threshold": 10,
      "duplication_check": true,
      "naming_conventions": true
    },
    "bugs": {
      "enabled": true,
      "null_checks": true,
      "type_safety": true,
      "edge_cases": true
    }
  },
  "files": {
    "max_size_kb": 50,
    "supported_extensions": [".js", ".ts", ".jsx", ".tsx", ".py", ".java"],
    "exclude_patterns": [
      "node_modules/",
      "dist/",
      "build/",
      "*.min.js",
      "*.bundle.js",
      "coverage/",
      "__pycache__/"
    ],
    "include_tests": false
  },
  "comments": {
    "enabled": true,
    "severity_threshold": "medium",
    "max_comments_per_file": 5,
    "format": "detailed"
  },
  "cost_control": {
    "daily_budget_usd": 5.0,
    "monthly_budget_usd": 100.0,
    "skip_on_budget_exceeded": true,
    "cost_tracking": true
  },
  "quality_gates": {
    "block_on_critical": true,
    "block_on_high_security": true,
    "warning_on_high": true,
    "max_issues_per_pr": 20
  },
  "notifications": {
    "slack_webhook": "",
    "email_alerts": false,
    "teams_webhook": ""
  },
  "custom_prompts": {
    "security": "Focus on OWASP Top 10 vulnerabilities...",
    "performance": "Analyze for Node.js performance anti-patterns...",
    "react_specific": "Check for React best practices and hooks usage..."
  }
}

// Repository-specific overrides
// .github/ai-review-config.local.json
{
  "analysis": {
    "security": {
      "patterns": ["custom_banking_patterns", "pci_compliance"]
    }
  },
  "custom_rules": [
    {
      "name": "banking_transaction_validation",
      "pattern": "transaction.*amount.*validate",
      "severity": "critical",
      "message": "All transaction amounts must be validated"
    }
  ]
}

# .github/workflows/ai-review-advanced.yml
name: Advanced AI Code Review

on:
  pull_request:
    types: [opened, synchronize, reopened]
  schedule:
    # Weekly security scan
    - cron: '0 2 * * 1'
  workflow_dispatch:
    inputs:
      analysis_type:
        description: 'Type of analysis'
        required: true
        default: 'full'
        type: choice
        options:
        - full
        - security-only
        - performance-only
        - quality-only

env:
  OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
  ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

jobs:
  setup:
    runs-on: ubuntu-latest
    outputs:
      should_run: ${{ steps.check.outputs.should_run }}
      analysis_type: ${{ steps.config.outputs.analysis_type }}
      config: ${{ steps.config.outputs.config }}
    steps:
      - uses: actions/checkout@v4
      
      - name: Check if AI review should run
        id: check
        run: |
          # Check if AI review is enabled in config
          if [ -f ".github/ai-review-config.json" ]; then
            enabled=$(jq -r '.enabled // true' .github/ai-review-config.json)
            echo "should_run=$enabled" >> $GITHUB_OUTPUT
          else
            echo "should_run=true" >> $GITHUB_OUTPUT
          fi

      - name: Load configuration
        id: config
        run: |
          if [ -f ".github/ai-review-config.json" ]; then
            config=$(cat .github/ai-review-config.json | jq -c .)
            echo "config=$config" >> $GITHUB_OUTPUT
          fi
          
          analysis_type="${{ github.event.inputs.analysis_type || 'full' }}"
          echo "analysis_type=$analysis_type" >> $GITHUB_OUTPUT

  security-analysis:
    needs: setup
    if: needs.setup.outputs.should_run == 'true' && (needs.setup.outputs.analysis_type == 'full' || needs.setup.outputs.analysis_type == 'security-only')
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
          
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '18'
          cache: 'npm'

      - name: Install dependencies
        run: |
          npm install @octokit/rest openai semgrep
          
      - name: Run Security Analysis
        run: |
          # Combine AI analysis with static analysis tools
          semgrep --config=auto --json -o semgrep-results.json . || true
          node scripts/security-analysis.js
        env:
          CONFIG: ${{ needs.setup.outputs.config }}

  performance-analysis:
    needs: setup
    if: needs.setup.outputs.should_run == 'true' && (needs.setup.outputs.analysis_type == 'full' || needs.setup.outputs.analysis_type == 'performance-only')
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
          
      - name: Performance Analysis
        run: |
          node scripts/performance-analysis.js
        env:
          CONFIG: ${{ needs.setup.outputs.config }}

  quality-analysis:
    needs: setup
    if: needs.setup.outputs.should_run == 'true' && (needs.setup.outputs.analysis_type == 'full' || needs.setup.outputs.analysis_type == 'quality-only')
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        
      - name: Quality Analysis
        run: |
          npm install eslint @typescript-eslint/parser sonarjs
          node scripts/quality-analysis.js
        env:
          CONFIG: ${{ needs.setup.outputs.config }}

  consolidate-results:
    needs: [setup, security-analysis, performance-analysis, quality-analysis]
    if: always() && needs.setup.outputs.should_run == 'true'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Download all artifacts
        uses: actions/download-artifact@v3
        
      - name: Consolidate and Report
        run: |
          node scripts/consolidate-results.js
          node scripts/update-pr-summary.js
        env:
          CONFIG: ${{ needs.setup.outputs.config }}

  quality-gate:
    needs: consolidate-results
    if: always()
    runs-on: ubuntu-latest
    steps:
      - name: Quality Gate Check
        run: |
          node scripts/quality-gate.js
        env:
          CONFIG: ${{ needs.setup.outputs.config }}

# Separate workflow for cost monitoring
# .github/workflows/ai-review-cost-monitor.yml
name: AI Review Cost Monitor

on:
  schedule:
    - cron: '0 0 * * *' # Daily at midnight
  workflow_dispatch:

jobs:
  cost-monitoring:
    runs-on: ubuntu-latest
    steps:
      - name: Check API Usage and Costs
        run: |
          # Monitor OpenAI API usage
          curl -H "Authorization: Bearer $OPENAI_API_KEY" \
               "https://api.openai.com/v1/usage?date=$(date -d yesterday +%Y-%m-%d)" \
               | jq '.total_usage'
          
          # Alert if approaching budget limits
          # (Implementation depends on your monitoring setup)