alissa-tools-github-reviewloop 0.1.0__tar.gz → 0.2.0__tar.gz

{alissa_tools_github_reviewloop-0.1.0/src/main/alissa_tools_github_reviewloop.egg-info → alissa_tools_github_reviewloop-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-reviewloop
-Version: 0.1.0
+Version: 0.2.0
 Summary: ALISSA-TOOLS-GITHUB-REVIEWLOOP
 Home-page: https://alissa.app
 Author: Fahera

{alissa_tools_github_reviewloop-0.1.0 → alissa_tools_github_reviewloop-0.2.0}/src/main/alissa/tools/github/reviewloop/alissa.py

@@ -15,10 +15,27 @@ log = logging.getLogger(__name__)
 # A review task is "open" while it can still receive a verdict.
 OPEN_STATUSES = {"committed", "in_progress", "pending_validation", "todo"}
 
+# CR6 verdict envelope outcomes.
+VERDICT_APPROVE = "approve"
+VERDICT_REQUEST_CHANGES = "request_changes"
+
+# Envelope titles and bodies both read:
+#   Review verdict: <org>/<repo>#<n> — request_changes (round 3, ...)
+#   # Review verdict: <org>/<repo>#<n> — approve
+# The separator is an em-dash in practice; en-dash and hyphen are accepted too
+# so a hand-written envelope does not silently fail to parse.
+# Kept to a single line on purpose: the verdict word sits on the same line as
+# the "Review verdict:" lead-in, so matching across newlines could only pick up
+# a later round's wording out of order.
+_VERDICT_RE = re.compile(
+    r"Review\s+verdict\s*:[^\n]*?[—–-]\s*(approve|request_changes)\b",
+    re.IGNORECASE,
+)
+
 
 @dataclass(frozen=True)
 class Task:
-    ref: str  # TASK-<seq>
+    ref: str  # TASK-<taskNumber>
     title: str
     status: str
 
@@ -40,12 +57,14 @@ class Alissa:
         data = run_json(["alissa", "task", "list", "--json"], timeout=90) or []
         tasks = []
         for row in data:
-            seq = row.get("taskSeq")
-            if seq is None:
+            # `taskNumber` is the ref the API resolves; `taskSeq` is a display
+            # ordinal and 404s as `TASK-<seq>`.
+            number = row.get("taskNumber")
+            if number is None:
                 continue
             tasks.append(
                 Task(
-                    ref=f"TASK-{seq}",
+                    ref=f"TASK-{number}",
                     title=row.get("title", ""),
                     status=row.get("status", ""),
                 )
@@ -72,6 +91,69 @@ class Alissa:
             )
         return matches[0]
 
+    def latest_verdict(self, task_ref: str) -> str | None:
+        """The newest CR6 verdict envelope on a review task, or None.
+
+        Returns VERDICT_APPROVE / VERDICT_REQUEST_CHANGES. This is the verdict
+        of record: reviewers post comment-mode reviews, so the GitHub review
+        state is always COMMENTED and cannot express approval at all.
+
+        Never raises. The daemon polls forever and this runs inside every pass,
+        so absent, empty or malformed evidence degrades to "no verdict" rather
+        than taking the loop down.
+        """
+        try:
+            data = run_json(["alissa", "task", "get", task_ref, "--json"], timeout=90)
+        except CommandError as exc:
+            log.warning("could not read verdict evidence for %s: %s", task_ref, exc)
+            return None
+        except Exception:  # pragma: no cover - defence in depth
+            log.exception("unexpected failure reading verdict evidence for %s", task_ref)
+            return None
+
+        try:
+            return self._newest_verdict(data)
+        except Exception:  # pragma: no cover - defence in depth
+            log.exception("could not parse verdict evidence for %s", task_ref)
+            return None
+
+    @staticmethod
+    def _newest_verdict(payload: object) -> str | None:
+        """Pick the newest parseable verdict out of a task's evidence array.
+
+        Every layer is optional by design -- the payload shape is whatever the
+        CLI printed, and a task with no evidence is the normal round-1 case.
+        """
+        if not isinstance(payload, dict):
+            return None
+        evidence = payload.get("evidence")
+        if not isinstance(evidence, list):
+            return None
+
+        found: list[tuple[str, str]] = []
+        for item in evidence:
+            if not isinstance(item, dict):
+                continue
+            title = item.get("title")
+            content = item.get("markdownContent")
+            for blob in (title, content):
+                if not isinstance(blob, str):
+                    continue
+                match = _VERDICT_RE.search(blob)
+                if match:
+                    created = item.get("createdAt")
+                    found.append(
+                        (created if isinstance(created, str) else "", match.group(1).lower())
+                    )
+                    break
+
+        if not found:
+            return None
+        # ISO-8601 timestamps sort lexicographically. Undated evidence sorts
+        # first (empty string), so a dated envelope always wins over one that
+        # lost its timestamp.
+        return max(found, key=lambda pair: pair[0])[1]
+
     def enqueue_reviewer(
         self,
         *,

{alissa_tools_github_reviewloop-0.1.0 → alissa_tools_github_reviewloop-0.2.0}/src/main/alissa/tools/github/reviewloop/ghclient.py

@@ -45,6 +45,17 @@ class Review:
     commit_id: str
     submitted_at: str
     url: str
+    body: str = ""
+
+    @property
+    def is_substantive(self) -> bool:
+        """A real review round, not a side effect of an inline comment.
+
+        Posting a standalone inline comment on a PR creates its own review
+        record with an empty body, so review records outnumber rounds. The
+        round-closing review always carries the verdict write-up in its body.
+        """
+        return bool(self.body.strip())
 
 
 class RateLimited(RuntimeError):
@@ -159,16 +170,34 @@ class GitHub:
                 commit_id=r.get("commit_id") or "",
                 submitted_at=r.get("submitted_at") or "",
                 url=r.get("html_url", ""),
+                body=r.get("body") or "",
             )
             for r in data
         ]
 
     def my_reviews(self, owner: str, repo: str, number: int) -> list[Review]:
