alissa-tools-github-revloop 0.20.0__tar.gz → 0.22.0__tar.gz

{alissa_tools_github_revloop-0.20.0/src/main/alissa_tools_github_revloop.egg-info → alissa_tools_github_revloop-0.22.0}/PKG-INFO

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

{alissa_tools_github_revloop-0.20.0 → alissa_tools_github_revloop-0.22.0}/src/main/alissa/tools/github/revloop/__main__.py

@@ -80,6 +80,15 @@ def build_parser() -> argparse.ArgumentParser:
         metavar="OWNER/REPO",
         help="only watch this repo; repeatable. Replaces the config list entirely.",
     )
+    over.add_argument(
+        "--author",
+        dest="authors",
+        action="append",
+        metavar="LOGIN",
+        help="only review PRs opened by this GitHub login; repeatable. "
+        "Replaces the config list entirely. Empty = every author is served "
+        "(a scope filter, not a grant); the self-review skip still applies.",
+    )
     over.add_argument(
         "--operator",
         dest="operators",
@@ -194,6 +203,7 @@ def overrides_from(args: argparse.Namespace) -> dict:
     through. `repos` becomes a tuple so it matches the config-file form."""
     return {
         "repos": tuple(args.repos) if args.repos else None,
+        "authors": tuple(args.authors) if args.authors else None,
         "operators": tuple(args.operators) if args.operators else None,
         "poll_interval": args.poll_interval,
         "round_cap": args.round_cap,

{alissa_tools_github_revloop-0.20.0 → alissa_tools_github_revloop-0.22.0}/src/main/alissa/tools/github/revloop/alissa.py

@@ -13,8 +13,36 @@ from .proc import CommandError, run, run_json
 
 log = logging.getLogger(__name__)
 
-# A review task is "open" while it can still receive a verdict.
-OPEN_STATUSES = {"committed", "in_progress", "pending_validation", "todo"}
+# The seven canonical Alissa task statuses -- `TaskStatusSchema` in the studio
+# repo (`packages/client/src/schemas/common.ts`). Mirrored here for the reason
+# the studio CLI mirrors it into `TASK_STATUSES` rather than importing it: what
+# this module needs is the SET of names, not the schema that validates them.
+#
+# It is the vocabulary the `--status` filter below is allowed to speak. CLI
+# 0.2.0 validates `--status` against exactly these seven client-side and exits 1
+# on anything else BEFORE issuing any request, so a single non-canonical value
+# does not narrow the call slightly less -- it costs the whole narrowed call.
+CANONICAL_TASK_STATUSES = frozenset(
+    {
+        "draft",
+        "committed",
+        "in_progress",
+        "blocked",
+        "pending_validation",
+        "validated",
+        "cancelled",
+    }
+)
+
+# A review task is "open" while it can still receive a verdict. Every member is
+# canonical, and a test pins that: a status Alissa cannot issue is dead weight
+# in `is_open` and poison in the `--status` filter derived from it.
+#
+# `todo` was such a member until 0.22.0 (issue #97). Alissa has never had that
+# status, so `is_open` could never match it -- but it was still reaching CLI
+# 0.2.0's `--status` validator, which rejects the call over it, which in turn
+# drops this process back to the unnarrowed whole-corpus list for good.
+OPEN_STATUSES = {"committed", "in_progress", "pending_validation"}
 
 # -- narrowing the `alissa task list` call (issue #87) ------------------------
 #
@@ -26,13 +54,48 @@ OPEN_STATUSES = {"committed", "in_progress", "pending_validation", "todo"}
 # not evidence, and this daemon turns a non-zero `alissa` exit into a SKIPPED
 # decision, so sending a flag the CLI does not have costs a review.
 
-# Statuses a LIVE review task can hold. Deliberately OPEN_STATUSES itself and
-# not a hand-written list: `is_review_task_for` already rejects every other
+# Statuses a LIVE review task can hold. Deliberately derived from OPEN_STATUSES
+# and not a hand-written list: `is_review_task_for` already rejects every other
 # status client-side, so filtering server-side on exactly this set cannot change
 # which task the daemon resolves -- it only stops shipping the rows over the
 # wire. Any status added to `is_open` is added here by construction.
+#
+# The canonical guard below does not weaken that invariant, and is deliberately
+# not an INTERSECTION with the canonical set, which would: an intersection makes
+# the filter a strict subset of the open set the moment the two disagree, so the
+# daemon would stop fetching rows `is_open` still accepts -- a skipped review,
+# reported as an empty corpus. The whole derivation is kept or nothing is sent.
+# Sending nothing degrades to the call the daemon has always made: wide, but
+# complete, which is the direction every other failure on this path degrades in.
 TASK_LIST_STATUS_FLAG = "--status"
-TASK_LIST_STATUS_FILTER = ",".join(sorted(OPEN_STATUSES))
+
+
+def _status_filter(statuses: "set[str] | frozenset[str]") -> str:
+    """The `--status` argument for `statuses`, or `""` when they cannot be one.
+
+    `""` means "do not narrow by status". It is returned for a set carrying any
+    non-canonical value, because such a value is not a filter the CLI serves
+    less precisely -- it is one the CLI refuses outright, taking the `--view`
+    and `--self` narrowing down with it and pinning this process to the
+    whole-corpus list (`list_tasks`). One wide call beats every call being wide.
+
+    Loud rather than silent: the condition is a code defect (a status added to
+    `OPEN_STATUSES` that Alissa cannot issue), and the tests pin against it, so
+    this is the last line rather than the first.
+    """
+    unknown = sorted(set(statuses) - CANONICAL_TASK_STATUSES)
+    if unknown:
+        log.warning(
+            "not narrowing `alissa task list` by status: %s not canonical "
+            "Alissa status(es) -- the CLI rejects the whole call over one "
+            "unknown value, so this daemon lists the corpus unnarrowed",
+            ", ".join(unknown),
+        )
+        return ""
+    return ",".join(sorted(statuses))
+
+
+TASK_LIST_STATUS_FILTER = _status_filter(OPEN_STATUSES)
 
 # `--self` drops the SPONSOR's corpus and keeps only the calling actor's rows.
 #
@@ -375,7 +438,10 @@ class Alissa:
         if self._task_list_narrowing_disabled:
             return argv
         flags = self.probe_task_list()
-        if flags.status and narrow_status:
+        # An empty filter is not a filter: `_status_filter` answers `""` when
+        # the open set carries a status the CLI would reject, and sending
+        # `--status ""` would be that same rejected call with an extra step.
+        if flags.status and narrow_status and TASK_LIST_STATUS_FILTER:
             argv += [TASK_LIST_STATUS_FLAG, TASK_LIST_STATUS_FILTER]
         if flags.self_scope and self._task_list_self_scope:
             argv.append(TASK_LIST_SELF_FLAG)

{alissa_tools_github_revloop-0.20.0 → alissa_tools_github_revloop-0.22.0}/src/main/alissa/tools/github/revloop/config.py

@@ -120,6 +120,7 @@ CONFIG_KEYS = (
     "poll_interval",
     "round_cap",
     "repos",
+    "authors",
     "operators",
     "agent_profile",
     "reviewer_login",
@@ -262,6 +263,21 @@ class Config:
     # Empty tuple means "every repo that requests a review from me".
     repos: tuple[str, ...] = ()
 
+    # GitHub logins whose PRs this loop will spend rounds on. A SCOPE FILTER,
+    # not a capability grant -- so, like `repos` and unlike `operators`, empty
+    # (the default) means EVERY author, and an existing deployment with no
+    # `authors` key behaves exactly as it did before the key existed.
+    #
+    # The distinction is worth keeping straight: `operators` empty means NOBODY
+    # because honouring an ack is a power being handed out, and a grant that
+    # defaults to everyone is a hole. Serving a review request is not a power
+    # the daemon hands to the author -- summoning the loop already costs repo
+    # write access (to request the reviewer) plus a place on the `repos`
+    # allowlist. This key only narrows which of those already-authorised PRs are
+    # worth the rounds: skip dependabot/renovate, or a teammate who does not
+    # want agent reviews.
+    authors: tuple[str, ...] = ()
+
     # GitHub logins whose re-entry ack may raise a capped PR's effective cap
     # (loop.parse_reentry_ack). Empty -- the default -- means NO ack is ever
     # honoured: the lever fails closed, because anyone who can comment on a PR
@@ -356,6 +372,23 @@ class Config:
     def watches(self, full_name: str) -> bool:
         return not self.repos or full_name in self.repos
 
+    def serves_author(self, login: str) -> bool:
+        """Whether a PR by this login is in scope for the loop.
+
+        Empty list = every author (the filter pattern, see the field). Otherwise
+        membership case-insensitively, because GitHub logins are: a config
+        saying `Alissa-App` must match the `alissa-app` the API returns, or the
+        allowlist silently serves nobody -- the same failure mode `_string_list`
+        exists to prevent. Mirrors `loop.ReviewWatcher._is_operator`.
+
+        This is not the self-review guard and cannot stand in for it: an author
+        listed here is still refused if it is the reviewer identity, because
+        that check runs first and independently (see `loop.evaluate`).
+        """
+        if not self.authors:
+            return True
+        return login.lower() in {a.lower() for a in self.authors}
+
     @classmethod
     def build(
         cls,
@@ -399,6 +432,9 @@ class Config:
             )
 
         repos = _string_list(raw.get("repos", ()), "repos", "owner/repo entries")
+        authors = _string_list(
+            raw.get("authors", ()), "authors", "GitHub logins"
+        )
         operators = _string_list(
             raw.get("operators", ()), "operators", "GitHub logins"
         )
@@ -529,6 +565,7 @@ class Config:
             poll_interval=interval,
             round_cap=cap,
             repos=repos,
+            authors=authors,
             operators=operators,
             agent_profile=raw.get("agent_profile", "claude"),
             reviewer_login=raw.get("reviewer_login"),
@@ -553,8 +590,8 @@ def _string_list(value: Any, key: str, what: str) -> tuple[str, ...]:
     The guard is the point: JSON makes `"repos": "org/repo"` an easy typo, and
     Python would iterate it into single CHARACTERS -- an allowlist of 30-odd
     one-character names, which `watches()` then matches against nothing and the
-    daemon quietly reviews no PR at all. Both list keys go through here so
-    neither can grow the footgun back.
+    daemon quietly reviews no PR at all. Every list key goes through here so
+    none of them can grow the footgun back.
     """
     if isinstance(value, str):
         raise ValueError(

{alissa_tools_github_revloop-0.20.0 → alissa_tools_github_revloop-0.22.0}/src/main/alissa/tools/github/revloop/loop.py

@@ -1695,6 +1695,13 @@ class ReviewWatcher:
         if pr.author == self.github.login:
             # GitHub rejects a self review-request, so this should be
             # unreachable -- but a shared bot identity would land here.
+            #
+            # FIRST, and deliberately above the authors allowlist (further
+            # down): the allowlist is a scope filter an operator writes, and no
+            # entry in it may buy back a review GitHub itself forbids. Listing
+            # the reviewer login in `authors` therefore narrows the loop to a PR
+            # it will then refuse -- which is the correct reading of "only serve
+            # this author" for an author that cannot be served.
             return Decision(
                 Action.SKIPPED,
                 f"PR author is the reviewer identity ({pr.author}); "
@@ -1755,6 +1762,36 @@ class ReviewWatcher:
             self._clear_own_review_request(pr, my_reviews, converged)
             return Decision(Action.CONVERGED, converged, completed)
 
+        # THE AUTHORS SCOPE FILTER (issue #93), and its position is the whole
+        # of its contract: it gates STARTING a round and nothing else.
+        #
+        # Client-side, because the discovery search is deliberately untouched --
+        # the author is only in hand once the PR detail is fetched. Below
+        # convergence rather than up beside the self-review skip, because every
+        # branch above finishes a round that was already started: a verdict
+        # envelope ahead of its native review still becomes a review of record
+        # (_close_round_natively), and a converged PR still gets its dangling
+        # review request withdrawn (_clear_own_review_request). An operator who
+        # narrows `authors` mid-round must not strand the round that is already
+        # running, and stopping one step short of its verdict of record is the
+        # studio #298 failure this module refuses everywhere else (PR #94 round
+        # 1). It costs a filtered PR one my_reviews fetch and the review-task
+        # lookup per poll -- the negative cache bounds the corpus search -- and
+        # that is the price of not stranding a round.
+        #
+        # Above THIS line, therefore, and everything the issue's checklist asks
+        # for follows from where it sits: the effective cap and its ack
+        # announcement, the cap-out escalation (the only branch below that would
+        # COMMENT on the PR), `round_ = completed + 1`, the stale-round probe and
+        # the spawn are all downstream. A filtered PR burns no round number,
+        # records no attempt, holds no stale-round slot and never says a word on
+        # the PR -- it gets silence, exactly as an unwatched repo does.
+        if not self.config.serves_author(pr.author):
+            return Decision(
+                Action.SKIPPED,
+                f"PR author {pr.author} is not in the authors allowlist",
+            )
+
         # The effective cap is the configured one plus every re-entry an
         # operator has explicitly acked on THIS PR (issue #42). The sum is a
         # local read, so it costs nothing on the common path; the GitHub scan

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

@@ -0,0 +1 @@
+0.22.0

{alissa_tools_github_revloop-0.20.0 → alissa_tools_github_revloop-0.22.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.20.0
+Version: 0.22.0
 Summary: ALISSA-TOOLS-GITHUB-REVLOOP
 Home-page: https://alissa.app
 Author: Fahera

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

@@ -1 +0,0 @@
-0.20.0