GitLab CI/CD + Ollama
AI Code Reviewer

# ติดตั้ง Ollama ด้วย script อย่างเป็นทางการ
curl -fsSL https://ollama.com/install.sh | sh

# หรือติดตั้งด้วย Docker
docker pull ollama/ollama

# รัน Ollama container (CPU only)
docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

# รัน Ollama ด้วย GPU support (NVIDIA)
docker run -d --gpus=all -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

# ทดสอบ Ollama API ด้วย curl
curl http://localhost:11434/api/generate -d '{
  "model": "deepseek-coder:6.7b",
  "prompt": "Review this Python code: def add(a, b): return a + b",
  "stream": false
}'

# ทดสอบ List Models
curl http://localhost:11434/api/tags

# ทดสอบด้วย Python
python3 -c "
import requests
import json

response = requests.post('http://localhost:11434/api/generate', json={
    'model': 'deepseek-coder:6.7b',
    'prompt': 'What is 2+2?',
    'stream': False
})
print(response.json())
"

# .gitlab-ci.yml - GitLab CI/CD Pipeline for AI Code Review
# ตั้งชื่อ pipeline และกำหนด variables
variables:
  OLLAMA_HOST: "http://your-ollama-server:11434"
  OLLAMA_MODEL: "deepseek-coder:6.7b"
  REVIEW_THRESHOLD: "70"
  # Threshold สำหรับ pass/fail (0-100)
  
# กำหนด stages
stages:
  - quality
  - security
  - best_practices
  - decision

# กำหนด default settings
default:
  image: python:3.11-slim
  before_script:
    - pip install --quiet requests python-gitlab
  retry:
    max: 2
    when:
      - script_failure

# ====================
# STAGE 1: CODE QUALITY
# ====================

code_quality_review:
  stage: quality
  script:
    - echo "🔍 Running AI Code Quality Review..."
    - python scripts/ai-review.py
      --type quality
      --ollama-host $OLLAMA_HOST
      --model $OLLAMA_MODEL
      --output quality_report.json
  artifacts:
    paths:
      - quality_report.json
    expire_in: 1 week
  allow_failure: false
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
  tags:
    - docker

# ====================
# STAGE 2: SECURITY SCAN
# ====================

security_review:
  stage: security
  script:
    - echo "🔒 Running AI Security Review..."
    - python scripts/ai-review.py
      --type security
      --ollama-host $OLLAMA_HOST
      --model $OLLAMA_MODEL
      --output security_report.json
  artifacts:
    paths:
      - security_report.json
    expire_in: 1 week
  allow_failure: false
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
  tags:
    - docker

# ====================
# STAGE 3: BEST PRACTICES
# ====================

best_practices_review:
  stage: best_practices
  script:
    - echo "📚 Running AI Best Practices Review..."
    - python scripts/ai-review.py
      --type best_practices
      --ollama-host $OLLAMA_HOST
      --model $OLLAMA_MODEL
      --output best_practices_report.json
  artifacts:
    paths:
      - best_practices_report.json
    expire_in: 1 week
  allow_failure: true
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
  tags:
    - docker

# ====================
# STAGE 4: FINAL DECISION
# ====================

ai_review_decision:
  stage: decision
  script:
    - echo "⚖️ Making final AI review decision..."
    - python scripts/review-decision.py
      --threshold $REVIEW_THRESHOLD
      --quality-report quality_report.json
      --security-report security_report.json
      --best-practices-report best_practices_report.json
  artifacts:
    paths:
      - final_review_report.json
      - review_summary.md
    expire_in: 1 month
  dependencies:
    - code_quality_review
    - security_review
    - best_practices_review
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
  tags:
    - docker

# ====================
# OPTIONAL: POST MR COMMENT
# ====================