-        """My submitted reviews, oldest first -- one per completed round."""
+        """My substantive submitted reviews, oldest first -- one per round.
+
+        Empty-bodied records are dropped: a standalone inline comment creates
+        its own zero-body review record, so counting raw records overcounts
+        rounds badly. On fahera-mx/studio.alissa.app#210 three real rounds
+        produced six records (round 1 plus three inline-comment artifacts, then
+        rounds 2 and 3), and round 3's reviewer was told it was "round 6 of
+        cap 10".
+
+        Do NOT dedupe by `commit_id` instead -- it looks like the natural
+        grouping key but it UNDERCOUNTS. A round reviews whatever head is
+        current, and consecutive rounds routinely land on the same commit when
+        the implementer triages findings without pushing: on #210 rounds 2 and
+        3 both carry head 805398a and would collapse into one. Body presence
+        tracks "a reviewer wrote a verdict"; commit identity does not.
+        """
         mine = [
             r
             for r in self.reviews(owner, repo, number)
-            if r.author == self.login and r.state in SUBMITTED_STATES
+            if r.author == self.login
+            and r.state in SUBMITTED_STATES
+            and r.is_substantive
         ]
         return sorted(mine, key=lambda r: r.submitted_at)
 

{alissa_tools_github_reviewloop-0.1.0 → alissa_tools_github_reviewloop-0.2.0}/src/main/alissa/tools/github/reviewloop/loop.py

@@ -2,7 +2,10 @@
 
 One pass = poll GitHub for pending review requests, decide per PR whether a
 fresh reviewer round is owed, and enqueue it. Rounds are derived from GitHub
