05 - Human Validation Workflows - Approvazione e Review Processes

# Checklist automatizzata per review di codice AI
class AICodeReviewChecklist:
    """Checklist strutturata per la review di codice AI-generated"""

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

    def run_checklist(self):
        """Esegue tutti i controlli della checklist"""
        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):
        """Verifica la presenza e qualità dell'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": "Solo eccezioni generiche, servono handler specifici"}
        elif not has_try_except:
            return {"check": "Error Handling", "status": "WARN",
                    "message": "Nessun error handling presente"}
        return {"check": "Error Handling", "status": "PASS",
                "message": "Error handling adeguato"}

    def _check_hardcoded_values(self):
        """Rileva valori hardcoded che dovrebbero essere configurabili"""
        import re
        patterns = [
            r'https?://[^\s"\']+',  # URL hardcoded
            r'\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b',  # IP address
            r'port\s*=\s*\d+',      # Port hardcoded
            r'timeout\s*=\s*\d+',   # Timeout hardcoded
        ]
        issues = []
        for pattern in patterns:
            matches = re.findall(pattern, self.diff)
            issues.extend(matches)

        if issues:
            return {"check": "Hardcoded Values", "status": "FAIL",
                    "message": f"Trovati {len(issues)} valori hardcoded"}
        return {"check": "Hardcoded Values", "status": "PASS",
                "message": "Nessun valore hardcoded rilevato"}

    def _overall_recommendation(self, checks):
        """Raccomandazione finale basata sui risultati"""
        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"
      

# Configurazione approval gates per codice AI
# .github/CODEOWNERS o configurazione equivalente

# Regole di approval basate sul rischio
approval_rules:
  # Codice AI che tocca sicurezza: 2 reviewer + security team
  security_critical:
    paths:
      - "src/auth/**"
      - "src/security/**"
      - "src/crypto/**"
    required_approvals: 2
    required_teams: ["security-team"]
    ai_code_extra_review: true

  # Codice AI in aree core: 2 reviewer
  core_business:
    paths:
      - "src/services/**"
      - "src/models/**"
      - "src/api/**"
    required_approvals: 2
    required_teams: ["backend-team"]

  # Codice AI in aree meno critiche: 1 reviewer
  standard:
    paths:
      - "src/utils/**"
      - "src/components/**"
    required_approvals: 1

  # Codice di infrastruttura: team ops obbligatorio
  infrastructure:
    paths:
      - "docker/**"
      - "k8s/**"
      - ".github/workflows/**"
    required_approvals: 2
    required_teams: ["ops-team"]
      

# Automazione pre-review per PR con codice AI
class PreReviewAutomation:
    """Controlli automatici prima della review umana"""

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

    def run_pre_checks(self):
        """Esegue tutti i controlli pre-review"""
        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):
        """Verifica che il codice AI sia etichettato correttamente"""
        # I file generati da AI dovrebbero avere un 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)} file AI etichettati"
        }