post_mr_comment:
  stage: .post
  script:
    - echo "💬 Posting review to Merge Request..."
    - python scripts/post-mr-comment.py
      --project-id $CI_PROJECT_ID
      --mr-iid $CI_MERGE_REQUEST_IID
      --report final_review_report.json
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
  allow_failure: true
  tags:
    - docker

#!/usr/bin/env python3
"""
AI Code Review Script for GitLab CI/CD
Uses Ollama Local LLM for code analysis

Usage:
    python ai-review.py --type quality --ollama-host http://localhost:11434 --model deepseek-coder:6.7b
"""

import argparse
import json
import os
import re
import sys
import subprocess
from dataclasses import dataclass
from typing import Optional, List, Dict, Any
from pathlib import Path

import requests
from requests.exceptions import RequestException


# ====================
# PROMPTS TEMPLATES
# ====================

PROMPTS = {
    "quality": """You are an expert code reviewer specializing in code quality.
Analyze the following code changes and provide a comprehensive quality review.

Focus on:
1. Code readability and maintainability
2. Naming conventions (variables, functions, classes)
3. Code duplication (DRY principle violations)
4. Function/method length and complexity
5. Cyclomatic complexity concerns
6. Code organization and structure

CODE CHANGES TO REVIEW:
```diff
{code}
```

IMPORTANT: Respond ONLY with valid JSON in this exact format:
{{
  "score": ,
  "issues": [
    {{
      "severity": "",
      "file": "",
      "line": ,
      "message": "",
      "suggestion": ""
    }}
  ],
  "positive_points": [""],
  "summary": ""
}}""",

    "security": """You are a security expert specializing in application security.
Perform a thorough security review of the following code changes.

Focus on:
1. SQL injection vulnerabilities
2. Cross-site scripting (XSS) risks
3. Authentication and authorization issues
4. Sensitive data exposure (passwords, API keys, tokens)
5. Insecure dependencies or configurations
6. Input validation gaps
7. Path traversal vulnerabilities
8. Command injection risks

CODE CHANGES TO REVIEW:
```diff
{code}
```

IMPORTANT: Respond ONLY with valid JSON in this exact format:
{{
  "score": ,
  "vulnerabilities": [
    {{
      "severity": "",
      "type": "",
      "cwe": "",
      "file": "",
      "line": ,
      "description": "",
      "remediation": ""
    }}
  ],
  "secure_practices": [""],
  "summary": ""
}}""",

    "best_practices": """You are a software engineering expert specializing in best practices.
Review the following code changes for adherence to software engineering best practices.

Focus on:
1. SOLID principles adherence
2. Appropriate design patterns usage
3. Error handling strategies
4. Logging and monitoring practices
5. Code documentation quality
6. Testing considerations
7. API design principles
8. Dependency management

CODE CHANGES TO REVIEW:
```diff
{code}
```

IMPORTANT: Respond ONLY with valid JSON in this exact format:
{{
  "score": ,
  "recommendations": [
    {{
      "principle": "",
      "severity": "",
      "file": "",
      "line": ,
      "current": "",
      "recommended": "",
      "reason": ""
    }}
  ],
  "good_practices": [""],
  "summary": ""
}}""",

    "performance": """You are a performance optimization expert.
Analyze the following code changes for potential performance issues.

Focus on:
1. Time complexity analysis (Big O notation)
2. Memory usage patterns and potential leaks
3. Database query efficiency (N+1 problems, missing indexes)
4. Caching opportunities
5. Async/await usage and blocking operations
6. Resource management (connections, file handles)
7. Loop optimization opportunities
8. Unnecessary computations

CODE CHANGES TO REVIEW:
```diff
{code}
```

IMPORTANT: Respond ONLY with valid JSON in this exact format:
{{
  "score": ,
  "issues": [
    {{
      "severity": "",
      "type": "",
      "file": "",
      "line": ,
      "current_complexity": "",
      "suggested_complexity": "",
      "description": "",
      "optimization": ""
    }}
  ],
  "optimizations_applied": [""],
  "summary": ""
}}"""
}