-(one submitted review per round), not from local bookkeeping.
+(one *substantive* submitted review per round -- empty-bodied records are
+inline-comment artifacts, not rounds), not from local bookkeeping. Convergence
+comes from either the GitHub review state or the CR6 verdict envelope on the
+Alissa review task.
 """
 
 from __future__ import annotations
@@ -14,9 +17,9 @@ from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
 
-from .alissa import Alissa
+from .alissa import VERDICT_APPROVE, Alissa, Task
 from .config import HUB_ADD, ON_MISSING_SKIP, Config
-from .ghclient import GitHub, PullRequest, RateLimited
+from .ghclient import GitHub, PullRequest, RateLimited, Review
 from .proc import CommandError
 from .state import State
 
@@ -114,8 +117,13 @@ class ReviewWatcher:
         my_reviews = self.github.my_reviews(owner, repo, number)
         completed = len(my_reviews)
 
-        if my_reviews and my_reviews[-1].state == "APPROVED":
-            return Decision(Action.CONVERGED, "last verdict is approve", completed)
+        # Looked up here rather than inside _spawn: convergence needs the ref
+        # too. _spawn still handles `task is None` exactly as before.
+        task = self.alissa.find_review_task(owner, repo, number)
+
+        converged = self._convergence_reason(my_reviews, task)
+        if converged is not None:
+            return Decision(Action.CONVERGED, converged, completed)
 
         # CR9: never queue round cap+1.
         if completed >= self.config.round_cap:
@@ -138,13 +146,36 @@ class ReviewWatcher:
                 age / 60,
             )
 
-        return self._spawn(pr, round_)
+        return self._spawn(pr, round_, task)
 
-    # -- actions -----------------------------------------------------------
+    def _convergence_reason(self, my_reviews: list[Review], task: Task | None) -> str | None:
+        """Why the loop is done, or None if it is not.
+
+        Two independent signals, because neither alone is sufficient:
+
+        * The GitHub review state. Authoritative when it says APPROVED, but
+          reviewers work in comment mode, which can only ever produce
+          COMMENTED -- #210 has zero APPROVED records across its whole history.
+          On its own this made convergence unreachable: every PR, however
+          clean, ran to the round cap and escalated.
+        * The CR6 verdict envelope on the Alissa review task. The review skill
+          declares this the verdict of record, and unlike the GitHub state it
+          can actually express approval, so it is the signal that closes the
+          loop in practice.
+        """
+        if my_reviews and my_reviews[-1].state == "APPROVED":
+            return "last GitHub review state is APPROVED"
+
+        # Only checkable once a review task exists; before that there is
+        # nowhere for a verdict to have been recorded.
+        if task is not None and self.alissa.latest_verdict(task.ref) == VERDICT_APPROVE:
+            return f"newest verdict envelope on {task.ref} reads approve"
 
-    def _spawn(self, pr: PullRequest, round_: int) -> Decision:
-        task = self.alissa.find_review_task(pr.owner, pr.repo, pr.number)
+        return None
+
+    # -- actions -----------------------------------------------------------
 
+    def _spawn(self, pr: PullRequest, round_: int, task: Task | None) -> Decision:
         if task is None:
             if self.config.on_missing_review_task == ON_MISSING_SKIP:
                 return Decision(

alissa_tools_github_reviewloop-0.2.0/src/main/alissa/tools/github/reviewloop/version

@@ -0,0 +1 @@
+0.2.0

{alissa_tools_github_reviewloop-0.1.0 → alissa_tools_github_reviewloop-0.2.0/src/main/alissa_tools_github_reviewloop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-reviewloop
-Version: 0.1.0
+Version: 0.2.0
 Summary: ALISSA-TOOLS-GITHUB-REVIEWLOOP
 Home-page: https://alissa.app
 Author: Fahera

alissa_tools_github_reviewloop-0.1.0/src/main/alissa/tools/github/reviewloop/version

@@ -1 +0,0 @@
-0.1.0