05 - Human Validation Workflows - Approval and Review Processes

# Automated checklist for AI code review
class AICodeReviewChecklist:
    """Structured checklist for AI-generated code review"""

    def __init__(self, diff_content, project_config):
        self.diff = diff_content
        self.config = project_config
        self.findings = []

    def run_checklist(self):
        """Runs all checklist controls"""
        checks = [
            self._check_error_handling(),
            self._check_input_validation(),
            self._check_logging(),
            self._check_naming_conventions(),
            self._check_hardcoded_values(),
            self._check_test_coverage(),
            self._check_documentation(),
            self._check_security_patterns(),
            self._check_architecture_fit(),
            self._check_duplication(),
        ]
        return {
            "total_checks": len(checks),
            "passed": sum(1 for c in checks if c["status"] == "PASS"),
            "failed": sum(1 for c in checks if c["status"] == "FAIL"),
            "warnings": sum(1 for c in checks if c["status"] == "WARN"),
            "details": checks,
            "recommendation": self._overall_recommendation(checks)
        }

    def _check_error_handling(self):
        """Verifies presence and quality of error handling"""
        has_try_except = "try:" in self.diff
        has_specific_exceptions = any(
            exc in self.diff for exc in
            ["ValueError", "TypeError", "KeyError", "IOError"]
        )
        has_bare_except = "except:" in self.diff or "except Exception:" in self.diff

        if has_bare_except and not has_specific_exceptions:
            return {"check": "Error Handling", "status": "FAIL",
                    "message": "Only generic exceptions, specific handlers needed"}
        elif not has_try_except:
            return {"check": "Error Handling", "status": "WARN",
                    "message": "No error handling present"}
        return {"check": "Error Handling", "status": "PASS",
                "message": "Adequate error handling"}

    def _check_hardcoded_values(self):
        """Detects hardcoded values that should be configurable"""
        import re
        patterns = [
            r'https?://[^\s"\']+',  # Hardcoded URL
            r'\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b',  # IP address
            r'port\s*=\s*\d+',      # Hardcoded port
            r'timeout\s*=\s*\d+',   # Hardcoded timeout
        ]
        issues = []
        for pattern in patterns:
            matches = re.findall(pattern, self.diff)
            issues.extend(matches)

        if issues:
            return {"check": "Hardcoded Values", "status": "FAIL",
                    "message": f"Found {len(issues)} hardcoded values"}
        return {"check": "Hardcoded Values", "status": "PASS",
                "message": "No hardcoded values detected"}

    def _overall_recommendation(self, checks):
        """Final recommendation based on results"""
        fails = sum(1 for c in checks if c["status"] == "FAIL")
        if fails == 0:
            return "APPROVE"
        elif fails <= 2:
            return "REQUEST_CHANGES"
        else:
            return "REJECT"
      

# Approval gates configuration for AI code
# .github/CODEOWNERS or equivalent configuration

# Risk-based approval rules
approval_rules:
  # AI code touching security: 2 reviewers + security team
  security_critical:
    paths:
      - "src/auth/**"
      - "src/security/**"
      - "src/crypto/**"
    required_approvals: 2
    required_teams: ["security-team"]
    ai_code_extra_review: true

  # AI code in core areas: 2 reviewers
  core_business:
    paths:
      - "src/services/**"
      - "src/models/**"
      - "src/api/**"
    required_approvals: 2
    required_teams: ["backend-team"]

  # AI code in less critical areas: 1 reviewer
  standard:
    paths:
      - "src/utils/**"
      - "src/components/**"
    required_approvals: 1

  # Infrastructure code: ops team mandatory
  infrastructure:
    paths:
      - "docker/**"
      - "k8s/**"
      - ".github/workflows/**"
    required_approvals: 2
    required_teams: ["ops-team"]
      

# Pre-review automation for PRs with AI code
class PreReviewAutomation:
    """Automated checks before human review"""

    def __init__(self, pull_request):
        self.pr = pull_request

    def run_pre_checks(self):
        """Runs all pre-review checks"""
        results = {
            "quality_gate": self._check_quality_gate(),
            "test_coverage": self._check_coverage_threshold(),
            "security_scan": self._check_security_findings(),
            "complexity": self._check_complexity_threshold(),
            "duplication": self._check_duplication_threshold(),
            "ai_metadata": self._check_ai_code_labeling(),
        }

        all_passed = all(r["passed"] for r in results.values())
        return {
            "ready_for_review": all_passed,
            "blocking_issues": [
                k for k, v in results.items() if not v["passed"]
            ],
            "details": results
        }

    def _check_ai_code_labeling(self):
        """Verifies that AI code is properly labeled"""
        # AI-generated files should have a marker
        ai_files = self._detect_ai_generated_files()
        labeled = [f for f in ai_files if self._has_ai_label(f)]
        return {
            "passed": len(labeled) == len(ai_files),
            "message": f"{len(labeled)}/{len(ai_files)} AI files labeled"
        }