# ====================
# DATA CLASSES
# ====================

@dataclass
class ReviewResult:
    """Container for review results"""
    review_type: str
    score: int
    issues: List[Dict[str, Any]]
    positive_points: List[str]
    summary: str
    raw_response: str
    duration_ms: float


# ====================
# OLLAMA CLIENT
# ====================

class OllamaClient:
    """Client for interacting with Ollama API"""
    
    def __init__(self, host: str, model: str, timeout: int = 120):
        self.host = host.rstrip('/')
        self.model = model
        self.timeout = timeout
        self.api_url = f"{self.host}/api/generate"
    
    def generate(self, prompt: str) -> Dict[str, Any]:
        """Generate response from Ollama"""
        payload = {
            "model": self.model,
            "prompt": prompt,
            "stream": False,
            "options": {
                "temperature": 0.3,  # Lower temperature for more consistent reviews
                "top_p": 0.9,
                "num_predict": 4096  # Allow longer responses
            }
        }
        
        try:
            response = requests.post(
                self.api_url,
                json=payload,
                timeout=self.timeout
            )
            response.raise_for_status()
            return response.json()
        except RequestException as e:
            raise RuntimeError(f"Ollama API error: {e}")
    
    def health_check(self) -> bool:
        """Check if Ollama server is healthy"""
        try:
            response = requests.get(f"{self.host}/api/tags", timeout=5)
            return response.status_code == 200
        except:
            return False


# ====================
# GIT OPERATIONS
# ====================

class GitHelper:
    """Helper for Git operations in CI environment"""
    
    @staticmethod
    def get_changed_files() -> List[str]:
        """Get list of changed files in the current MR/commit"""
        # Try to get from CI environment variables
        if os.environ.get('CI_MERGE_REQUEST_DIFF_BASE_SHA'):
            # Merge Request context
            base_sha = os.environ['CI_MERGE_REQUEST_DIFF_BASE_SHA']
            head_sha = os.environ['CI_COMMIT_SHA']
            cmd = f"git diff --name-only {base_sha}...{head_sha}"
        elif os.environ.get('CI_COMMIT_BEFORE_SHA'):
            # Push context
            before_sha = os.environ['CI_COMMIT_BEFORE_SHA']
            head_sha = os.environ['CI_COMMIT_SHA']
            cmd = f"git diff --name-only {before_sha}...{head_sha}"
        else:
            # Fallback: last commit
            cmd = "git diff --name-only HEAD~1 HEAD"
        
        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
        if result.returncode == 0:
            return [f for f in result.stdout.strip().split('\n') if f]
        return []
    
    @staticmethod
    def get_diff(file_path: Optional[str] = None) -> str:
        """Get git diff for code review"""
        if os.environ.get('CI_MERGE_REQUEST_DIFF_BASE_SHA'):
            base_sha = os.environ['CI_MERGE_REQUEST_DIFF_BASE_SHA']
            head_sha = os.environ['CI_COMMIT_SHA']
            if file_path:
                cmd = f"git diff {base_sha}...{head_sha} -- {file_path}"
            else:
                cmd = f"git diff {base_sha}...{head_sha}"
        elif os.environ.get('CI_COMMIT_BEFORE_SHA'):
            before_sha = os.environ['CI_COMMIT_BEFORE_SHA']
            head_sha = os.environ['CI_COMMIT_SHA']
            if file_path:
                cmd = f"git diff {before_sha}...{head_sha} -- {file_path}"
            else:
                cmd = f"git diff {before_sha}...{head_sha}"
        else:
            if file_path:
                cmd = f"git diff HEAD~1 HEAD -- {file_path}"
            else:
                cmd = "git diff HEAD~1 HEAD"
        
        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
        return result.stdout if result.returncode == 0 else ""
    
    @staticmethod
    def get_file_content(file_path: str) -> str:
        """Get content of a specific file"""
        try:
            with open(file_path, 'r', encoding='utf-8') as f:
                return f.read()
        except Exception:
            return ""


