alissa-tools-github-revloop 0.30.1__tar.gz → 0.31.0__tar.gz

{alissa_tools_github_revloop-0.30.1/src/main/alissa_tools_github_revloop.egg-info → alissa_tools_github_revloop-0.31.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-revloop
-Version: 0.30.1
+Version: 0.31.0
 Summary: ALISSA-TOOLS-GITHUB-REVLOOP
 Home-page: https://alissa.app
 Author: Fahera

{alissa_tools_github_revloop-0.30.1 → alissa_tools_github_revloop-0.31.0}/src/main/alissa/tools/github/revloop/alissa.py

@@ -233,6 +233,53 @@ _VERDICT_RE = re.compile(
     re.IGNORECASE,
 )
 
+# The envelope's merge-readiness judgment (issue #130). The alissa-code-review
+# skill writes it as one list line in the verdict envelope:
+#   - **Merge-Readiness:** auto
+#   - **Merge-Readiness:** operator — touches convex/schema.ts
+# Tolerant of the markdown around the label -- an optional bullet, optional
+# `**` bold around the label (with the colon inside or outside it), optional
+# bold around the value -- but NOT of the value's case: `Auto` is not a
+# judgment this daemon will carry, so it reads as missing and fails closed to
+# `operator` downstream. Line-anchored, first match wins, like the consumer's
+# own grammar; the reason runs to the end of the line and no further.
+READINESS_AUTO = "auto"
+READINESS_OPERATOR = "operator"
+_READINESS_RE = re.compile(
+    r"^[ \t]*(?:[-*+][ \t]+)?(?:\*\*)?[ \t]*Merge-Readiness[ \t]*:?[ \t]*(?:\*\*)?"
+    r"[ \t]*:?[ \t]*(?:\*\*)?(auto|operator)\b(?:\*\*)?"
+    r"(?:[ \t]*[—–-][ \t]*(.*?))?[ \t]*$",
+    re.MULTILINE,
+)
+
+# The reason lands in a GitHub review body (as a line-anchored trailer) and in
+# a log line, so it is bounded and flattened at the parser: one line, no
+# backticks (a fence would swallow the trailer and everything after it), and
+# no more than this many characters.
+MAX_READINESS_REASON_CHARS = 200
+
+
+def clean_readiness_reason(text: object) -> str:
+    """Flatten a Merge-Readiness reason to one bounded, backtick-free line."""
+    if not isinstance(text, str):
+        return ""
+    flat = " ".join(text.replace("`", "").split())
+    return flat[:MAX_READINESS_REASON_CHARS].rstrip()
+
+
+def parse_readiness(blob: object) -> "tuple[str | None, str]":
+    """`(value, reason)` from the first Merge-Readiness line in `blob`.
+
+    `value` is READINESS_AUTO / READINESS_OPERATOR, or None when no line
+    parses; `reason` is the cleaned trailing text (empty when there is none).
+    """
+    if not isinstance(blob, str):
+        return (None, "")
+    match = _READINESS_RE.search(blob)
+    if match is None:
+        return (None, "")
+    return (match.group(1), clean_readiness_reason(match.group(2)))
+
 
 @dataclass(frozen=True)
 class Task:
@@ -389,6 +436,23 @@ def _task_from_row(row: object) -> "Task | None":
     )
 
 
+@dataclass(frozen=True)
+class VerdictEnvelope:
+    """One parsed CR6 verdict envelope: the verdict, plus the merge-readiness
+    judgment the same envelope carries (issue #130).
+
+    `readiness` is READINESS_AUTO / READINESS_OPERATOR, or None when the
+    envelope has no parseable `Merge-Readiness` line -- the case the native
+    post fails closed on. `readiness_reason` is already one bounded,
+    backtick-free line (see clean_readiness_reason); empty when the envelope
+    gave none.
+    """
+
+    verdict: str
+    readiness: "str | None" = None
+    readiness_reason: str = ""
+
+
 @dataclass(frozen=True)
 class TaskDetail:
     """One task as `alissa task get` sees it: the task itself, plus everything
@@ -774,16 +838,29 @@ 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.
+        """The newest CR6 verdict envelope's verdict 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.
 
