code-mower 0.5.0b5__py3-none-any.whl

code_mower/__init__.py

@@ -0,0 +1,3 @@
+"""Code Mower package."""
+
+__version__ = "0.5.0b5"

code_mower/adapters/__init__.py

@@ -0,0 +1,39 @@
+"""SaaS reviewer adapter package."""
+
+from __future__ import annotations
+
+from importlib import import_module
+
+try:
+    from ._base import SaaSReviewerAdapter
+except ImportError:  # pragma: no cover - direct `python tools/foo.py` execution
+    try:
+        from tools.adapters._base import SaaSReviewerAdapter
+    except ImportError:
+        from adapters._base import SaaSReviewerAdapter
+
+
+def load_adapter(name: str) -> SaaSReviewerAdapter:
+    normalized = name.replace("-", "_")
+    if normalized not in {"cursor_bugbot", "greptile", "gitar", "qodo"}:
+        raise ValueError(f"unknown SaaS reviewer adapter: {name}")
+    module_roots = []
+    if __package__:
+        module_roots.append(__package__)
+    module_roots.extend(["tools.adapters", "adapters"])
+    seen_roots: set[str] = set()
+    last_missing: ModuleNotFoundError | None = None
+    for root in module_roots:
+        if root in seen_roots:
+            continue
+        seen_roots.add(root)
+        module_name = f"{root}.{normalized}"
+        try:
+            module = import_module(module_name)
+            return module.ADAPTER
+        except ModuleNotFoundError as exc:
+            if exc.name == module_name or exc.name == root.split(".", 1)[0]:
+                last_missing = exc
+                continue
+            raise
+    raise ValueError(f"unknown SaaS reviewer adapter: {name}") from last_missing

code_mower/adapters/_base.py