# ====================
# REVIEW ENGINE
# ====================

class CodeReviewer:
    """Main code review engine"""
    
    # File extensions to review (exclude non-code files)
    REVIEWABLE_EXTENSIONS = {
        '.py', '.js', '.ts', '.jsx', '.tsx', '.java', '.go', '.rs',
        '.php', '.rb', '.cs', '.cpp', '.c', '.h', '.swift', '.kt',
        '.scala', '.vue', '.svelte', '.sql', '.sh', '.yaml', '.yml',
        '.json', '.html', '.css', '.scss', '.sass', '.less'
    }
    
    # Files/patterns to skip
    SKIP_PATTERNS = {
        'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml',
        'poetry.lock', 'Cargo.lock', 'go.sum',
        '.min.js', '.min.css', 'dist/', 'build/', 'node_modules/'
    }
    
    def __init__(self, ollama_client: OllamaClient):
        self.ollama = ollama_client
        self.git = GitHelper()
    
    def should_review_file(self, file_path: str) -> bool:
        """Check if file should be reviewed"""
        # Check skip patterns
        for pattern in self.SKIP_PATTERNS:
            if pattern in file_path:
                return False
        
        # Check extension
        ext = Path(file_path).suffix.lower()
        return ext in self.REVIEWABLE_EXTENSIONS
    
    def review(self, review_type: str, max_files: int = 20) -> ReviewResult:
        """Perform code review"""
        import time
        
        # Get prompt template
        prompt_template = PROMPTS.get(review_type)
        if not prompt_template:
            raise ValueError(f"Unknown review type: {review_type}")
        
        # Get changed files
        changed_files = self.git.get_changed_files()
        reviewable_files = [f for f in changed_files if self.should_review_file(f)]
        
        if not reviewable_files:
            return ReviewResult(
                review_type=review_type,
                score=100,
                issues=[],
                positive_points=["No reviewable code changes found"],
                summary="No code files to review",
                raw_response="",
                duration_ms=0
            )
        
        # Limit files to prevent timeout
        reviewable_files = reviewable_files[:max_files]
        
        # Get combined diff
        diff_parts = []
        for file_path in reviewable_files:
            file_diff = self.git.get_diff(file_path)
            if file_diff:
                diff_parts.append(f"--- {file_path} ---\n{file_diff}")
        
        combined_diff = "\n\n".join(diff_parts)
        
        # Truncate if too long
        max_chars = 15000
        if len(combined_diff) > max_chars:
            combined_diff = combined_diff[:max_chars] + "\n... [truncated]"
        
        # Build prompt
        prompt = prompt_template.format(code=combined_diff)
        
        # Call Ollama
        start_time = time.time()
        response = self.ollama.generate(prompt)
        duration_ms = (time.time() - start_time) * 1000
        
        # Parse response
        raw_response = response.get('response', '')
        parsed = self._parse_response(raw_response)
        
        return ReviewResult(
            review_type=review_type,
            score=parsed.get('score', 50),
            issues=parsed.get('issues', parsed.get('vulnerabilities', parsed.get('recommendations', []))),
            positive_points=parsed.get('positive_points', parsed.get('secure_practices', parsed.get('good_practices', parsed.get('optimizations_applied', [])))),
            summary=parsed.get('summary', 'Review completed'),
            raw_response=raw_response,
            duration_ms=duration_ms
        )
    
    def _parse_response(self, response: str) -> Dict[str, Any]:
        """Parse AI response to extract JSON"""
        # Try direct JSON parse
        try:
            return json.loads(response)
        except json.JSONDecodeError:
            pass
        
        # Try to find JSON in response
        json_patterns = [
            r'\{[\s\S]*\}',  # Full JSON object
            r'```json\s*([\s\S]*?)\s*```',  # JSON in code block
            r'```\s*([\s\S]*?)\s*```'  # Any code block
        ]
        
        for pattern in json_patterns:
            match = re.search(pattern, response)
            if match:
                try:
                    json_str = match.group(1) if '```' in pattern else match.group()
                    return json.loads(json_str)
                except (json.JSONDecodeError, IndexError):
                    continue
        
        # Fallback: try to extract score
        score_match = re.search(r'"?score"?\s*[:=]\s*(\d+)', response)
        score = int(score_match.group(1)) if score_match else 50
        
        return {
            "score": score,
            "issues": [],
            "positive_points": [],
            "summary": "Could not parse full AI response. Manual review recommended."
        }


