alissa-tools-github-reviewloop 0.1.1__tar.gz → 0.3.0__tar.gz

{alissa_tools_github_reviewloop-0.1.1/src/main/alissa_tools_github_reviewloop.egg-info → alissa_tools_github_reviewloop-0.3.0}/PKG-INFO

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

{alissa_tools_github_reviewloop-0.1.1 → alissa_tools_github_reviewloop-0.3.0}/setup.py

@@ -49,6 +49,7 @@ setup(
     entry_points={
         "console_scripts": [
             "alissa-reviewloop=alissa.tools.github.reviewloop.__main__:main",
+            "alissa-pr-review=alissa.tools.github.reviewloop.prreview:main",
         ]
     },
     install_requires=requirements,

{alissa_tools_github_reviewloop-0.1.1 → alissa_tools_github_reviewloop-0.3.0}/src/main/alissa/tools/github/reviewloop/alissa.py

@@ -15,6 +15,23 @@ 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:
@@ -74,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.1 → alissa_tools_github_reviewloop-0.3.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.1 → alissa_tools_github_reviewloop-0.3.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.3.0/src/main/alissa/tools/github/reviewloop/prreview.py

@@ -0,0 +1,228 @@
+"""alissa-pr-review: the implementer-side driver for ONE review round.
+
+The reviewer daemon (`alissa-reviewloop`) is autonomous but only the *reviewer*
+half: a review request in, a review out. This command is the *implementer* half,
+run by the dev session that just finished the work — it fires the trigger and
+blocks on the verdict, so the loop closes without a second always-on daemon.
+
+One invocation = one round:
+
+  1. resolve the PR from the branch
+  2. flip it ready-for-review (from draft)
+  3. request the reviewer          ← this is the daemon's edge-trigger
+  4. block until a NEW review round lands, or the timeout
+
+It reads the verdict from the **review task envelope**, never from GitHub's
+review state: reviewers work in comment mode, so the GitHub state is always
+COMMENTED and cannot express approval. The round-completion signal is the
+reviewer's substantive-review count going up; the verdict word then comes from
+`Alissa.latest_verdict` — the exact logic the daemon uses, so the two halves
+cannot disagree.
+
+The triage -> fix -> re-enter loop and the round cap live in the caller (see the
+`run-the-review-loop` how-to): on `request_changes` the dev triages, fixes, and
+runs this again for round k+1.
+
+Exit codes:  0 approve · 1 request_changes · 2 timeout/no verdict · 3 usage/setup
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import re
+import sys
+import time
+
+from .alissa import Alissa, VERDICT_APPROVE, VERDICT_REQUEST_CHANGES
+from .ghclient import GitHub
+from .proc import CommandError, run, run_json
+
+log = logging.getLogger(__name__)
+
+# After a new review lands, the verdict envelope is written on the task around
+# the same moment; give it a short grace window to appear before giving up.
+_ENVELOPE_GRACE_SECONDS = 120
+
+
+def resolve_pr(branch: str | None) -> tuple[str, str, int, str, bool]:
+    """(owner, repo, number, url, is_draft) for `branch` (or the current branch).
+
+    Runs in the repo working tree, so `gh` infers the repo; the head branch
+    selects the PR. owner/repo come from the PR URL, which is the base repo.
+    """
+    argv = ["gh", "pr", "view"]
+    if branch:
+        argv.append(branch)
+    argv += ["--json", "url,number,isDraft,state"]
+    data = run_json(argv)
+    if not data:
+        raise ValueError(
+            f"no pull request found for {'branch ' + branch if branch else 'the current branch'}"
+        )
+    url = data.get("url", "")
+    match = re.search(r"github\.com/([\w.-]+)/([\w.-]+)/pull/(\d+)", url)
+    if not match:
+        raise ValueError(f"could not parse owner/repo from PR url {url!r}")
+    if data.get("state") not in (None, "OPEN"):
+        raise ValueError(f"PR {url} is {data.get('state')}, not open — nothing to review")
+    return match.group(1), match.group(2), int(match.group(3)), url, bool(data.get("isDraft"))
+
+
+def _review_task_ref(alissa: Alissa, owner: str, repo: str, number: int) -> str | None:
+    """The CR2 review task for this PR, by title, regardless of status.
+
+    Deliberately not `Alissa.find_review_task` (which filters to open tasks): we
+    still want the ref just after the task is validated, to read its verdict.
+    """
+    pattern = re.compile(
+        rf"^Review PR\s+{re.escape(owner)}/{re.escape(repo)}#{number}\b", re.IGNORECASE
+    )
+    matches = [t for t in alissa.list_tasks() if pattern.match(t.title)]
+    return matches[0].ref if matches else None
+
+
+def _reviewer_review_count(gh: GitHub, owner: str, repo: str, number: int, reviewer: str) -> int:
+    """Substantive reviews the reviewer has submitted — one per completed round.
+
+    Same 'substantive' rule the daemon counts by (empty-bodied inline-comment
+    artifacts don't close a round), so a fresh round is a clean +1 edge.
+    """
+    return sum(
+        1
+        for r in gh.reviews(owner, repo, number)
+        if r.author == reviewer and r.is_substantive
+    )
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="alissa-pr-review",
+        description="Implementer-side: flip a PR ready, request a reviewer, and "
+        "block until the review verdict lands (one round of the adversarial loop).",
+    )
+    p.add_argument(
+        "--reviewer",
+        required=True,
+        metavar="LOGIN",
+        help="GitHub login to request review from (e.g. alissa-app)",
+    )
+    p.add_argument(
+        "--branch",
+        metavar="NAME",
+        help="head branch of the PR (default: the current branch)",
+    )
+    p.add_argument(
+        "--timeout",
+        type=int,
+        default=2700,
+        metavar="SECONDS",
+        help="give up waiting after this long (default: 2700 = 45 min)",
+    )
+    p.add_argument(
+        "--poll-interval",
+        type=int,
+        default=30,
+        metavar="SECONDS",
+        help="seconds between checks (default: 30)",
+    )
+    p.add_argument("-v", "--verbose", action="store_true")
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    logging.basicConfig(
+        level=logging.DEBUG if args.verbose else logging.INFO,
+        format="%(asctime)s %(levelname)-7s %(message)s",
+        datefmt="%H:%M:%S",
+    )
+
+    gh = GitHub()
+    alissa = Alissa()
+
+    try:
+        # Identity guard: GitHub forbids requesting review from the PR author, so
+        # the dev's gh token must not be the reviewer.
+        dev = gh.token_login()
+        if dev == args.reviewer:
+            print(
+                f"identity error: the gh token belongs to {dev!r}, the same as "
+                f"--reviewer. GitHub forbids requesting review from the PR author; "
+                f"run this as a different account than the reviewer.",
+                file=sys.stderr,
+            )
+            return 3
+
+        owner, repo, number, url, is_draft = resolve_pr(args.branch)
+        slug = f"{owner}/{repo}#{number}"
+        log.info("PR %s (%s), reviewing as reviewer=%s, dev=%s", slug, url, args.reviewer, dev)
+
+        if is_draft:
+            log.info("flipping %s ready-for-review", slug)
+            run(["gh", "pr", "ready", str(number)])
+
+        before = _reviewer_review_count(gh, owner, repo, number, args.reviewer)
+        log.info("requesting review from %s (round %d)", args.reviewer, before + 1)
+        run(["gh", "pr", "edit", str(number), "--add-reviewer", args.reviewer])
+
+        deadline = time.time() + args.timeout
+        ref: str | None = None
+        round_landed_at: float | None = None
+
+        while time.time() < deadline:
+            time.sleep(args.poll_interval)
+
+            if round_landed_at is None:
+                now = _reviewer_review_count(gh, owner, repo, number, args.reviewer)
+                if now > before:
+                    round_landed_at = time.time()
+                    log.info("%s: a new review landed — reading the verdict", slug)
+                else:
+                    log.debug("%s: still waiting (reviews=%d)", slug, now)
+                    continue
+
+            ref = ref or _review_task_ref(alissa, owner, repo, number)
+            verdict = alissa.latest_verdict(ref) if ref else None
+            if verdict == VERDICT_APPROVE:
+                print(f"\n✔ APPROVE — {slug} converged.\n  PR:   {url}\n  task: {ref}")
+                return 0
+            if verdict == VERDICT_REQUEST_CHANGES:
+                print(
+                    f"\n✗ REQUEST_CHANGES — {slug}.\n  PR:   {url}\n  task: {ref}\n"
+                    f"  Triage each finding on its PR thread, fix, then run this again "
+                    f"for the next round."
+                )
+                return 1
+
+            # Review landed but the envelope isn't readable yet — brief grace.
+            if round_landed_at and time.time() - round_landed_at > _ENVELOPE_GRACE_SECONDS:
+                print(
+                    f"\n⚠ a review landed on {slug} but no verdict envelope was found "
+                    f"on the review task {ref or '(not found)'} within "
+                    f"{_ENVELOPE_GRACE_SECONDS}s.\n  PR: {url}\n  Read the PR review "
+                    f"and the review task directly.",
+                    file=sys.stderr,
+                )
+                return 2
+
+        print(
+            f"\n⏱ timed out after {args.timeout}s waiting for a review on {slug} — no "
+            f"verdict yet.\n  PR: {url}\n  The reviewer daemon re-spawns a stalled "
+            f"reviewer at ~90 min; re-run this, or check the worker.",
+            file=sys.stderr,
+        )
+        return 2
+
+    except CommandError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 3
+    except ValueError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 3
+    except KeyboardInterrupt:
+        return 130
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -0,0 +1 @@
+0.3.0

{alissa_tools_github_reviewloop-0.1.1 → alissa_tools_github_reviewloop-0.3.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.1
+Version: 0.3.0
 Summary: ALISSA-TOOLS-GITHUB-REVIEWLOOP
 Home-page: https://alissa.app
 Author: Fahera

{alissa_tools_github_reviewloop-0.1.1 → alissa_tools_github_reviewloop-0.3.0}/src/main/alissa_tools_github_reviewloop.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ src/main/alissa/tools/github/reviewloop/config.py
 src/main/alissa/tools/github/reviewloop/ghclient.py
 src/main/alissa/tools/github/reviewloop/loop.py
 src/main/alissa/tools/github/reviewloop/proc.py
+src/main/alissa/tools/github/reviewloop/prreview.py
 src/main/alissa/tools/github/reviewloop/state.py
 src/main/alissa/tools/github/reviewloop/version
 src/main/alissa/tools/github/reviewloop/version.py

{alissa_tools_github_reviewloop-0.1.1 → alissa_tools_github_reviewloop-0.3.0}/src/main/alissa_tools_github_reviewloop.egg-info/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
+alissa-pr-review = alissa.tools.github.reviewloop.prreview:main
 alissa-reviewloop = alissa.tools.github.reviewloop.__main__:main

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

@@ -1 +0,0 @@
-0.1.1