+        The word alone; `latest_envelope` returns the whole record (verdict
+        plus merge-readiness) off the same read for the caller that posts it.
+
         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.
         """
+        envelope = self.latest_envelope(task_ref)
+        return None if envelope is None else envelope.verdict
+
+    def latest_envelope(self, task_ref: str) -> "VerdictEnvelope | None":
+        """The newest CR6 verdict envelope on a review task, parsed, or None.
+
+        Same read and same tolerance as `latest_verdict`; this is the record
+        the native post carries onto GitHub (issue #130), so it needs the
+        envelope's Merge-Readiness line alongside the verdict word.
+        """
         try:
             data = run_json(["alissa", "task", "get", task_ref, "--json"], timeout=90)
         except CommandError as exc:
@@ -794,7 +871,7 @@ class Alissa:
             return None
 
         try:
-            return self._newest_verdict(data)
+            return self._newest_envelope(data)
         except Exception:  # pragma: no cover - defence in depth
             log.exception("could not parse verdict evidence for %s", task_ref)
             return None
@@ -839,10 +916,23 @@ class Alissa:
 
     @staticmethod
     def _newest_verdict(payload: object) -> str | None:
-        """Pick the newest parseable verdict out of a task's evidence array.
+        """The newest parseable verdict WORD out of a task's evidence array;
+        `_newest_envelope` with the readiness dropped, for the callers that
+        only decide on the word."""
+        envelope = Alissa._newest_envelope(payload)
+        return None if envelope is None else envelope.verdict
+
+    @staticmethod
+    def _newest_envelope(payload: object) -> "VerdictEnvelope | None":
+        """Pick the newest parseable verdict envelope out of a task's evidence
+        array, with the Merge-Readiness judgment it carries (issue #130).
 
         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.
+
+        The readiness is read off the SAME evidence item as the verdict (its
+        body first, then its title), never off a neighbour: a stray line on an
+        older envelope must not decorate a newer round's verdict.
         """
         if not isinstance(payload, dict):
             return None
@@ -850,7 +940,7 @@ class Alissa:
         if not isinstance(evidence, list):
             return None
 
-        found: list[tuple[tuple[int, float], int, str]] = []
+        found: list[tuple[tuple[int, float], int, VerdictEnvelope]] = []
         for index, item in enumerate(evidence):
             if not isinstance(item, dict):
                 continue
@@ -861,10 +951,17 @@ class Alissa:
                     continue
                 match = _VERDICT_RE.search(blob)
                 if match:
+                    readiness, reason = parse_readiness(content)
+                    if readiness is None:
+                        readiness, reason = parse_readiness(title)
                     found.append(
                         (Alissa._created_key(item.get("createdAt")),
                          index,
-                         match.group(1).lower())
+                         VerdictEnvelope(
+                             verdict=match.group(1).lower(),
+                             readiness=readiness,
+                             readiness_reason=reason,
+                         ))
                     )
                     break
 

{alissa_tools_github_revloop-0.30.1 → alissa_tools_github_revloop-0.31.0}/src/main/alissa/tools/github/revloop/loop.py