# ====================
# OUTPUT FORMATTERS
# ====================

def format_console_output(result: ReviewResult) -> str:
    """Format result for console output"""
    lines = []
    
    # Header
    lines.append(f"\n{'='*60}")
    lines.append(f"🤖 AI {result.review_type.upper()} REVIEW")
    lines.append(f"{'='*60}")
    
    # Score with emoji
    if result.score >= 80:
        emoji = "🟢"
        status = "EXCELLENT"
    elif result.score >= 70:
        emoji = "🟢"
        status = "GOOD"
    elif result.score >= 50:
        emoji = "🟡"
        status = "NEEDS IMPROVEMENT"
    else:
        emoji = "🔴"
        status = "POOR"
    
    lines.append(f"\n{emoji} Score: {result.score}/100 ({status})")
    lines.append(f"⏱️  Duration: {result.duration_ms:.0f}ms")
    
    # Issues
    if result.issues:
        lines.append(f"\n📋 Issues Found: {len(result.issues)}")
        for i, issue in enumerate(result.issues[:10], 1):  # Limit to 10
            severity = issue.get('severity', 'unknown')
            sev_emoji = {"critical": "🔴", "high": "🟠", "medium": "🟡", "low": "🟢"}.get(severity, "⚪")
            lines.append(f"\n  {i}. {sev_emoji} [{severity.upper()}] {issue.get('file', 'unknown')}")
            if issue.get('line'):
                lines.append(f"     Line: {issue['line']}")
            msg = issue.get('message', issue.get('description', 'No description'))
            lines.append(f"     {msg[:100]}...")
    
    # Positive points
    if result.positive_points:
        lines.append(f"\n✅ Positive Points:")
        for point in result.positive_points[:5]:
            lines.append(f"  • {point}")
    
    # Summary
    lines.append(f"\n📝 Summary:")
    lines.append(f"  {result.summary}")
    
    lines.append(f"\n{'='*60}\n")
    
    return "\n".join(lines)


def format_json_output(result: ReviewResult) -> str:
    """Format result as JSON"""
    return json.dumps({
        "review_type": result.review_type,
        "score": result.score,
        "issues": result.issues,
        "positive_points": result.positive_points,
        "summary": result.summary,
        "duration_ms": result.duration_ms,
        "timestamp": os.environ.get('CI_JOB_STARTED_AT', ''),
        "commit_sha": os.environ.get('CI_COMMIT_SHA', ''),
        "branch": os.environ.get('CI_COMMIT_REF_NAME', '')
    }, indent=2)


# ====================
# MAIN
# ====================

