anvil-dev-framework 0.1.6

package/global/lib/coderabbit_service.py

@@ -0,0 +1,314 @@
+#!/usr/bin/env python3
+"""
+coderabbit_service.py - CodeRabbit CLI integration for HUD (ANV-114-115)
+
+Wraps the CodeRabbit CLI to fetch review status for PRs.
+
+Usage:
+    from coderabbit_service import CodeRabbitService
+
+    service = CodeRabbitService()
+    status = service.get_review_status(pr_number=45, repo_path="/path/to/repo")
+    print(status["review_status"], status["issues_count"])
+"""
+
+import json
+import subprocess
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional, TypedDict
+
+
+class ReviewIssue(TypedDict, total=False):
+    """A CodeRabbit review issue."""
+    severity: str       # error, warning, suggestion
+    file: str           # File path
+    line: int           # Line number
+    message: str        # Issue message
+    resolved: bool      # Whether resolved
+
+
+class CodeRabbitStatus(TypedDict, total=False):
+    """CodeRabbit review status for a PR."""
+    pr_number: int
+    review_status: str      # reviewing, approved, changes_requested, pending
+    issues_count: int       # Total issues found
+    suggestions_count: int  # Total suggestions
+    resolved_count: int     # Resolved issues/suggestions
+    pending_count: int      # Pending issues
+    review_url: str         # Link to review
+    issues: List[ReviewIssue]
+    last_updated: float
+
+
+# Cache TTL in seconds
+CACHE_TTL = 60.0
+
+
+class CodeRabbitService:
+    """Service for fetching CodeRabbit review status (ANV-114-115)."""
+
+    def __init__(self):
+        """Initialize the CodeRabbit service."""
+        self._cache: Dict[str, CodeRabbitStatus] = {}
+        self._cache_timestamps: Dict[str, float] = {}
+        self._cli_available: Optional[bool] = None
+
+    def is_available(self) -> bool:
+        """Check if CodeRabbit CLI is available."""
+        if self._cli_available is None:
+            try:
+                result = subprocess.run(
+                    ["coderabbit", "--version"],
+                    capture_output=True,
+                    text=True,
+                    timeout=5,
+                )
+                self._cli_available = result.returncode == 0
+            except Exception:
+                self._cli_available = False
+        return self._cli_available
+
+    def get_review_status(
+        self,
+        pr_number: int,
+        repo_path: Optional[str] = None,
+        force_refresh: bool = False,
+    ) -> Optional[CodeRabbitStatus]:
+        """Get CodeRabbit review status for a PR.
+
+        Args:
+            pr_number: PR number to check
+            repo_path: Path to repository (for cwd context)
+            force_refresh: Force refresh even if cache is fresh
+
+        Returns:
+            CodeRabbitStatus or None if not available
+        """
+        cache_key = f"{repo_path or 'default'}:{pr_number}"
+        now = time.time()
+
+        # Check cache
+        if not force_refresh and cache_key in self._cache:
+            if now - self._cache_timestamps.get(cache_key, 0) < CACHE_TTL:
+                return self._cache[cache_key]
+
+        # Fetch fresh status
+        status = self._fetch_review_status(pr_number, repo_path)
+        if status:
+            self._cache[cache_key] = status
+            self._cache_timestamps[cache_key] = now
+
+        return status
+
+    def get_status_for_prs(
+        self,
+        github_status: Dict[str, Any],
+    ) -> Dict[str, CodeRabbitStatus]:
+        """Get CodeRabbit status for all PRs from GitHub status.
+
+        Args:
+            github_status: Dictionary of project_path -> GitHub PRStatus
+
+        Returns:
+            Dictionary of project_path -> CodeRabbitStatus
+        """
+        results: Dict[str, CodeRabbitStatus] = {}
+
+        for project_path, gh_status in github_status.items():
+            pr_number = gh_status.get("pr_number")
+            if pr_number:
+                status = self.get_review_status(pr_number, project_path)
+                if status:
+                    results[project_path] = status
+
+        return results
+
+    def _fetch_review_status(
+        self,
+        pr_number: int,
+        repo_path: Optional[str] = None,
+    ) -> Optional[CodeRabbitStatus]:
+        """Fetch review status from CodeRabbit CLI."""
+        if not self.is_available():
+            return self._create_unavailable_status(pr_number)
+
+        cwd = repo_path if repo_path and Path(repo_path).exists() else None
+
+        try:
+            # Try to get status via CLI
+            result = subprocess.run(
+                ["coderabbit", "status", "--pr", str(pr_number), "--json"],
+                cwd=cwd,
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+
+            if result.returncode != 0:
+                # CLI failed, return empty status
+                return self._create_pending_status(pr_number)
+
+            data = json.loads(result.stdout)
+            return self._parse_cli_output(data, pr_number)
+
+        except subprocess.TimeoutExpired:
+            return self._create_pending_status(pr_number)
+        except json.JSONDecodeError:
+            # Try parsing as prompt-only output
+            # result is guaranteed to be defined here since JSONDecodeError
+            # only happens after json.loads(result.stdout) succeeds in parsing
+            if 'result' in locals():
+                return self._parse_prompt_output(result.stdout, pr_number)
+            return self._create_pending_status(pr_number)
+        except Exception:
+            return self._create_pending_status(pr_number)
+
+    def _parse_cli_output(self, data: Dict[str, Any], pr_number: int) -> CodeRabbitStatus:
+        """Parse CodeRabbit CLI JSON output."""
+        issues: List[ReviewIssue] = []
+        issues_count = 0
+        suggestions_count = 0
+        resolved_count = 0
+
+        # Parse issues/suggestions from CLI output
+        for item in data.get("issues", []):
+            issue: ReviewIssue = {
+                "severity": item.get("severity", "suggestion"),
+                "file": item.get("file", ""),
+                "line": item.get("line", 0),
+                "message": item.get("message", ""),
+                "resolved": item.get("resolved", False),
+            }
+            issues.append(issue)
+
+            if issue["severity"] in ("error", "warning"):
+                issues_count += 1
+            else:
+                suggestions_count += 1
+
+            if issue["resolved"]:
+                resolved_count += 1
+
+        # Determine review status
+        review_status = data.get("status", "pending")
+        if review_status == "approved":
+            review_status = "approved"
+        elif issues_count > 0:
+            review_status = "changes_requested"
+        elif suggestions_count > 0:
+            review_status = "reviewing"
+        else:
+            review_status = "pending"
+
+        return {
+            "pr_number": pr_number,
+            "review_status": review_status,
+            "issues_count": issues_count,
+            "suggestions_count": suggestions_count,
+            "resolved_count": resolved_count,
+            "pending_count": issues_count + suggestions_count - resolved_count,
+            "review_url": data.get("url", ""),
+            "issues": issues,
+            "last_updated": time.time(),
+        }
+
+    def _parse_prompt_output(self, output: str, pr_number: int) -> CodeRabbitStatus:
+        """Parse CodeRabbit --prompt-only output (CR-006)."""
+        # Basic parsing of text output
+        issues_count = 0
+        suggestions_count = 0
+
+        lines = output.lower()
+        if "issue" in lines or "error" in lines or "warning" in lines:
+            # Try to count issues
+            import re
+            match = re.search(r"(\d+)\s*issue", lines)
+            if match:
+                issues_count = int(match.group(1))
+
+        if "suggestion" in lines:
+            match = re.search(r"(\d+)\s*suggestion", lines)
+            if match:
+                suggestions_count = int(match.group(1))
+
+        review_status = "pending"
+        if "approved" in lines:
+            review_status = "approved"
+        elif issues_count > 0:
+            review_status = "changes_requested"
+        elif suggestions_count > 0:
+            review_status = "reviewing"
+
+        return {
+            "pr_number": pr_number,
+            "review_status": review_status,
+            "issues_count": issues_count,
+            "suggestions_count": suggestions_count,
+            "resolved_count": 0,
+            "pending_count": issues_count + suggestions_count,
+            "review_url": "",
+            "issues": [],
+            "last_updated": time.time(),
+        }
+
+    def _create_pending_status(self, pr_number: int) -> CodeRabbitStatus:
+        """Create a pending status when review hasn't started."""
+        return {
+            "pr_number": pr_number,
+            "review_status": "pending",
+            "issues_count": 0,
+            "suggestions_count": 0,
+            "resolved_count": 0,
+            "pending_count": 0,
+            "review_url": "",
+            "issues": [],
+            "last_updated": time.time(),
+        }
+
+    def _create_unavailable_status(self, pr_number: int) -> CodeRabbitStatus:
+        """Create status when CLI is not available."""
+        return {
+            "pr_number": pr_number,
+            "review_status": "unavailable",
+            "issues_count": 0,
+            "suggestions_count": 0,
+            "resolved_count": 0,
+            "pending_count": 0,
+            "review_url": "",
+            "issues": [],
+            "last_updated": time.time(),
+        }
+
+    def clear_cache(self) -> None:
+        """Clear cached status."""
+        self._cache.clear()
+        self._cache_timestamps.clear()
+
+
+# Singleton instance
+_service: Optional[CodeRabbitService] = None
+
+
+def get_coderabbit_service() -> CodeRabbitService:
+    """Get singleton service instance."""
+    global _service
+    if _service is None:
+        _service = CodeRabbitService()
+    return _service
+
+
+if __name__ == "__main__":
+    # Simple test
+    service = CodeRabbitService()
+    print(f"CodeRabbit CLI available: {service.is_available()}")
+
+    if service.is_available():
+        import sys
+        pr_number = int(sys.argv[1]) if len(sys.argv) > 1 else 1
+        status = service.get_review_status(pr_number)
+        if status:
+            print(f"PR: #{status['pr_number']}")
+            print(f"Status: {status['review_status']}")
+            print(f"Issues: {status['issues_count']}")
+            print(f"Suggestions: {status['suggestions_count']}")