anvil-dev-framework 0.1.6

package/global/lib/gate_logger.py

@@ -0,0 +1,316 @@
+#!/usr/bin/env python3
+"""
+gate_logger.py - Stop Gate Event Logging (ANV-155)
+
+Logs all verification gate events for debugging and audit purposes.
+Events are written to .claude/logs/stop_gate.log.
+
+Usage:
+    from gate_logger import GateLogger
+
+    logger = GateLogger()
+    logger.log_gate_trigger()
+    logger.log_check_result("tests", passed=True, count=47)
+    logger.log_gate_result(passed=True)
+"""
+
+import json
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional
+
+
+@dataclass
+class GateEvent:
+    """A single gate event."""
+    timestamp: str
+    level: Literal["INFO", "WARN", "ERROR", "OK"]
+    event_type: str
+    message: str
+    details: Dict[str, Any] = field(default_factory=dict)
+
+    def to_log_line(self) -> str:
+        """Format as log line."""
+        base = f"[{self.timestamp}] [{self.level}] {self.event_type}: {self.message}"
+        if self.details:
+            base += f" | {json.dumps(self.details)}"
+        return base
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "timestamp": self.timestamp,
+            "level": self.level,
+            "event_type": self.event_type,
+            "message": self.message,
+            "details": self.details,
+        }
+
+
+class GateLogger:
+    """Logger for stop gate events."""
+
+    DEFAULT_LOG_FILE = ".claude/logs/stop_gate.log"
+    MAX_LOG_SIZE = 1024 * 1024  # 1MB
+    MAX_LOG_FILES = 5
+
+    def __init__(
+        self,
+        log_file: Optional[str] = None,
+        project_root: Optional[Path] = None,
+    ):
+        self.project_root = project_root or Path.cwd()
+        self.log_file = self.project_root / (log_file or self.DEFAULT_LOG_FILE)
+        self.session_events: List[GateEvent] = []
+
+    def _ensure_log_dir(self) -> None:
+        """Ensure log directory exists."""
+        self.log_file.parent.mkdir(parents=True, exist_ok=True)
+
+    def _rotate_if_needed(self) -> None:
+        """Rotate log file if too large."""
+        if not self.log_file.exists():
+            return
+
+        if self.log_file.stat().st_size < self.MAX_LOG_SIZE:
+            return
+
+        # Rotate existing files
+        for i in range(self.MAX_LOG_FILES - 1, 0, -1):
+            old_file = self.log_file.with_suffix(f".log.{i}")
+            new_file = self.log_file.with_suffix(f".log.{i + 1}")
+            if old_file.exists():
+                if i + 1 >= self.MAX_LOG_FILES:
+                    old_file.unlink()
+                else:
+                    old_file.rename(new_file)
+
+        # Rotate current file
+        self.log_file.rename(self.log_file.with_suffix(".log.1"))
+
+    def _timestamp(self) -> str:
+        """Get current timestamp in ISO format."""
+        return datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    def _write_event(self, event: GateEvent) -> None:
+        """Write event to log file."""
+        self._ensure_log_dir()
+        self._rotate_if_needed()
+
+        with open(self.log_file, "a") as f:
+            f.write(event.to_log_line() + "\n")
+
+        self.session_events.append(event)
+
+    def log(
+        self,
+        level: Literal["INFO", "WARN", "ERROR", "OK"],
+        event_type: str,
+        message: str,
+        details: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Log a gate event."""
+        event = GateEvent(
+            timestamp=self._timestamp(),
+            level=level,
+            event_type=event_type,
+            message=message,
+            details=details or {},
+        )
+        self._write_event(event)
+
+    # ==========================================================================
+    # Convenience Methods
+    # ==========================================================================
+
+    def log_gate_trigger(self, reason: str = "stop_event") -> None:
+        """Log that the gate was triggered."""
+        self.log("INFO", "GATE_TRIGGER", f"Stop gate triggered: {reason}")
+
+    def log_config(
+        self,
+        require_verification: bool,
+        force_exit: bool,
+        project_type: str,
+    ) -> None:
+        """Log gate configuration."""
+        self.log(
+            "INFO",
+            "CONFIG",
+            "Gate config loaded",
+            {
+                "require_verification": require_verification,
+                "force_exit": force_exit,
+                "project_type": project_type,
+            },
+        )
+
+    def log_check_start(self, check_type: str) -> None:
+        """Log start of a verification check."""
+        self.log("INFO", "CHECK_START", f"Starting {check_type} check")
+
+    def log_check_result(
+        self,
+        check_type: str,
+        passed: bool,
+        count: Optional[int] = None,
+        error_count: Optional[int] = None,
+        duration_ms: Optional[int] = None,
+    ) -> None:
+        """Log result of a verification check."""
+        level = "OK" if passed else "ERROR"
+        status = "passed" if passed else "failed"
+
+        details: Dict[str, Any] = {"passed": passed}
+        if count is not None:
+            details["count"] = count
+        if error_count is not None:
+            details["error_count"] = error_count
+        if duration_ms is not None:
+            details["duration_ms"] = duration_ms
+
+        self.log(level, "CHECK_RESULT", f"{check_type} {status}", details)
+
+    def log_gate_result(
+        self,
+        passed: bool,
+        failing_checks: Optional[List[str]] = None,
+    ) -> None:
+        """Log final gate decision."""
+        if passed:
+            self.log("OK", "GATE_RESULT", "Gate PASSED - allowing exit")
+        else:
+            checks = ", ".join(failing_checks or ["unknown"])
+            self.log(
+                "ERROR",
+                "GATE_RESULT",
+                f"Gate BLOCKED - failures: {checks}",
+                {"failing_checks": failing_checks or []},
+            )
+
+    def log_force_exit(self, reason: str) -> None:
+        """Log force exit bypass."""
+        self.log(
+            "WARN",
+            "FORCE_EXIT",
+            "Force exit requested",
+            {"reason": reason},
+        )
+
+    def log_verification_state_used(self, status: str) -> None:
+        """Log that cached verification state was used."""
+        self.log(
+            "INFO",
+            "STATE_CACHE",
+            f"Using cached verification state: {status}",
+        )
+
+    def log_error(self, error: str, details: Optional[Dict[str, Any]] = None) -> None:
+        """Log an error."""
+        self.log("ERROR", "ERROR", error, details)
+
+    # ==========================================================================
+    # Session Summary
+    # ==========================================================================
+
+    def get_session_summary(self) -> Dict[str, Any]:
+        """Get summary of events in current session."""
+        checks_passed = []
+        checks_failed = []
+        gate_result = None
+
+        for event in self.session_events:
+            if event.event_type == "CHECK_RESULT":
+                check_type = event.message.split()[0]
+                if event.details.get("passed"):
+                    checks_passed.append(check_type)
+                else:
+                    checks_failed.append(check_type)
+            elif event.event_type == "GATE_RESULT":
+                gate_result = "passed" if "PASSED" in event.message else "blocked"
+
+        return {
+            "event_count": len(self.session_events),
+            "checks_passed": checks_passed,
+            "checks_failed": checks_failed,
+            "gate_result": gate_result,
+        }
+
+    def read_recent_events(self, count: int = 50) -> List[Dict[str, Any]]:
+        """Read recent events from log file."""
+        if not self.log_file.exists():
+            return []
+
+        try:
+            with open(self.log_file, "r") as f:
+                lines = f.readlines()
+
+            events = []
+            for line in lines[-count:]:
+                # Parse log line
+                line = line.strip()
+                if not line:
+                    continue
+
+                # Basic parsing: [timestamp] [level] event_type: message
+                try:
+                    parts = line.split("] ", 2)
+                    timestamp = parts[0][1:]
+                    level = parts[1][1:]
+                    rest = parts[2]
+                    event_type, message = rest.split(": ", 1)
+
+                    events.append({
+                        "timestamp": timestamp,
+                        "level": level,
+                        "event_type": event_type,
+                        "message": message,
+                    })
+                except (IndexError, ValueError):
+                    continue
+
+            return events
+
+        except Exception:
+            return []
+
+
+# =============================================================================
+# CLI Interface
+# =============================================================================
+
+def main():
+    """CLI entry point for gate logger."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Gate logger utility")
+    parser.add_argument("command", choices=["tail", "summary", "clear"])
+    parser.add_argument("--count", type=int, default=20, help="Number of events")
+    parser.add_argument("--project", type=str, help="Project root path")
+
+    args = parser.parse_args()
+
+    project_root = Path(args.project) if args.project else Path.cwd()
+    logger = GateLogger(project_root=project_root)
+
+    if args.command == "tail":
+        events = logger.read_recent_events(args.count)
+        for event in events:
+            level = event.get("level", "INFO")
+            msg = event.get("message", "")
+            print(f"[{level}] {msg}")
+
+    elif args.command == "summary":
+        summary = logger.get_session_summary()
+        print(json.dumps(summary, indent=2))
+
+    elif args.command == "clear":
+        if logger.log_file.exists():
+            logger.log_file.unlink()
+            print("Log file cleared")
+        else:
+            print("No log file to clear")
+
+
+if __name__ == "__main__":
+    main()

