interface CodeReviewStrategy {
  // Analyze code changes
  analyze(changes: CodeChanges): Promise<ReviewReport>
  
  // Generate suggestions
  suggest(issues: Issue[]): Promise<Suggestion[]>
  
  // Validate against standards
  validate(code: string, standards: Standards): ValidationResult
  
  // Learn from feedback
  learn(feedback: ReviewFeedback): void
}

name: Claude Code AI-Assisted Review
on:
  pull_request:
    types: [opened, synchronize, reopened]
 
jobs:
  automated_review:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Code
        uses: actions/checkout@v4
        with:
          fetch-depth: 0  # Full history for better analysis
 
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
 
      - name: Run Linter & Static Analysis
        run: |
          npm ci
          npm run lint:check
          npm run typecheck
        continue-on-error: true  # Capture errors for AI review
 
      - name: Run Unit & Integration Tests
        run: |
          npm test -- --coverage --json --outputFile=test-results.json
        continue-on-error: true
 
      - name: Security Scan with CodeQL
        uses: github/codeql-action/analyze@v3
        with:
          languages: javascript, typescript
 
      - name: Generate AI Review Summary
        env:
          CLAUDE_API_KEY: ${{ secrets.CLAUDE_API_KEY }}
        run: |
          # Get PR diff
          git diff ${{ github.event.pull_request.base.sha }} ${{ github.event.pull_request.head.sha }} > changes.diff
          
          # Combine all analysis results
          echo "## Automated Review Results" > review_input.md
          echo "### Lint Results" >> review_input.md
          npm run lint:check --silent 2>&1 | tail -n 50 >> review_input.md || true
          echo "### Test Results" >> review_input.md
          cat test-results.json | jq '.numFailedTests, .numPassedTests' >> review_input.md || true
          echo "### Code Changes" >> review_input.md
          head -n 1000 changes.diff >> review_input.md
          
          # Use Claude to analyze and generate review
          claude -p "Review this PR for:
            1. Code quality issues
            2. Security vulnerabilities  
            3. Performance concerns
            4. Best practice violations
            5. Test coverage gaps
            
            Provide specific, actionable feedback with code examples.
            Format as a GitHub PR review comment." < review_input.md > review_summary.md
    
      - name: Post AI Review as PR Comment
        uses: actions/github-script@v7
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          script: |
            const fs = require('fs');
            const reviewContent = fs.readFileSync('review_summary.md', 'utf8');
            
            // Add header to distinguish AI review
            const comment = `## 🤖 Claude Code Review
            
            ${reviewContent}
            
            ---
            *This is an automated review. Human review is still required for merge approval.*`;
            
            await github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: comment
            });
 
      - name: Quality Gate Check
        run: |
          # Check if critical issues were found
          if grep -q "CRITICAL\|HIGH" review_summary.md; then
            echo "❌ Quality gate failed: Critical issues found"
            exit 1
          fi
          
          # Check test coverage
          COVERAGE=$(cat coverage/coverage-summary.json | jq '.total.lines.pct')
          if (( $(echo "$COVERAGE < 80" | bc -l) )); then
            echo "❌ Quality gate failed: Coverage below 80%"
            exit 1
          fi
          
          echo "✅ Quality gates passed"

class ReviewPrioritizer {
  prioritize(pullRequests: PullRequest[]): PrioritizedList {
    return pullRequests
      .map(pr => ({
        pr,
        score: this.calculateScore(pr)
      }))
      .sort((a, b) => b.score - a.score)
  }
  
  private calculateScore(pr: PullRequest): number {
    const factors = {
      criticalPath: pr.affectsCriticalPath ? 10 : 0,
      securityImpact: pr.securityChanges ? 8 : 0,
      size: Math.max(0, 5 - pr.filesChanged / 10),
      author: pr.author.isNewContributor ? 3 : 0
    }
    
    return Object.values(factors).reduce((a, b) => a + b, 0)
  }
}

class PatternReviewer {
  private patterns = new Map<string, ReviewPattern>()
  
  async reviewCode(code: string): Promise<ReviewResult> {
    const detectedPatterns = await this.detectPatterns(code)
    const suggestions = []
    
    for (const pattern of detectedPatterns) {
      if (this.patterns.has(pattern.type)) {
        const reviewer = this.patterns.get(pattern.type)!
        suggestions.push(...await reviewer.review(pattern))
      }
    }
    
    return { suggestions, patterns: detectedPatterns }
  }
}

async function automatedReview(pr: PullRequest) {
  // Run automated checks
  const results = await Promise.all([
    runLinting(pr),
    runSecurityScan(pr),
    runTests(pr),
    analyzeComplexity(pr)
  ])
  
  // Generate AI review with specific focus areas
  const aiReview = await generateAIReview(pr, {
    results,
    focusAreas: [
      'security vulnerabilities',
      'performance bottlenecks',
      'test coverage gaps',
      'code duplication',
      'API contract violations'
    ],
    contextFiles: ['CLAUDE.md', 'ARCHITECTURE.md']
  })
  
  // Post categorized feedback
  await postReviewComments(pr, {
    critical: aiReview.securityIssues,
    suggestions: aiReview.improvements,
    praise: aiReview.goodPatterns
  })
}

class IncrementalReviewer {
  async reviewChange(change: CodeChange) {
    // Review immediately
    const feedback = await this.analyze(change)
    
    // Provide real-time suggestions
    if (feedback.hasIssues()) {
      await this.notifyDeveloper(feedback)
    }
  }
}

class LearningReviewer {
  async learn(review: CompletedReview) {
    // Extract patterns from accepted suggestions
    const patterns = this.extractPatterns(review)
    
    // Update review model
    await this.model.train(patterns)
    
    // Adjust future reviews
    this.updateStrategies(patterns)
  }
}