def main():
    parser = argparse.ArgumentParser(description='AI Code Review using Ollama')
    parser.add_argument('--type', '-t', 
                        choices=['quality', 'security', 'best_practices', 'performance'],
                        required=True,
                        help='Type of review to perform')
    parser.add_argument('--ollama-host', '-H',
                        default=os.environ.get('OLLAMA_HOST', 'http://localhost:11434'),
                        help='Ollama server URL')
    parser.add_argument('--model', '-m',
                        default=os.environ.get('OLLAMA_MODEL', 'deepseek-coder:6.7b'),
                        help='Ollama model to use')
    parser.add_argument('--output', '-o',
                        help='Output file for JSON report')
    parser.add_argument('--timeout', type=int, default=120,
                        help='API timeout in seconds')
    parser.add_argument('--max-files', type=int, default=20,
                        help='Maximum files to review')
    parser.add_argument('--verbose', '-v', action='store_true',
                        help='Enable verbose output')
    
    args = parser.parse_args()
    
    print(f"🦙 AI Code Review starting...")
    print(f"   Type: {args.type}")
    print(f"   Model: {args.model}")
    print(f"   Ollama: {args.ollama_host}")
    
    # Initialize client
    client = OllamaClient(args.ollama_host, args.model, args.timeout)
    
    # Health check
    if not client.health_check():
        print(f"❌ Error: Cannot connect to Ollama at {args.ollama_host}")
        sys.exit(1)
    
    print(f"✅ Ollama connection OK")
    
    # Initialize reviewer
    reviewer = CodeReviewer(client)
    
    # Perform review
    try:
        result = reviewer.review(args.type, args.max_files)
    except Exception as e:
        print(f"❌ Review failed: {e}")
        sys.exit(1)
    
    # Output results
    print(format_console_output(result))
    
    # Save JSON report
    json_output = format_json_output(result)
    if args.output:
        with open(args.output, 'w') as f:
            f.write(json_output)
        print(f"📄 Report saved to: {args.output}")
    
    # Exit with appropriate code
    if result.score < 50:
        print("❌ Review FAILED: Score below 50")
        sys.exit(1)
    elif result.score < 70:
        print("⚠️  Review PASSED with warnings: Score below 70")
        sys.exit(0)
    else:
        print("✅ Review PASSED")
        sys.exit(0)


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
Review Decision Script
Aggregates multiple review reports and makes pass/fail decision

Usage:
    python review-decision.py --threshold 70 --quality-report quality_report.json
