anvil-dev-framework 0.1.8 → 0.1.9

package/global/lib/coderabbit_metrics.py

@@ -0,0 +1,647 @@
+"""
+CodeRabbit Metrics Service for Anvil Framework.
+
+Provides instrumentation for tracking CodeRabbit review metrics across sessions.
+Stores metrics in SQLite for analysis by /weekly-review and HUD panels.
+
+Usage:
+    from coderabbit_metrics import CodeRabbitMetrics
+
+    metrics = CodeRabbitMetrics()
+    metrics.record_review(
+        pr_number="123",
+        issue_count=3,
+        categories={"suggestion": 2, "warning": 1},
+        review_time_seconds=45,
+    )
+    summary = metrics.get_weekly_summary()
+"""
+
+import sqlite3
+import os
+import logging
+from pathlib import Path
+from datetime import datetime, timezone, timedelta
+from typing import Optional, Dict, Any, List
+from dataclasses import dataclass, field
+from contextlib import contextmanager
+
+# Module logger
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ReviewRecord:
+    """Record of a single CodeRabbit review."""
+    id: int
+    pr_number: str
+    pr_url: Optional[str]
+    issue_count: int
+    categories: Dict[str, int]
+    review_time_seconds: float
+    reviewed_at: datetime
+    result: str  # pass, issues, error
+    branch: Optional[str]
+    issue_key: Optional[str]
+
+
+@dataclass
+class FixRecord:
+    """Record of a CodeRabbit fix application."""
+    id: int
+    pr_number: str
+    issues_fixed: int
+    issues_manual: int
+    fix_time_seconds: float
+    fixed_at: datetime
+
+
+@dataclass
+class WeeklySummary:
+    """Aggregated metrics for a week."""
+    total_reviews: int
+    total_issues_found: int
+    total_issues_fixed: int
+    avg_issues_per_review: float
+    avg_review_time_seconds: float
+    pass_rate: float  # % of reviews with 0 issues
+    category_breakdown: Dict[str, int]
+    top_issue_prs: List[Dict[str, Any]]
+    trend: str  # improving, stable, degrading
+
+
+# =============================================================================
+# Database Path
+# =============================================================================
+
+def get_db_path() -> Path:
+    """Get the database path for CodeRabbit metrics."""
+    # Use ~/.anvil/coderabbit_metrics.db for persistence across projects
+    anvil_dir = Path.home() / ".anvil"
+    anvil_dir.mkdir(parents=True, exist_ok=True)
+    return anvil_dir / "coderabbit_metrics.db"
+
+
+# =============================================================================
+# CodeRabbit Metrics Service
+# =============================================================================
+
+class CodeRabbitMetrics:
+    """Service for tracking CodeRabbit review metrics."""
+
+    def __init__(self, db_path: Optional[Path] = None):
+        """Initialize the metrics service.
+
+        Args:
+            db_path: Optional path to the database file.
+                     Defaults to ~/.anvil/coderabbit_metrics.db
+        """
+        self.db_path = db_path or get_db_path()
+        self._init_db()
+
+    @contextmanager
+    def _get_connection(self):
+        """Context manager for database connections."""
+        conn = sqlite3.connect(str(self.db_path))
+        conn.row_factory = sqlite3.Row
+        try:
+            yield conn
+        finally:
+            conn.close()
+
+    def _init_db(self):
+        """Initialize database schema."""
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+
+            # Reviews table
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS reviews (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    pr_number TEXT NOT NULL,
+                    pr_url TEXT,
+                    issue_count INTEGER NOT NULL DEFAULT 0,
+                    categories_json TEXT,
+                    review_time_seconds REAL DEFAULT 0,
+                    reviewed_at TEXT NOT NULL,
+                    result TEXT NOT NULL DEFAULT 'unknown',
+                    branch TEXT,
+                    issue_key TEXT,
+                    project_path TEXT
+                )
+            """)
+
+            # Fixes table
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS fixes (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    pr_number TEXT NOT NULL,
+                    issues_fixed INTEGER NOT NULL DEFAULT 0,
+                    issues_manual INTEGER NOT NULL DEFAULT 0,
+                    fix_time_seconds REAL DEFAULT 0,
+                    fixed_at TEXT NOT NULL,
+                    project_path TEXT
+                )
+            """)
+
+            # Index for efficient queries
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_reviews_reviewed_at
+                ON reviews(reviewed_at)
+            """)
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_fixes_fixed_at
+                ON fixes(fixed_at)
+            """)
+
+            conn.commit()
+
+    # -------------------------------------------------------------------------
+    # Recording Methods
+    # -------------------------------------------------------------------------
+
+    def record_review(
+        self,
+        pr_number: str,
+        issue_count: int,
+        categories: Optional[Dict[str, int]] = None,
+        review_time_seconds: float = 0,
+        pr_url: Optional[str] = None,
+        result: str = "unknown",
+        branch: Optional[str] = None,
+        issue_key: Optional[str] = None,
+    ) -> int:
+        """Record a CodeRabbit review.
+
+        Args:
+            pr_number: PR number (e.g., "123")
+            issue_count: Total number of issues found
+            categories: Issue breakdown by category (suggestion, warning, error)
+            review_time_seconds: Time taken for review
+            pr_url: Full GitHub PR URL
+            result: Review result (pass, issues, error)
+            branch: Git branch name
+            issue_key: Associated Linear issue key
+
+        Returns:
+            The ID of the recorded review
+        """
+        import json
+
+        categories = categories or {}
+        reviewed_at = datetime.now(timezone.utc).isoformat()
+        project_path = str(Path.cwd())
+
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT INTO reviews
+                (pr_number, pr_url, issue_count, categories_json, review_time_seconds,
+                 reviewed_at, result, branch, issue_key, project_path)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                pr_number,
+                pr_url,
+                issue_count,
+                json.dumps(categories),
+                review_time_seconds,
+                reviewed_at,
+                result,
+                branch,
+                issue_key,
+                project_path,
+            ))
+            conn.commit()
+            return cursor.lastrowid
+
+    def record_fix(
+        self,
+        pr_number: str,
+        issues_fixed: int,
+        issues_manual: int = 0,
+        fix_time_seconds: float = 0,
+    ) -> int:
+        """Record a CodeRabbit fix application.
+
+        Args:
+            pr_number: PR number
+            issues_fixed: Number of issues automatically fixed
+            issues_manual: Number of issues requiring manual fix
+            fix_time_seconds: Time taken to apply fixes
+
+        Returns:
+            The ID of the recorded fix
+        """
+        fixed_at = datetime.now(timezone.utc).isoformat()
+        project_path = str(Path.cwd())
+
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT INTO fixes
+                (pr_number, issues_fixed, issues_manual, fix_time_seconds, fixed_at, project_path)
+                VALUES (?, ?, ?, ?, ?, ?)
+            """, (
+                pr_number,
+                issues_fixed,
+                issues_manual,
+                fix_time_seconds,
+                fixed_at,
+                project_path,
+            ))
+            conn.commit()
+            return cursor.lastrowid
+
+    # -------------------------------------------------------------------------
+    # Query Methods
+    # -------------------------------------------------------------------------
+
+    def get_weekly_summary(self, weeks_ago: int = 0) -> WeeklySummary:
+        """Get summary metrics for a specific week.
+
+        Args:
+            weeks_ago: Number of weeks in the past (0 = current week)
+
+        Returns:
+            WeeklySummary with aggregated metrics
+        """
+        import json
+
+        # Calculate date range
+        now = datetime.now(timezone.utc)
+        start_of_week = now - timedelta(days=now.weekday() + (weeks_ago * 7))
+        start_of_week = start_of_week.replace(hour=0, minute=0, second=0, microsecond=0)
+        end_of_week = start_of_week + timedelta(days=7)
+
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+
+            # Get reviews for the week
+            cursor.execute("""
+                SELECT * FROM reviews
+                WHERE reviewed_at >= ? AND reviewed_at < ?
+                ORDER BY issue_count DESC
+            """, (start_of_week.isoformat(), end_of_week.isoformat()))
+
+            reviews = cursor.fetchall()
+
+            # Get fixes for the week
+            cursor.execute("""
+                SELECT SUM(issues_fixed) as total_fixed
+                FROM fixes
+                WHERE fixed_at >= ? AND fixed_at < ?
+            """, (start_of_week.isoformat(), end_of_week.isoformat()))
+
+            fixes_row = cursor.fetchone()
+            total_fixed = fixes_row["total_fixed"] or 0 if fixes_row else 0
+
+        # Calculate aggregates
+        total_reviews = len(reviews)
+        total_issues = sum(r["issue_count"] for r in reviews)
+        pass_count = sum(1 for r in reviews if r["issue_count"] == 0)
+
+        avg_issues = total_issues / total_reviews if total_reviews > 0 else 0
+        avg_time = sum(r["review_time_seconds"] for r in reviews) / total_reviews if total_reviews > 0 else 0
+        pass_rate = (pass_count / total_reviews * 100) if total_reviews > 0 else 0
+
+        # Category breakdown
+        category_breakdown: Dict[str, int] = {}
+        for review in reviews:
+            if review["categories_json"]:
+                try:
+                    cats = json.loads(review["categories_json"])
+                    for cat, count in cats.items():
+                        category_breakdown[cat] = category_breakdown.get(cat, 0) + count
+                except json.JSONDecodeError:
+                    pass
+
+        # Top issue PRs
+        top_prs = [
+            {
+                "pr_number": r["pr_number"],
+                "issue_count": r["issue_count"],
+                "branch": r["branch"],
+                "issue_key": r["issue_key"],
+            }
+            for r in reviews[:5]
+        ]
+
+        # Determine trend by comparing to previous week
+        prev_summary = self._get_basic_weekly_stats(weeks_ago + 1)
+        if prev_summary["total_reviews"] == 0:
+            trend = "new"
+        elif avg_issues < prev_summary["avg_issues"] - 0.5:
+            trend = "improving"
+        elif avg_issues > prev_summary["avg_issues"] + 0.5:
+            trend = "degrading"
+        else:
+            trend = "stable"
+
+        return WeeklySummary(
+            total_reviews=total_reviews,
+            total_issues_found=total_issues,
+            total_issues_fixed=total_fixed,
+            avg_issues_per_review=round(avg_issues, 2),
+            avg_review_time_seconds=round(avg_time, 2),
+            pass_rate=round(pass_rate, 1),
+            category_breakdown=category_breakdown,
+            top_issue_prs=top_prs,
+            trend=trend,
+        )
+
+    def _get_basic_weekly_stats(self, weeks_ago: int) -> Dict[str, Any]:
+        """Get basic stats for trend comparison."""
+        now = datetime.now(timezone.utc)
+        start_of_week = now - timedelta(days=now.weekday() + (weeks_ago * 7))
+        start_of_week = start_of_week.replace(hour=0, minute=0, second=0, microsecond=0)
+        end_of_week = start_of_week + timedelta(days=7)
+
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                SELECT COUNT(*) as count, SUM(issue_count) as total_issues
+                FROM reviews
+                WHERE reviewed_at >= ? AND reviewed_at < ?
+            """, (start_of_week.isoformat(), end_of_week.isoformat()))
+
+            row = cursor.fetchone()
+
+        total_reviews = row["count"] or 0
+        total_issues = row["total_issues"] or 0
+        avg_issues = total_issues / total_reviews if total_reviews > 0 else 0
+
+        return {
+            "total_reviews": total_reviews,
+            "total_issues": total_issues,
+            "avg_issues": avg_issues,
+        }
+
+    def get_recent_reviews(self, limit: int = 10) -> List[ReviewRecord]:
+        """Get the most recent reviews.
+
+        Args:
+            limit: Maximum number of reviews to return
+
+        Returns:
+            List of ReviewRecord objects
+        """
+        import json
+
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                SELECT * FROM reviews
+                ORDER BY reviewed_at DESC
+                LIMIT ?
+            """, (limit,))
+
+            rows = cursor.fetchall()
+
+        return [
+            ReviewRecord(
+                id=row["id"],
+                pr_number=row["pr_number"],
+                pr_url=row["pr_url"],
+                issue_count=row["issue_count"],
+                categories=json.loads(row["categories_json"]) if row["categories_json"] else {},
+                review_time_seconds=row["review_time_seconds"],
+                reviewed_at=datetime.fromisoformat(row["reviewed_at"]),
+                result=row["result"],
+                branch=row["branch"],
+                issue_key=row["issue_key"],
+            )
+            for row in rows
+        ]
+
+    def get_pr_history(self, pr_number: str) -> Dict[str, Any]:
+        """Get all reviews and fixes for a specific PR.
+
+        Args:
+            pr_number: The PR number to look up
+
+        Returns:
+            Dict with reviews and fixes lists
+        """
+        import json
+
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+
+            # Get reviews
+            cursor.execute("""
+                SELECT * FROM reviews
+                WHERE pr_number = ?
+                ORDER BY reviewed_at ASC
+            """, (pr_number,))
+            review_rows = cursor.fetchall()
+
+            # Get fixes
+            cursor.execute("""
+                SELECT * FROM fixes
+                WHERE pr_number = ?
+                ORDER BY fixed_at ASC
+            """, (pr_number,))
+            fix_rows = cursor.fetchall()
+
+        reviews = [
+            {
+                "issue_count": r["issue_count"],
+                "categories": json.loads(r["categories_json"]) if r["categories_json"] else {},
+                "result": r["result"],
+                "reviewed_at": r["reviewed_at"],
+            }
+            for r in review_rows
+        ]
+
+        fixes = [
+            {
+                "issues_fixed": f["issues_fixed"],
+                "issues_manual": f["issues_manual"],
+                "fixed_at": f["fixed_at"],
+            }
+            for f in fix_rows
+        ]
+
+        return {
+            "pr_number": pr_number,
+            "reviews": reviews,
+            "fixes": fixes,
+            "total_reviews": len(reviews),
+            "total_fixes": len(fixes),
+        }
+
+
+# =============================================================================
+# Linear Issue Automation (ANV-276)
+# =============================================================================
+
+def create_linear_issue_for_review(
+    pr_number: str,
+    issue_count: int,
+    categories: Dict[str, int],
+    pr_url: Optional[str] = None,
+    branch: Optional[str] = None,
+) -> Optional[str]:
+    """Create a Linear issue when CodeRabbit finds critical issues.
+
+    Creates an issue when:
+    - Security issues are found (always)
+    - Critical errors are found (always)
+    - More than 5 issues total (optional, based on config)
+
+    Args:
+        pr_number: PR number
+        issue_count: Total issues found
+        categories: Issue breakdown by category
+        pr_url: GitHub PR URL
+        branch: Git branch name
+
+    Returns:
+        Linear issue identifier if created, None otherwise
+    """
+    # Check if we should create an issue
+    has_security = categories.get("security", 0) > 0
+    has_critical = categories.get("critical", 0) > 0
+    high_issue_count = issue_count >= 5
+
+    if not (has_security or has_critical or high_issue_count):
+        return None
+
+    try:
+        from linear_provider import LinearProvider
+        from issue_models import IssueStatus, Priority
+    except ImportError:
+        try:
+            from .linear_provider import LinearProvider
+            from .issue_models import IssueStatus, Priority
+        except ImportError:
+            logger.warning("Linear provider not available, skipping issue creation")
+            return None
+
+    # Determine priority based on issue types
+    if has_security:
+        priority = Priority.URGENT
+        title_prefix = "🔒 Security"
+    elif has_critical:
+        priority = Priority.HIGH
+        title_prefix = "⚠️ Critical"
+    else:
+        priority = Priority.MEDIUM
+        title_prefix = "📋 Review"
+
+    # Build description
+    desc_parts = [
+        f"CodeRabbit found **{issue_count} issues** in PR #{pr_number}.",
+        "",
+        "### Issue Breakdown",
+    ]
+
+    for cat, count in categories.items():
+        desc_parts.append(f"- {cat}: {count}")
+
+    if pr_url:
+        desc_parts.extend(["", f"**PR**: [{pr_url}]({pr_url})"])
+
+    if branch:
+        desc_parts.extend(["", f"**Branch**: `{branch}`"])
+
+    desc_parts.extend([
+        "",
+        "### Next Steps",
+        "1. Review CodeRabbit comments on the PR",
+        "2. Apply fixes using `/coderabbit-fix`",
+        "3. Re-run review to verify",
+    ])
+
+    description = "\n".join(desc_parts)
+    title = f"{title_prefix}: CodeRabbit issues in PR #{pr_number}"
+
+    try:
+        # Get team from environment or use default
+        team_key = os.environ.get("LINEAR_TEAM", "ANV")
+        provider = LinearProvider(team_key=team_key)
+
+        issue = provider.create_issue(
+            title=title,
+            description=description,
+            priority=priority,
+            labels=["coderabbit", "automated"],
+        )
+
+        logger.info(f"Created Linear issue {issue.key} for PR #{pr_number}")
+        return issue.key
+    except Exception as e:
+        logger.warning(f"Failed to create Linear issue: {e}")
+        return None
+
+
+# =============================================================================
+# CLI Interface
+# =============================================================================
+
+if __name__ == "__main__":
+    import sys
+    import json as json_module
+
+    if len(sys.argv) < 2:
+        print("Usage: coderabbit_metrics.py <command> [args...]")
+        print("Commands:")
+        print("  record-review <pr> <issues> [result] - Record a review")
+        print("  record-fix <pr> <fixed> [manual]     - Record a fix")
+        print("  weekly [weeks_ago]                   - Get weekly summary")
+        print("  recent [limit]                       - Get recent reviews")
+        print("  pr-history <pr>                      - Get PR history")
+        sys.exit(1)
+
+    cmd = sys.argv[1]
+    metrics = CodeRabbitMetrics()
+
+    if cmd == "record-review":
+        if len(sys.argv) < 4:
+            print("Error: record-review requires pr and issues count")
+            sys.exit(1)
+        pr = sys.argv[2]
+        issues = int(sys.argv[3])
+        result = sys.argv[4] if len(sys.argv) > 4 else ("pass" if issues == 0 else "issues")
+        record_id = metrics.record_review(pr, issues, result=result)
+        print(f"Review recorded: ID {record_id}")
+
+    elif cmd == "record-fix":
+        if len(sys.argv) < 4:
+            print("Error: record-fix requires pr and fixed count")
+            sys.exit(1)
+        pr = sys.argv[2]
+        fixed = int(sys.argv[3])
+        manual = int(sys.argv[4]) if len(sys.argv) > 4 else 0
+        record_id = metrics.record_fix(pr, fixed, manual)
+        print(f"Fix recorded: ID {record_id}")
+
+    elif cmd == "weekly":
+        weeks_ago = int(sys.argv[2]) if len(sys.argv) > 2 else 0
+        summary = metrics.get_weekly_summary(weeks_ago)
+        print(f"Weekly Summary (week -{weeks_ago}):")
+        print(f"  Reviews: {summary.total_reviews}")
+        print(f"  Issues Found: {summary.total_issues_found}")
+        print(f"  Issues Fixed: {summary.total_issues_fixed}")
+        print(f"  Avg Issues/Review: {summary.avg_issues_per_review}")
+        print(f"  Pass Rate: {summary.pass_rate}%")
+        print(f"  Trend: {summary.trend}")
+
+    elif cmd == "recent":
+        limit = int(sys.argv[2]) if len(sys.argv) > 2 else 10
+        reviews = metrics.get_recent_reviews(limit)
+        print(f"Recent {len(reviews)} reviews:")
+        for r in reviews:
+            print(f"  PR #{r.pr_number}: {r.issue_count} issues ({r.result})")
+
+    elif cmd == "pr-history":
+        if len(sys.argv) < 3:
+            print("Error: pr-history requires pr number")
+            sys.exit(1)
+        pr = sys.argv[2]
+        history = metrics.get_pr_history(pr)
+        print(json_module.dumps(history, indent=2))
+
+    else:
+        print(f"Unknown command: {cmd}")
+        sys.exit(1)