@@ -0,0 +1,148 @@
+"""Base contract for SaaS reviewer labeler adapters."""
+
+from __future__ import annotations
+
+import os
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+
+class SaaSReviewerAdapter(ABC):
+    """Interface for advisory SaaS code-review labelers."""
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Short CLI adapter name, e.g. "greptile"."""
+
+    @property
+    @abstractmethod
+    def label_prefix(self) -> str:
+        """Audit label prefix, e.g. "greptile-audit"."""
+
+    @property
+    @abstractmethod
+    def bot_usernames(self) -> frozenset[str]:
+        """Default trusted bot author logins."""
+
+    @property
+    @abstractmethod
+    def bot_authors_env_var(self) -> str:
+        """Optional comma-separated override env var for bot authors."""
+
+    @property
+    @abstractmethod
+    def event_type(self) -> str:
+        """GitHub event type this adapter handles."""
+
+    @property
+    def supported_event_types(self) -> frozenset[str]:
+        event_types = {self.event_type}
+        if self.check_run_app_slugs or self.check_run_names:
+            event_types.add("check_run")
+        return frozenset(event_types)
+
+    @property
+    def needs_label(self) -> str:
+        return f"needs-{self.label_prefix}"
+
+    @property
+    def done_label(self) -> str:
+        return f"{self.label_prefix}-done"
+
+    @property
+    def blocked_label(self) -> str:
+        return f"{self.label_prefix}-blocked"
+
+    @property
+    def opt_in_required(self) -> bool:
+        return False
+
+    @property
+    def opt_in_label_names(self) -> frozenset[str]:
+        return frozenset()
+
+    @property
+    def opt_in_label_prefixes(self) -> frozenset[str]:
+        return frozenset()
+
+    @property
+    def informational_only(self) -> bool:
+        return True
+
+    @property
+    def requires_review_comments(self) -> bool:
+        return False
+
+    @property
+    def review_comments_page_cap(self) -> int:
+        return 50
+
+    @property
+    def token_env_vars(self) -> tuple[str, ...]:
+        return ("GITHUB_TOKEN",)
+
+    @property
+    def check_run_app_slugs(self) -> frozenset[str]:
+        return frozenset()
+
+    @property
+    def check_run_names(self) -> frozenset[str]:
+        return frozenset()
+
+    @property
+    def check_run_done_requires_absent_same_head_review(self) -> bool:
+        return False
+
+    def same_head_review_exists_reason(self) -> str:
+        return (
+            f"check_run success ignored: {self.name} PR review already exists "
+            "for this head; review event owns the verdict"
+        )
+
+    def review_lookup_failed_reason(self, exc: Exception) -> str:
+        return f"could not verify absence of same-head {self.name} PR review: {exc}"
+
+    def review_authors(self) -> frozenset[str]:
+        raw_authors = os.environ.get(self.bot_authors_env_var) or ",".join(
+            sorted(self.bot_usernames)
+        )
+        return frozenset(
+            author.strip().lower() for author in raw_authors.split(",") if author.strip()
+        )
+
+    def is_review_author(self, login: str) -> bool:
+        return login.lower() in self.review_authors()
+
+    def is_check_run_author(self, check_run: dict[str, Any]) -> bool:
+        app = check_run.get("app") or {}
+        slug = str(app.get("slug") or "").lower()
+        return bool(slug and slug in self.check_run_app_slugs)
+
+    def is_check_run_name(self, check_run: dict[str, Any]) -> bool:
+        allowed = self.check_run_names
+        if not allowed:
+            return False
+        return str(check_run.get("name") or "").strip().lower() in allowed
+
+    def is_opted_in(self, labels: list[str]) -> bool:
+        if not self.opt_in_required:
+            return True
+        label_set = set(labels)
+        if label_set & self.opt_in_label_names:
+            return True
+        return any(
+            label.startswith(prefix)
+            for label in label_set
+            for prefix in self.opt_in_label_prefixes
+        )
+
+    @abstractmethod
+    def classify_verdict(self, event: dict[str, Any], **kwargs: Any) -> Optional[str]:
+        """Return "done", "blocked", "needs", or None for no adapter verdict."""
+
+    def extract_stale_head_info(self, event: dict[str, Any]) -> tuple[Optional[str], bool]:
+        return None, False
+
+    def label_reason(self, status: str, event: dict[str, Any], **kwargs: Any) -> str:
+        return f"{self.name} verdict: {status}"

code_mower/adapters/cursor_bugbot.py

@@ -0,0 +1,97 @@
+"""Cursor BugBot adapter for the generic SaaS reviewer labeler.
+
+BugBot is currently treated as an informational, manually triggered lane. This
+adapter is intentionally conservative: the disabled-repository response is
+classified as needing setup, an explicit no-bugs response can mark the lane
+done, and all other trusted BugBot comments fail closed to ``needs`` until
+real enabled-output examples are captured and calibrated.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Optional
+
+try:
+    from ._base import SaaSReviewerAdapter
+except ImportError:  # pragma: no cover - direct `python tools/foo.py` execution
+    try:
+        from tools.adapters._base import SaaSReviewerAdapter
+    except ImportError:
+        from adapters._base import SaaSReviewerAdapter
+
+
+_DISABLED_RE = re.compile(r"\bBugbot is disabled for this repository\b", re.IGNORECASE)
+_NO_BUGS_RE = re.compile(
+    r"\A\s*(?:BugBot\s+)?(?:no\s+(?:bugs?|issues?)\s+(?:were\s+)?found|found\s+no\s+(?:bugs?|issues?))"
+    r"(?:\s+(?:in|for)\s+this\s+(?:pull\s+request|pr))?[.!]?\s*\Z",
+    re.IGNORECASE,
+)
+_FINDING_HINT_RE = re.compile(
+    r"\b(?:found\s+[1-9]\d*\s+(?:bugs?|issues?|findings?)|"
+    r"(?:bug|issue|finding|severity)\s*[:#]|changes\s+requested|p[0-3]\b)",
+    re.IGNORECASE,
+)
+
+
+def classify_cursor_bugbot_comment(comment_body: str) -> tuple[Optional[str], str]:
+    if _DISABLED_RE.search(comment_body):
+        return "needs", "BugBot is disabled for this repository"
+    if _NO_BUGS_RE.search(comment_body) and not _FINDING_HINT_RE.search(comment_body):
+        return "done", "BugBot reported no bugs"
+    if "bugbot" not in comment_body.lower() and "cursor" not in comment_body.lower():
+        return None, "no Cursor BugBot marker"
+    return "needs", "Cursor BugBot output shape is not calibrated yet"
+
+
+class CursorBugBotAdapter(SaaSReviewerAdapter):
+    @property
+    def name(self) -> str:
+        return "cursor_bugbot"
+
+    @property
+    def label_prefix(self) -> str:
+        return "cursor-bugbot-audit"
+
+    @property
+    def bot_usernames(self) -> frozenset[str]:
+        return frozenset({"cursor[bot]", "cursor"})
+
+    @property
+    def bot_authors_env_var(self) -> str:
+        return "CURSOR_BUGBOT_BOT_AUTHORS"
+
+    @property
+    def event_type(self) -> str:
+        return "issue_comment"
+
+    @property
+    def opt_in_required(self) -> bool:
+        return True
+
+    @property
+    def opt_in_label_names(self) -> frozenset[str]:
+        return frozenset({self.needs_label, self.done_label, self.blocked_label})
+
+    @property
+    def opt_in_label_prefixes(self) -> frozenset[str]:
+        return frozenset({"cursor-bugbot-audit-"})
+
+    @property
+    def token_env_vars(self) -> tuple[str, ...]:
+        return ("CURSOR_BUGBOT_AUDIT_LABEL_TOKEN", "GITHUB_TOKEN")
+
+    def classify_verdict(self, event: dict[str, Any], **kwargs: Any) -> Optional[str]:
+        status, _ = classify_cursor_bugbot_comment(kwargs.get("comment_body") or "")
+        return status
+
+    def label_reason(self, status: str, event: dict[str, Any], **kwargs: Any) -> str:
+        _, detail = classify_cursor_bugbot_comment(kwargs.get("comment_body") or "")
+        if status == "needs":
+            return f"Cursor BugBot needs attention ({detail})"
+        if status == "done":
+            return f"Cursor BugBot clean ({detail})"
+        return f"Cursor BugBot verdict: {status} ({detail})"
+
+
+ADAPTER = CursorBugBotAdapter()