"""

import argparse
import json
import sys
from pathlib import Path
from typing import Dict, List, Optional


class ReviewDecision:
    """Aggregate review results and make decision"""
    
    # Weights for different review types
    WEIGHTS = {
        'quality': 0.3,
        'security': 0.4,  # Security has highest weight
        'best_practices': 0.2,
        'performance': 0.1
    }
    
    def __init__(self, threshold: int = 70):
        self.threshold = threshold
        self.reports: Dict[str, dict] = {}
    
    def load_report(self, review_type: str, file_path: str) -> bool:
        """Load a review report from file"""
        try:
            with open(file_path, 'r') as f:
                self.reports[review_type] = json.load(f)
            return True
        except (FileNotFoundError, json.JSONDecodeError) as e:
            print(f"⚠️  Could not load {review_type} report: {e}")
            return False
    
    def calculate_weighted_score(self) -> float:
        """Calculate weighted average score"""
        total_weight = 0
        weighted_sum = 0
        
        for review_type, weight in self.WEIGHTS.items():
            if review_type in self.reports:
                score = self.reports[review_type].get('score', 50)
                weighted_sum += score * weight
                total_weight += weight
        
        if total_weight == 0:
            return 0
        
        return weighted_sum / total_weight
    
    def get_critical_issues(self) -> List[dict]:
        """Get all critical/high severity issues"""
        critical = []
        for review_type, report in self.reports.items():
            issues = report.get('issues', report.get('vulnerabilities', report.get('recommendations', [])))
            for issue in issues:
                severity = issue.get('severity', '').lower()
                if severity in ('critical', 'high'):
                    critical.append({
                        'type': review_type,
                        **issue
                    })
        return critical
    
    def make_decision(self) -> dict:
        """Make final pass/fail decision"""
        weighted_score = self.calculate_weighted_score()
        critical_issues = self.get_critical_issues()
        
        # Decision logic
        passed = True
        reasons = []
        
        # Check weighted score
        if weighted_score < self.threshold:
            passed = False
            reasons.append(f"Weighted score ({weighted_score:.1f}) below threshold ({self.threshold})")
        
        # Check for critical security issues (auto-fail)
        security_critical = [i for i in critical_issues if i.get('type') == 'security' and i.get('severity') == 'critical']
        if security_critical:
            passed = False
            reasons.append(f"Found {len(security_critical)} critical security vulnerabilities")
        
        # Check for too many high severity issues
        high_issues = [i for i in critical_issues if i.get('severity') == 'high']
        if len(high_issues) > 5:
            passed = False
            reasons.append(f"Too many high severity issues ({len(high_issues)})")
        
        return {
            'passed': passed,
            'weighted_score': round(weighted_score, 1),
            'threshold': self.threshold,
            'reasons': reasons,
            'critical_issues_count': len(critical_issues),
            'reports_summary': {
                rtype: {
                    'score': report.get('score'),
                    'issues_count': len(report.get('issues', report.get('vulnerabilities', [])))
                }
                for rtype, report in self.reports.items()
            }
        }


def generate_summary_markdown(decision: dict) -> str:
    """Generate markdown summary for GitLab"""
    lines = []
    
    # Header
    status_emoji = "✅" if decision['passed'] else "❌"
    lines.append(f"# {status_emoji} AI Code Review Decision")
    lines.append("")
    
    # Result
    result_text = "PASSED" if decision['passed'] else "FAILED"
    lines.append(f"## Result: **{result_text}**")
    lines.append("")
    
    # Score
    score = decision['weighted_score']
    threshold = decision['threshold']
    score_emoji = "🟢" if score >= 80 else "🟡" if score >= 60 else "🔴"
    lines.append(f"### {score_emoji} Weighted Score: {score}/100 (threshold: {threshold})")
    lines.append("")
    
    # Reports summary
    lines.append("### 📊 Review Breakdown")
    lines.append("")
    lines.append("| Review Type | Score | Issues |")
    lines.append("|-------------|-------|--------|")
    for rtype, summary in decision['reports_summary'].items():
        lines.append(f"| {rtype.replace('_', ' ').title()} | {summary['score']} | {summary['issues_count']} |")
    lines.append("")
    
    # Reasons if failed
    if decision['reasons']:
        lines.append("### ⚠️ Failure Reasons")
        lines.append("")
        for reason in decision['reasons']:
            lines.append(f"- {reason}")
        lines.append("")
    
    # Critical issues
    if decision['critical_issues_count'] > 0:
        lines.append(f"### 🔴 Critical/High Issues: {decision['critical_issues_count']}")
        lines.append("")
        lines.append("> Please review the detailed reports for more information.")
        lines.append("")
    
    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description='Make review decision')
    parser.add_argument('--threshold', '-t', type=int, default=70,
                        help='Pass threshold (0-100)')
    parser.add_argument('--quality-report', help='Quality review report')
    parser.add_argument('--security-report', help='Security review report')
    parser.add_argument('--best-practices-report', help='Best practices report')
    parser.add_argument('--performance-report', help='Performance review report')
    
    args = parser.parse_args()
    
    decision_maker = ReviewDecision(args.threshold)
    
    # Load available reports
    if args.quality_report:
        decision_maker.load_report('quality', args.quality_report)
    if args.security_report:
        decision_maker.load_report('security', args.security_report)
    if args.best_practices_report:
        decision_maker.load_report('best_practices', args.best_practices_report)
    if args.performance_report:
        decision_maker.load_report('performance', args.performance_report)
    
    # Make decision
    decision = decision_maker.make_decision()
    
    # Output JSON
    with open('final_review_report.json', 'w') as f:
        json.dump(decision, f, indent=2)
    
    # Output markdown summary
    summary = generate_summary_markdown(decision)
    with open('review_summary.md', 'w') as f:
        f.write(summary)
    
    # Console output
    print(summary)
    
    # Exit code
    sys.exit(0 if decision['passed'] else 1)


if __name__ == '__main__':
    main()