package/global/lib/github_service.py

@@ -0,0 +1,310 @@
+#!/usr/bin/env python3
+"""
+github_service.py - GitHub and CI status integration for HUD (ANV-111-113)
+
+Fetches PR and CI status using the `gh` CLI tool with caching.
+
+Usage:
+    from github_service import GitHubService
+
+    service = GitHubService()
+    status = service.get_pr_status(project_path="/path/to/repo")
+    print(status["pr_state"], status["ci_status"])
+"""
+
+import json
+import subprocess
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional, TypedDict
+
+
+class ReviewInfo(TypedDict, total=False):
+    """Information about a PR review."""
+    state: str           # APPROVED, CHANGES_REQUESTED, COMMENTED, PENDING
+    author: str          # Reviewer username
+    submitted_at: str    # ISO timestamp
+
+
+class CheckRun(TypedDict, total=False):
+    """Information about a CI check run."""
+    name: str            # Check name
+    status: str          # queued, in_progress, completed
+    conclusion: str      # success, failure, neutral, cancelled, skipped
+    url: str             # URL to check details
+
+
+class MergeQueueEntry(TypedDict, total=False):
+    """Merge queue position info."""
+    position: int                      # Position in queue
+    estimated_time_to_merge: int       # Estimated seconds until merge
+
+
+class PRStatus(TypedDict, total=False):
+    """PR and CI status information."""
+    project_path: str
+    branch: str
+    pr_number: Optional[int]
+    pr_url: str
+    pr_state: str           # OPEN, MERGED, CLOSED
+    pr_title: str
+    ci_status: str          # passed, failed, running, pending
+    ci_conclusion: str      # success, failure, etc.
+    reviews: List[ReviewInfo]
+    reviews_summary: str    # e.g., "2 approved, 1 pending"
+    check_runs: List[CheckRun]
+    merge_queue: Optional[MergeQueueEntry]
+    last_updated: float
+
+
+# Cache TTL in seconds
+CACHE_TTL = 30.0
+
+
+class GitHubService:
+    """Service for fetching GitHub PR and CI status (ANV-111-113)."""
+
+    def __init__(self):
+        """Initialize the GitHub service."""
+        self._cache: Dict[str, PRStatus] = {}
+        self._cache_timestamps: Dict[str, float] = {}
+
+    def get_pr_status(self, project_path: str, force_refresh: bool = False) -> Optional[PRStatus]:
+        """Get PR and CI status for a project.
+
+        Args:
+            project_path: Path to the git repository
+            force_refresh: Force refresh even if cache is fresh
+
+        Returns:
+            PRStatus or None if no PR exists or gh CLI not available
+        """
+        cache_key = project_path
+        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 data
+        status = self._fetch_pr_status(project_path)
+        if status:
+            self._cache[cache_key] = status
+            self._cache_timestamps[cache_key] = now
+
+        return status
+
+    def get_status_for_agents(self, agents: Dict[str, Any]) -> Dict[str, PRStatus]:
+        """Get PR status for all agent projects.
+
+        Args:
+            agents: Dictionary of agent_id -> agent data
+
+        Returns:
+            Dictionary of project_path -> PRStatus
+        """
+        results: Dict[str, PRStatus] = {}
+
+        for agent_id, agent in agents.items():
+            project = agent.get("project")
+            if project and project not in results:
+                status = self.get_pr_status(project)
+                if status:
+                    results[project] = status
+
+        return results
+
+    def _fetch_pr_status(self, project_path: str) -> Optional[PRStatus]:
+        """Fetch PR status from GitHub using gh CLI."""
+        if not Path(project_path).exists():
+            return None
+
+        # Get current branch first
+        branch = self._get_current_branch(project_path)
+        if not branch:
+            return None
+
+        try:
+            # Try to get PR for current branch
+            result = subprocess.run(
+                [
+                    "gh", "pr", "view",
+                    "--json", "number,state,title,url,reviews,statusCheckRollup,mergeQueueEntry",
+                ],
+                cwd=project_path,
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+
+            if result.returncode != 0:
+                # No PR exists for this branch
+                return {
+                    "project_path": project_path,
+                    "branch": branch,
+                    "pr_number": None,
+                    "pr_url": "",
+                    "pr_state": "NO_PR",
+                    "pr_title": "",
+                    "ci_status": "none",
+                    "ci_conclusion": "",
+                    "reviews": [],
+                    "reviews_summary": "",
+                    "check_runs": [],
+                    "merge_queue": None,
+                    "last_updated": time.time(),
+                }
+
+            data = json.loads(result.stdout)
+            return self._parse_pr_data(data, project_path, branch)
+
+        except subprocess.TimeoutExpired:
+            return None
+        except (json.JSONDecodeError, Exception):
+            return None
+
+    def _get_current_branch(self, project_path: str) -> Optional[str]:
+        """Get current git branch name."""
+        try:
+            result = subprocess.run(
+                ["git", "branch", "--show-current"],
+                cwd=project_path,
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            return result.stdout.strip() or None
+        except Exception:
+            return None
+
+    def _parse_pr_data(self, data: Dict[str, Any], project_path: str, branch: str) -> PRStatus:
+        """Parse gh CLI PR data into PRStatus."""
+        # Parse reviews
+        reviews: List[ReviewInfo] = []
+        for review in data.get("reviews", []) or []:
+            reviews.append({
+                "state": review.get("state", ""),
+                "author": review.get("author", {}).get("login", ""),
+                "submitted_at": review.get("submittedAt", ""),
+            })
+
+        # Summarize reviews
+        approved = sum(1 for r in reviews if r["state"] == "APPROVED")
+        changes_requested = sum(1 for r in reviews if r["state"] == "CHANGES_REQUESTED")
+        pending = sum(1 for r in reviews if r["state"] == "PENDING")
+
+        parts = []
+        if approved:
+            parts.append(f"{approved} approved")
+        if changes_requested:
+            parts.append(f"{changes_requested} changes requested")
+        if pending:
+            parts.append(f"{pending} pending")
+        reviews_summary = ", ".join(parts) if parts else "No reviews"
+
+        # Parse status check rollup
+        status_rollup = data.get("statusCheckRollup", []) or []
+        check_runs: List[CheckRun] = []
+        ci_status = "pending"
+        ci_conclusion = ""
+
+        for check in status_rollup:
+            typename = check.get("__typename", "")
+            if typename == "CheckRun":
+                check_runs.append({
+                    "name": check.get("name", ""),
+                    "status": check.get("status", ""),
+                    "conclusion": check.get("conclusion", ""),
+                    "url": check.get("detailsUrl", ""),
+                })
+            elif typename == "StatusContext":
+                # StatusContext state contains values like "success", "pending", "failure"
+                state = check.get("state", "")
+                check_runs.append({
+                    "name": check.get("context", ""),
+                    "status": "completed" if state and state.lower() != "pending" else "pending",
+                    "conclusion": state.lower() if state else "",
+                    "url": check.get("targetUrl", ""),
+                })
+
+        # Determine overall CI status
+        if not check_runs:
+            ci_status = "none"
+        else:
+            statuses = [c.get("status", "").lower() for c in check_runs]
+            conclusions = [c.get("conclusion", "").lower() for c in check_runs]
+
+            if "in_progress" in statuses or "queued" in statuses:
+                ci_status = "running"
+            elif all(c == "completed" for c in statuses):
+                if "failure" in conclusions or "cancelled" in conclusions:
+                    ci_status = "failed"
+                    ci_conclusion = "failure"
+                elif all(c in ("success", "skipped", "neutral") for c in conclusions if c):
+                    ci_status = "passed"
+                    ci_conclusion = "success"
+                else:
+                    ci_status = "mixed"
+
+        # Parse merge queue
+        merge_queue_data = data.get("mergeQueueEntry")
+        merge_queue: Optional[MergeQueueEntry] = None
+        if merge_queue_data:
+            merge_queue = {
+                "position": merge_queue_data.get("position", 0),
+                "estimated_time_to_merge": merge_queue_data.get("estimatedTimeToMerge", 0),
+            }
+
+        return {
+            "project_path": project_path,
+            "branch": branch,
+            "pr_number": data.get("number"),
+            "pr_url": data.get("url", ""),
+            "pr_state": data.get("state", "OPEN"),
+            "pr_title": data.get("title", ""),
+            "ci_status": ci_status,
+            "ci_conclusion": ci_conclusion,
+            "reviews": reviews,
+            "reviews_summary": reviews_summary,
+            "check_runs": check_runs,
+            "merge_queue": merge_queue,
+            "last_updated": time.time(),
+        }
+
+    def clear_cache(self) -> None:
+        """Clear cached PR status."""
+        self._cache.clear()
+        self._cache_timestamps.clear()
+
+
+# Singleton instance
+_service: Optional[GitHubService] = None
+
+
+def get_github_service() -> GitHubService:
+    """Get singleton service instance."""
+    global _service
+    if _service is None:
+        _service = GitHubService()
+    return _service
+
+
+if __name__ == "__main__":
+    # Simple test
+    import sys
+
+    project = sys.argv[1] if len(sys.argv) > 1 else "."
+    service = GitHubService()
+    status = service.get_pr_status(project)
+
+    if status:
+        print(f"Project: {status['project_path']}")
+        print(f"Branch: {status['branch']}")
+        print(f"PR: #{status.get('pr_number', 'None')} - {status['pr_state']}")
+        print(f"CI: {status['ci_status']}")
+        print(f"Reviews: {status['reviews_summary']}")
+        if status.get('merge_queue'):
+            print(f"Merge Queue: Position {status['merge_queue']['position']}")
+    else:
+        print("Could not fetch PR status")