code_mower/adapters/gitar.py

@@ -0,0 +1,111 @@
+"""Gitar adapter for the generic SaaS reviewer labeler."""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Optional
+
+try:
+    from ._base import SaaSReviewerAdapter
+except ImportError:  # pragma: no cover - direct `python tools/foo.py` execution
+    try:
+        from tools.adapters._base import SaaSReviewerAdapter
+    except ImportError:
+        from adapters._base import SaaSReviewerAdapter
+
+
+_CODE_REVIEW_LABEL_RE = re.compile(r"Code Review\s*</b>", re.IGNORECASE)
+_CODE_REVIEW_BADGE_RE = re.compile(
+    r"Code Review\s*</b>\s*<kbd[^>]*>\s*(?P<badge>.*?)\s*</kbd>",
+    re.IGNORECASE | re.DOTALL,
+)
+_CODE_FENCE_RE = re.compile(r"(`+).*?\1|~~~.*?~~~", re.DOTALL)
+
+
+def _strip_code(text: str) -> str:
+    """Blank code spans/fences so quoted badges cannot spoof verdicts."""
+    return _CODE_FENCE_RE.sub(lambda match: re.sub(r"[^\n]", " ", match.group(0)), text)
+
+
+def has_code_review_block(comment_body: str) -> bool:
+    return bool(_CODE_REVIEW_LABEL_RE.search(comment_body))
+
+
+def parse_code_review_badge(comment_body: str) -> Optional[str]:
+    match = _CODE_REVIEW_BADGE_RE.search(comment_body)
+    if not match:
+        return None
+    badge = re.sub(r"<[^>]*>", "", match.group("badge"))
+    return badge.strip()
+
+
+def classify_badge(badge: Optional[str]) -> Optional[str]:
+    if badge is None:
+        return None
+    if not badge:
+        return "needs"
+    normalized = re.sub(r"[^a-z]", "", badge.lower())
+    if normalized in {"approved", "approvedwithsuggestions"}:
+        return "done"
+    return "blocked"
+
+
+def classify_gitar_comment(comment_body: str) -> tuple[Optional[str], str]:
+    body = _strip_code(comment_body)
+    if not has_code_review_block(body):
+        return None, "no Code Review block"
+    badge = parse_code_review_badge(body)
+    if not badge:
+        return "needs", "Code Review block present but badge unparseable"
+    return classify_badge(badge), f"Code Review badge {badge!r}"
+
+
+class GitarAdapter(SaaSReviewerAdapter):
+    @property
+    def name(self) -> str:
+        return "gitar"
+
+    @property
+    def label_prefix(self) -> str:
+        return "gitar-audit"
+
+    @property
+    def bot_usernames(self) -> frozenset[str]:
+        return frozenset({"gitar-ai[bot]", "gitar-bot", "gitar-bot[bot]"})
+
+    @property
+    def bot_authors_env_var(self) -> str:
+        return "GITAR_BOT_AUTHORS"
+
+    @property
+    def event_type(self) -> str:
+        return "issue_comment"
+
+    @property
+    def opt_in_required(self) -> bool:
+        return True
+
+    @property
+    def opt_in_label_names(self) -> frozenset[str]:
+        return frozenset({self.needs_label, self.done_label, self.blocked_label})
+
+    @property
+    def opt_in_label_prefixes(self) -> frozenset[str]:
+        return frozenset({"gitar-audit-"})
+
+    @property
+    def token_env_vars(self) -> tuple[str, ...]:
+        return ("GITAR_AUDIT_LABEL_TOKEN", "GITHUB_TOKEN")
+
+    def classify_verdict(self, event: dict[str, Any], **kwargs: Any) -> Optional[str]:
+        status, _ = classify_gitar_comment(kwargs.get("comment_body") or "")
+        return status
+
+    def label_reason(self, status: str, event: dict[str, Any], **kwargs: Any) -> str:
+        _, detail = classify_gitar_comment(kwargs.get("comment_body") or "")
+        if status == "needs":
+            return f"Gitar Code Review block present but verdict was empty/unparseable ({detail})"
+        return f"Gitar verdict: {status} ({detail})"
+
+
+ADAPTER = GitarAdapter()

