alissa-tools-github-reviewloop 0.5.0__tar.gz → 0.7.0__tar.gz

{alissa_tools_github_reviewloop-0.5.0/src/main/alissa_tools_github_reviewloop.egg-info → alissa_tools_github_reviewloop-0.7.0}/PKG-INFO

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

{alissa_tools_github_reviewloop-0.5.0 → alissa_tools_github_reviewloop-0.7.0}/src/main/alissa/tools/github/reviewloop/alissa.py

@@ -154,6 +154,48 @@ class Alissa:
         # lost its timestamp.
         return max(found, key=lambda pair: pair[0])[1]
 
+    def count_verdicts(self, task_ref: str) -> int:
+        """How many CR6 verdict envelopes are on the review task.
+
+        One envelope per completed round (CR7, append-only), so this is the
+        authoritative round count -- unlike the GitHub review count it cannot be
+        thrown off by an empty-bodied review or two reviews in one cycle. Never
+        raises: absent, empty, or malformed evidence degrades to 0 (round 1)
+        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 0
+        except Exception:  # pragma: no cover - defence in depth
+            log.exception("unexpected failure reading verdict evidence for %s", task_ref)
+            return 0
+        try:
+            return self._count_verdicts(data)
+        except Exception:  # pragma: no cover - defence in depth
+            log.exception("could not count verdict evidence for %s", task_ref)
+            return 0
+
+    @staticmethod
+    def _count_verdicts(payload: object) -> int:
+        """Count evidence items carrying a verdict envelope. Mirrors
+        `_newest_verdict`'s tolerant parsing -- one match per item at most."""
+        if not isinstance(payload, dict):
+            return 0
+        evidence = payload.get("evidence")
+        if not isinstance(evidence, list):
+            return 0
+        count = 0
+        for item in evidence:
+            if not isinstance(item, dict):
+                continue
+            for blob in (item.get("title"), item.get("markdownContent")):
+                if isinstance(blob, str) and _VERDICT_RE.search(blob):
+                    count += 1
+                    break
+        return count
+
     def enqueue_reviewer(
         self,
         *,

{alissa_tools_github_reviewloop-0.5.0 → alissa_tools_github_reviewloop-0.7.0}/src/main/alissa/tools/github/reviewloop/loop.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 
 import logging
 import re
+import secrets
 import time
 from dataclasses import dataclass
 from enum import Enum
@@ -105,9 +106,17 @@ class Decision:
 
 
 def session_name(pr: PullRequest, round_: int) -> str:
-    """tmux-safe, unique per (repo, pr, round)."""
+    """A tmux-safe reviewer session name, unique per spawn.
+
+    The `review-<repo>-pr<n>-r<round>` prefix stays human-readable, but a short
+    random nonce is appended so a re-used or miscounted round number can never
+    collide with a still-live session (a collision wedges the worker -- the
+    original 'stuck' failure). Safe to be non-deterministic: the generated name
+    is recorded in the spawn ledger and is what gets reaped / self-killed, so the
+    daemon never re-derives it.
+    """
     repo = re.sub(r"[^A-Za-z0-9-]", "-", pr.repo).strip("-").lower()
-    return f"review-{repo}-pr{pr.number}-r{round_}"
+    return f"review-{repo}-pr{pr.number}-r{round_}-{secrets.token_hex(3)}"
 
 
 class ReviewWatcher:
@@ -143,18 +152,27 @@ class ReviewWatcher:
             )
 
         my_reviews = self.github.my_reviews(owner, repo, number)
-        completed = len(my_reviews)
+
+        # The review task (CR2) is the round record: one verdict envelope per
+        # round (CR7), so counting envelopes is the authoritative "rounds
+        # completed" -- immune to the GitHub heuristics that drift. A round whose
+        # review has an empty body undercounts (round_ repeats -> the session name
+        # collides -> the worker wedges); two reviews in one cycle overcount.
+        # Fall back to the substantive-review count only before the review task
+        # exists (round 1). Looked up here (not in _spawn) because both the count
+        # and convergence need it.
+        task = self.alissa.find_review_task(owner, repo, number)
+        completed = (
+            self.alissa.count_verdicts(task.ref) if task is not None
+            else len(my_reviews)
+        )
 
         # Backstop: reap the sessions of rounds that have already landed a review
         # (the fast path is the reviewer self-killing, but it may forget). A round
         # <= completed is done; its session, if we still have it, can be killed.
         self._reap_finished(pr.full_name, number, 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)
+        converged = self._convergence_reason(my_reviews, task, pr.head_sha)
         if converged is not None:
             return Decision(Action.CONVERGED, converged, completed)
 
@@ -181,7 +199,9 @@ class ReviewWatcher:
 
         return self._spawn(pr, round_, task)
 
-    def _convergence_reason(self, my_reviews: list[Review], task: Task | None) -> str | None:
+    def _convergence_reason(
+        self, my_reviews: list[Review], task: Task | None, head_sha: str
+    ) -> str | None:
         """Why the loop is done, or None if it is not.
 
         Two independent signals, because neither alone is sufficient:
@@ -195,8 +215,26 @@ class ReviewWatcher:
           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.
+
+        BOTH are bound to the current head. An approval means "this code is
+        good", so once the implementer pushes past the reviewed commit it is
+        about old code and the next round is owed. Without this bind a stale
+        approve latches the loop shut forever -- #227: round 1 approved
+        `fa304de`, the implementer pushed `fd500fc` and re-requested (and even
+        dismissed the approve), yet the envelope still read approve and no round
+        2 was ever queued.
         """
-        if my_reviews and my_reviews[-1].state == "APPROVED":
+        if not my_reviews:
+            return None
+
+        # New commits since the newest review -> its verdict is about old code.
+        # A falsy commit_id (older records lack one) can't be checked, so it
+        # falls through rather than blocking convergence.
+        newest = my_reviews[-1]
+        if newest.commit_id and newest.commit_id != head_sha:
+            return None
+
+        if newest.state == "APPROVED":
             return "last GitHub review state is APPROVED"
 
         # Only checkable once a review task exists; before that there is

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

@@ -0,0 +1 @@
+0.7.0

{alissa_tools_github_reviewloop-0.5.0 → alissa_tools_github_reviewloop-0.7.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.5.0
+Version: 0.7.0
 Summary: ALISSA-TOOLS-GITHUB-REVIEWLOOP
 Home-page: https://alissa.app
 Author: Fahera

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

@@ -1 +0,0 @@
-0.5.0