@@ -22,8 +22,11 @@ from enum import Enum
 from pathlib import Path
 
 from .alissa import (
+    READINESS_AUTO,
+    READINESS_OPERATOR,
     VERDICT_APPROVE,
     VERDICT_REQUEST_CHANGES,
+    VerdictEnvelope,
     Alissa,
     ManagedSession,
     SessionRef,
@@ -391,10 +394,50 @@ NATIVE_VERDICT_BODY = (
     "Submitted by the review daemon under the configured reviewer identity, so "
     "this round has a verdict of record on GitHub. The round's findings and "
     "reasoning are in the reviewer session's own comments on this PR{task_note}."
-    "{head_note}\n\n"
+    "{head_note}{readiness}\n\n"
     "{marker}"
 )
 
+# The merge-readiness trailer (issue #130). orcloop's opt-in merge edge merges
+# a PR only when the reviewer's APPROVE on the current head carries
+# `Merge-Readiness: auto`; the judgment is the reviewer session's (the
+# envelope's `- **Merge-Readiness:**` line) and this daemon only CARRIES it,
+# in a grammar the consumer can parse: one plain-text line, line-anchored,
+# the last non-empty line before the hidden verdict marker --
+#
+#   Merge-Readiness: auto
+#   Merge-Readiness: operator — <one-line reason>
+#
+# The rules that make it safe to consume: it is emitted on APPROVE events
+# ONLY (a request_changes envelope with a stray `auto` line carries nothing;
+# an approve the checks gate downgraded carries nothing), and an envelope
+# with no parseable line fails CLOSED to `operator`, with a reason that tells
+# the operator why the merge waited on them.
+READINESS_TRAILER_LABEL = "Merge-Readiness:"
+READINESS_MISSING_REASON = "envelope carries no Merge-Readiness line"
+
+
+def readiness_trailer(envelope: "VerdictEnvelope | None") -> str:
+    """The line the native APPROVE carries for `envelope`'s judgment.
+
+    The caller has already decided the event is an APPROVE; this only maps
+    the envelope onto the grammar. `auto` is emitted bare -- the consumer
+    keys on the value, and an operator reads a reason only when the merge is
+    theirs to make. A missing or unparseable judgment (None envelope, or one
+    whose readiness did not parse) is `operator` with a reason saying so.
+    """
+    if envelope is not None and envelope.readiness == READINESS_AUTO:
+        return f"{READINESS_TRAILER_LABEL} {READINESS_AUTO}"
+    if envelope is not None and envelope.readiness == READINESS_OPERATOR:
+        if envelope.readiness_reason:
+            return (
+                f"{READINESS_TRAILER_LABEL} {READINESS_OPERATOR} — "
+                f"{envelope.readiness_reason}"
+            )
+        return f"{READINESS_TRAILER_LABEL} {READINESS_OPERATOR}"
+    return f"{READINESS_TRAILER_LABEL} {READINESS_OPERATOR} — {READINESS_MISSING_REASON}"
+
+
 # Appended to the body when the round's review task is known.
 _VERDICT_TASK_NOTE = ", and the CR6 verdict envelope is on `{task_ref}`"
 
@@ -601,6 +644,17 @@ _RECORD_THE_CAP = (
     "from a stale template default. "
 )
 
+# The merge-readiness line (issue #130). The verdict envelope is where the
+# reviewer's judgment lives; the daemon copies it onto the native review as a
+# trailer the merge edge reads, and an envelope without the line posts as
+# `operator` -- so a reviewer who skips it has silently withheld auto-merge.
+_MERGE_READINESS_LINE = (
+    "Your verdict envelope MUST carry the skill's `- **Merge-Readiness:** auto | "
+    "operator — <reason>` line — the daemon copies it onto the native review as "
+    "the `Merge-Readiness:` trailer the merge edge reads, and an envelope "
+    "without the line posts as `operator`. "
+)
+
 # -- the reviewer session's own CI gate (issue #84) ---------------------------
 #
 # _gate_on_checks (issue #58) gates the verdict the DAEMON posts. It cannot gate the
@@ -881,6 +935,7 @@ ROUND_1_DIRECTIVE = (
     "severity-tagged comments via gh pr review, record the verdict evidence, "
     "move the task to pending_validation. "
     + _RECORD_THE_CAP
+    + _MERGE_READINESS_LINE
     + "{credential}"
     + _CHECKS_BEFORE_VERDICT
     + "{checks}"
@@ -899,6 +954,7 @@ ROUND_K_DIRECTIVE = (
     "verify the fixes, sweep the new diff with the full rubric, record a "
     "round-{round} verdict envelope, move the task to pending_validation. "
     + _RECORD_THE_CAP
+    + _MERGE_READINESS_LINE
     + "{credential}"
     + _CHECKS_BEFORE_VERDICT
     + "{checks}"
@@ -3169,9 +3225,10 @@ class ReviewWatcher:
         Never raises past RateLimited: a broken post must stall this PR, not
         the whole poll pass.
         """
-        verdict = self.alissa.latest_verdict(task.ref)
+        envelope = self.alissa.latest_envelope(task.ref)
+        verdict = None if envelope is None else envelope.verdict
         if verdict not in (VERDICT_APPROVE, VERDICT_REQUEST_CHANGES):
-            # count_verdicts and latest_verdict read the same envelopes with
+            # count_verdicts and latest_envelope read the same envelopes with
             # the same pattern, so this is nearly unreachable -- but "I know a
             # round finished and cannot tell you its verdict" must never be
             # resolved by guessing one onto the PR.
@@ -3266,6 +3323,11 @@ class ReviewWatcher:
                 return gate.hold
             event = gate.event
 
+        # The trailer follows the EVENT, not the envelope: an approve the
+        # checks gate turned into a REQUEST_CHANGES or COMMENT carries none,
+        # because `auto` on anything but an APPROVE is exactly what the
+        # consumer must never see (issue #130).
+        trailer = readiness_trailer(envelope) if event == EVENT_APPROVE else ""
         body = gate.lead + NATIVE_VERDICT_BODY.format(
             round=round_,
             verdict=verdict,
@@ -3275,6 +3337,7 @@ class ReviewWatcher:
                 if moved
                 else ""
             ),
+            readiness=f"\n\n{trailer}" if trailer else "",
             marker=verdict_marker(round_),
         )
         try:
@@ -3312,14 +3375,20 @@ class ReviewWatcher:
         self.state.record_verdict(
             pr.full_name, pr.number, judged, int(time.time()), url or ""
         )
+        # The readiness carried on the post, in the same three records. Only
+        # an APPROVE carries one, so only an APPROVE names it.
+        readiness_value = trailer[len(READINESS_TRAILER_LABEL):].strip()
+        readiness_note = f" readiness={readiness_value}" if trailer else ""
         log.info(
-            "%s round %d closed: native %s review submitted as %s (%s)%s",
-            pr.slug, round_, event, self.github.login, url or "no url", gate_note,
+            "%s round %d closed: native %s review submitted as %s (%s)%s%s",
+            pr.slug, round_, event, self.github.login, url or "no url",
+            readiness_note, gate_note,
         )
         self._append_activity(
             pr,
             f"- {_now()} — round {round_} — native `{event}` review submitted "
-            f"as `{self.github.login}` (verdict of record){gate_note}",
+            f"as `{self.github.login}` (verdict of record){gate_note}"
+            + (f" — merge-readiness: `{readiness_value}`" if trailer else ""),
         )
         if event == EVENT_COMMENT:
             # A degraded verdict takes the PR out of the loop (the review

alissa_tools_github_revloop-0.31.0/src/main/alissa/tools/github/revloop/version

@@ -0,0 +1 @@
+0.31.0

{alissa_tools_github_revloop-0.30.1 → alissa_tools_github_revloop-0.31.0/src/main/alissa_tools_github_revloop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-revloop
-Version: 0.30.1
+Version: 0.31.0
 Summary: ALISSA-TOOLS-GITHUB-REVLOOP
 Home-page: https://alissa.app
 Author: Fahera

alissa_tools_github_revloop-0.30.1/src/main/alissa/tools/github/revloop/version

@@ -1 +0,0 @@
-0.30.1