code_mower/adapters/greptile.py

@@ -0,0 +1,191 @@
+"""Greptile adapter for the generic SaaS reviewer labeler."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any, Optional
+
+try:
+    from ._base import SaaSReviewerAdapter
+except ImportError:  # pragma: no cover - direct `python tools/foo.py` execution
+    try:
+        from tools.adapters._base import SaaSReviewerAdapter
+    except ImportError:
+        from adapters._base import SaaSReviewerAdapter
+
+
+_ALT_P_TAG_RE = re.compile(r'alt="P([0-3])"', flags=re.IGNORECASE)
+_BADGE_URL_RE = re.compile(
+    r"greptile-static-assets\.s3\.amazonaws\.com/badges/p([0-3])\.svg",
+    flags=re.IGNORECASE,
+)
+
+
+def severity_of(comment_body: str) -> Optional[int]:
+    """Return 0/1/2/3 if a Greptile inline comment has a P-badge."""
+    match = _ALT_P_TAG_RE.search(comment_body)
+    if match:
+        return int(match.group(1))
+    match = _BADGE_URL_RE.search(comment_body)
+    if match:
+        return int(match.group(1))
+    return None
+
+
+@dataclass(frozen=True)
+class GreptileVerdict:
+    p0_count: int = 0
+    p1_count: int = 0
+    p2_count: int = 0
+    p3_count: int = 0
+    unparsed_count: int = 0
+
+    @property
+    def total_comments(self) -> int:
+        return (
+            self.p0_count
+            + self.p1_count
+            + self.p2_count
+            + self.p3_count
+            + self.unparsed_count
+        )
+
+    @property
+    def blocker_count(self) -> int:
+        return self.p0_count + self.p1_count
+
+    def classify(self) -> str:
+        if self.unparsed_count > 0:
+            return "needs"
+        if self.blocker_count > 0:
+            return "blocked"
+        return "done"
+
+
+def parse_review_comments(comments: list[dict[str, Any]]) -> GreptileVerdict:
+    p0_count = p1_count = p2_count = p3_count = unparsed_count = 0
+    for comment in comments:
+        severity = severity_of(comment.get("body") or "")
+        if severity is None:
+            unparsed_count += 1
+        elif severity == 0:
+            p0_count += 1
+        elif severity == 1:
+            p1_count += 1
+        elif severity == 2:
+            p2_count += 1
+        elif severity == 3:
+            p3_count += 1
+    return GreptileVerdict(
+        p0_count=p0_count,
+        p1_count=p1_count,
+        p2_count=p2_count,
+        p3_count=p3_count,
+        unparsed_count=unparsed_count,
+    )
+
+
+class GreptileAdapter(SaaSReviewerAdapter):
+    @property
+    def name(self) -> str:
+        return "greptile"
+
+    @property
+    def label_prefix(self) -> str:
+        return "greptile-audit"
+
+    @property
+    def bot_usernames(self) -> frozenset[str]:
+        return frozenset({"greptile-apps", "greptile-apps[bot]"})
+
+    @property
+    def bot_authors_env_var(self) -> str:
+        return "GREPTILE_BOT_AUTHORS"
+
+    @property
+    def event_type(self) -> str:
+        return "pull_request_review"
+
+    @property
+    def opt_in_required(self) -> bool:
+        return True
+
+    @property
+    def opt_in_label_names(self) -> frozenset[str]:
+        return frozenset({self.needs_label, self.done_label, self.blocked_label})
+
+    @property
+    def opt_in_label_prefixes(self) -> frozenset[str]:
+        return frozenset({"greptile-audit-"})
+
+    @property
+    def requires_review_comments(self) -> bool:
+        return True
+
+    @property
+    def token_env_vars(self) -> tuple[str, ...]:
+        return ("GREPTILE_AUDIT_LABEL_TOKEN", "GITHUB_TOKEN")
+
+    @property
+    def check_run_app_slugs(self) -> frozenset[str]:
+        return frozenset({"greptile-apps"})
+
+    @property
+    def check_run_names(self) -> frozenset[str]:
+        return frozenset({"greptile review"})
+
+    @property
+    def check_run_done_requires_absent_same_head_review(self) -> bool:
+        return True
+
+    def classify_verdict(self, event: dict[str, Any], **kwargs: Any) -> Optional[str]:
+        check_run = kwargs.get("check_run")
+        if isinstance(check_run, dict):
+            conclusion = str(check_run.get("conclusion") or "").lower()
+            if conclusion == "success":
+                return "done"
+            if conclusion in {"failure", "timed_out", "action_required", "startup_failure"}:
+                return "blocked"
+            # Any other or unknown conclusion fails closed to needs.
+            return "needs"
+        return parse_review_comments(kwargs.get("review_comments") or []).classify()
+
+    def extract_stale_head_info(self, event: dict[str, Any]) -> tuple[Optional[str], bool]:
+        review = event.get("review") or {}
+        return review.get("commit_id") or None, True
+
+    def label_reason(self, status: str, event: dict[str, Any], **kwargs: Any) -> str:
+        check_run = kwargs.get("check_run")
+        if isinstance(check_run, dict):
+            conclusion = str(check_run.get("conclusion") or "unknown")
+            head_sha = str(check_run.get("head_sha") or "")[:8]
+            suffix = f"; checked {head_sha}" if head_sha else ""
+            if status == "done":
+                return f"Greptile status check succeeded{suffix}"
+            if status == "blocked":
+                return f"Greptile status check concluded {conclusion}{suffix}"
+            return f"Greptile status check conclusion was not a final pass: {conclusion}{suffix}"
+
+        verdict = parse_review_comments(kwargs.get("review_comments") or [])
+        review_sha = ((event.get("review") or {}).get("commit_id") or "")[:8]
+        if status == "needs":
+            return (
+                f"{verdict.total_comments} inline comments present but at least one "
+                "has no recognizable P-badge (alt='P[N]' or badge URL); "
+                "Greptile output format may have drifted"
+            )
+        if status == "blocked":
+            return (
+                f"Greptile found {verdict.blocker_count} blocker(s) "
+                f"(P0={verdict.p0_count}, P1={verdict.p1_count}); "
+                f"P2={verdict.p2_count}, P3={verdict.p3_count} concerns"
+            )
+        suffix = f"; reviewed {review_sha}" if review_sha else ""
+        return (
+            f"Greptile audit clean (0 P0/P1 blockers; "
+            f"P2={verdict.p2_count}, P3={verdict.p3_count} concerns{suffix})"
+        )
+
+
+ADAPTER = GreptileAdapter()