alissa-tools-github-devloop 0.1.0__tar.gz → 0.3.0__tar.gz

{alissa_tools_github_devloop-0.1.0/src/main/alissa_tools_github_devloop.egg-info → alissa_tools_github_devloop-0.3.0}/PKG-INFO

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

{alissa_tools_github_devloop-0.1.0 → alissa_tools_github_devloop-0.3.0}/src/main/alissa/tools/github/devloop/__main__.py

@@ -98,6 +98,23 @@ def build_parser() -> argparse.ArgumentParser:
     )
     over.add_argument("--on-missing-hub", choices=[HUB_SKIP, HUB_ADD])
 
+    fix = over.add_mutually_exclusive_group()
+    fix.add_argument(
+        "--fix-rounds",
+        dest="fix_rounds_enabled",
+        action="store_true",
+        default=None,
+        help="poll open PRs authored by the token for a request_changes "
+        "review awaiting the author, and spawn fix sessions (the default)",
+    )
+    fix.add_argument(
+        "--no-fix-rounds",
+        dest="fix_rounds_enabled",
+        action="store_false",
+        help="issues-only polling: never evaluate PRs or spawn fix sessions, "
+        "even if the config enables it",
+    )
+
     dry = over.add_mutually_exclusive_group()
     dry.add_argument(
         "--dry-run",
@@ -131,6 +148,7 @@ def overrides_from(args: argparse.Namespace) -> dict:
         "stale_minutes": args.stale_minutes,
         "on_missing_origin_task": args.on_missing_origin_task,
         "on_missing_hub": args.on_missing_hub,
+        "fix_rounds_enabled": args.fix_rounds_enabled,
         "dry_run": args.dry_run,
     }
 
@@ -161,8 +179,10 @@ def log_effective_config(config: Config, login: str) -> None:
     )
     log.info("reviewers: %s", ", ".join(config.reviewers) or "none")
     log.info(
-        "poll every %ss; dry_run=%s; attempt_cap=%s; stale after %s min",
-        config.poll_interval, config.dry_run, config.attempt_cap, config.stale_minutes,
+        "poll every %ss; dry_run=%s; attempt_cap=%s; stale after %s min; "
+        "fix_rounds=%s",
+        config.poll_interval, config.dry_run, config.attempt_cap,
+        config.stale_minutes, config.fix_rounds_enabled,
     )
     log.debug("hub_template: %s", config.hub_template)
     log.debug("agent_profile: %s", config.agent_profile)

{alissa_tools_github_devloop-0.1.0 → alissa_tools_github_devloop-0.3.0}/src/main/alissa/tools/github/devloop/alissa.py

@@ -1,10 +1,12 @@
-"""Alissa CLI access: enqueue the fresh developer session and probe the
-worker. The developer's Alissa task is created by the session itself (as a
-downstream of the origin task), so unlike reviewloop there is no task lookup
-here -- the daemon's only Alissa surfaces are the tmux queue and the worker."""
+"""Alissa CLI access: enqueue the fresh developer session, probe the worker,
+and list/kill managed tmux sessions for the reaper sweep. The developer's
+Alissa task is created by the session itself (as a downstream of the origin
+task), so unlike reviewloop there is no task lookup here -- the daemon's only
+Alissa surfaces are the tmux queue, the worker, and the tmux session list."""
 
 from __future__ import annotations
 
+import json
 import logging
 from pathlib import Path
 
@@ -66,6 +68,33 @@ class Alissa:
         # Cloning a repo can be slow; the poll loop tolerates a long pass.
         run(argv, timeout=600, cwd=workspace_root)
 
+    def list_sessions(self) -> "list[dict]":
+        """Managed tmux sessions as `alissa tmux ls --json` reports them
+        (dicts carrying at least `name` and `status`). Raises CommandError
+        when the CLI cannot answer at all (the caller skips that sweep);
+        unparseable or non-list JSON degrades to an empty list -- a broken
+        listing must read as "nothing to reap", never crash the poll."""
+        out = run(["alissa", "tmux", "ls", "--json"], timeout=60)
+        if not out.strip():
+            return []
+        try:
+            data = json.loads(out)
+        except json.JSONDecodeError:
+            log.warning(
+                "`alissa tmux ls --json` returned unparseable output -- "
+                "treating as no sessions this sweep"
+            )
+            return []
+        if not isinstance(data, list):
+            return []
+        return [entry for entry in data if isinstance(entry, dict)]
+
+    def kill_session(self, name: str) -> None:
+        """Kill ONE managed session by name -- never the tmux server. Raises
+        CommandError on failure (including a CLI old enough to lack
+        `tmux kill`); the reaper treats kills as best-effort."""
+        run(["alissa", "tmux", "kill", name], timeout=60)
+
     def worker_running(self) -> bool:
         """The queue only drains while `alissa worker` reconciles it."""
         try:

{alissa_tools_github_devloop-0.1.0 → alissa_tools_github_devloop-0.3.0}/src/main/alissa/tools/github/devloop/config.py

@@ -58,11 +58,18 @@ CONFIG_KEYS = (
     "stale_minutes",
     "on_missing_origin_task",
     "on_missing_hub",
+    "fix_rounds_enabled",
     "dry_run",
 )
 
 MIN_POLL_INTERVAL = 10  # the search API allows 30 req/min
 
+# The only placeholders hub_for supplies. Probed at load time: nothing else
+# calls hub_for until the daemon loop is already running, so a typo'd
+# placeholder would otherwise outlive Config.build AND preflight and surface
+# as a raw KeyError mid-poll instead of a config error at startup.
+HUB_TEMPLATE_FIELDS = ("root", "owner", "repo")
+
 
 def default_state_path(workspace_root: Path) -> Path:
     return Path(workspace_root) / ".devloop" / "state.db"
@@ -126,6 +133,13 @@ class Config:
 
     on_missing_origin_task: str = ON_MISSING_WARN
     on_missing_hub: str = HUB_SKIP
+
+    # The review-response edge (poll open PRs authored by the token for a
+    # request_changes verdict awaiting the author, and spawn fix sessions).
+    # Default ON: the edge is the daemon's second half, and every side effect
+    # still honors dry_run. Turning it off reverts to issues-only polling.
+    fix_rounds_enabled: bool = True
+
     dry_run: bool = False
 
     # Derived at build time: `repos` casefolded for matching. GitHub names are
@@ -209,6 +223,23 @@ class Config:
                 f"on_missing_hub must be one of {sorted(_HUB_MODES)}, got {hub_mode!r}"
             )
 
+        template = raw.get("hub_template", cls.hub_template)
+        valid = ", ".join("{" + name + "}" for name in HUB_TEMPLATE_FIELDS)
+        try:
+            template.format(**{name: name for name in HUB_TEMPLATE_FIELDS})
+        except KeyError as exc:
+            raise ValueError(
+                f"hub_template has an unknown placeholder {{{exc.args[0]}}}: "
+                f"{template!r}. Valid placeholders: {valid}"
+            ) from exc
+        except (IndexError, ValueError) as exc:
+            # Positional fields ({}, {0}) or unbalanced braces — str.format
+            # reports these without naming the template, so name it here.
+            raise ValueError(
+                f"hub_template is not a valid template: {template!r} ({exc}). "
+                f"Use named placeholders: {valid}"
+            ) from exc
+
         repos = _string_list(raw.get("repos", cls.repos), "repos")
         if hub_mode == HUB_ADD and not repos:
             # Anyone who can label an issue could otherwise cause an arbitrary
@@ -233,21 +264,24 @@ class Config:
                 f"poll_interval must be >= {MIN_POLL_INTERVAL} seconds, got {interval}"
             )
 
-        state_path = raw.get("state_path")
+        state_path = raw.get("state_path", cls.state_path)
         return cls(
             workspace_root=Path(workspace_root),
-            hub_template=raw.get("hub_template", cls.hub_template),
+            hub_template=template,
             poll_interval=interval,
             label=raw.get("label", cls.label),
             repos=repos,
             agent_profile=raw.get("agent_profile", cls.agent_profile),
-            developer_login=raw.get("developer_login"),
+            developer_login=raw.get("developer_login", cls.developer_login),
             reviewers=_string_list(raw.get("reviewers", cls.reviewers), "reviewers"),
             state_path=Path(state_path).expanduser() if state_path else None,
             attempt_cap=cap,
             stale_minutes=stale,
             on_missing_origin_task=mode,
             on_missing_hub=hub_mode,
+            fix_rounds_enabled=bool(
+                raw.get("fix_rounds_enabled", cls.fix_rounds_enabled)
+            ),
             dry_run=bool(raw.get("dry_run", cls.dry_run)),
         )
 

{alissa_tools_github_devloop-0.1.0 → alissa_tools_github_devloop-0.3.0}/src/main/alissa/tools/github/devloop/ghclient.py

@@ -36,6 +36,12 @@ TASK_REF_RE = re.compile(r"TASK-(\d+)")
 TIMELINE_PAGE_SIZE = 100
 TIMELINE_MAX_PAGES = 5
 
+# Review states that count as "a review was submitted". PENDING is a draft
+# review that was never submitted, so it closes nothing. Same set as
+# reviewloop's SUBMITTED_STATES -- the two daemons must count rounds
+# identically or they disagree about which round a PR is in.
+SUBMITTED_STATES = {"APPROVED", "CHANGES_REQUESTED", "COMMENTED", "DISMISSED"}
+
 
 def parse_task_ref(body: str) -> int | None:
     """Origin Alissa task number from an issue body, or None if absent.
@@ -74,6 +80,58 @@ class Issue:
         return f"{self.owner}/{self.repo}#{self.number}"
 
 
+@dataclass(frozen=True)
+class PullRequest:
+    owner: str
+    repo: str
+    number: int
+    state: str
+    title: str
+    author: str
+    head_ref: str
+    head_sha: str
+    draft: bool
+    url: str
+    # Logins/slugs whose review is CURRENTLY requested (users and teams
+    # merged): non-empty means the ball is in a reviewer's court, so the
+    # review-response edge is closed. GitHub clears an entry when that
+    # reviewer submits and re-adds it on re-request.
+    requested_reviewers: tuple[str, ...]
+
+    @property
+    def full_name(self) -> str:
+        return f"{self.owner}/{self.repo}"
+
+    @property
+    def pr_slug(self) -> str:
+        # `#pr16`, not `#16`: PR and issue numbers share GitHub's namespace,
+        # and poll_once logs both edges into one Decision list -- the slug is
+        # what tells `acme/widgets#7` (issue) from `acme/widgets#pr7` (PR).
+        return f"{self.owner}/{self.repo}#pr{self.number}"
+
+
+@dataclass(frozen=True)
+class Review:
+    author: str
+    state: str
+    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.
+        Same rule as reviewloop's Review.is_substantive -- both daemons (and
+        alissa-pr-review's round counter) must agree on what closes a round.
+        """
+        return bool(self.body.strip())
+
+
 class RateLimited(RuntimeError):
     pass
 
@@ -258,6 +316,136 @@ class GitHub:
             out.append((parts[-2], parts[-1], number, assignees))
         return out
 
+    def search_prs(self, repos: tuple[str, ...] = ()) -> list[tuple[str, str, int]]:
+        """Open non-draft PRs AUTHORED by the token identity across the
+        watched repos, as `(owner, repo, number)` hits -- the candidate set of
+        the review-response edge.
+
+        `author:@me` resolves server-side from the gh token (the same token
+        verify_identity() pins at startup), so the daemon only ever considers
+        its own PRs -- the developer identity is the author of every PR its
+        spawned sessions push. `draft:false` keeps the daemon's own fresh
+        draft PRs (the pre-review norm) from costing a pull_request() re-fetch
+        every poll; evaluate_pr() re-checks `draft` anyway, since a PR can
+        flip back to draft between search and fetch (same belt-and-braces as
+        reviewloop's review_requests + CR1 re-check).
+
+        Fails closed on an empty allowlist for the same reason search_issues
+        does: an unscoped query would return every PR the token ever authored
+        anywhere on GitHub, and the caller spawns code-writing sessions
+        against what comes back. Empty/whitespace entries fail closed too.
+        """
+        repos = tuple(r.strip() for r in repos if r and r.strip())
+        if not repos:
+            log.warning(
+                "search_prs: repo allowlist is empty -- nothing is watched. "
+                "An unscoped search would match every PR this token authored "
+                "anywhere on GitHub, so this fails closed; configure `repos` "
+                "to watch something."
+            )
+            return []
+
+        query = "is:pr is:open draft:false author:@me"
+        for full_name in repos:
+            query += f" repo:{full_name}"
+
+        payload = self._api(
+            "-X",
+            "GET",
+            "search/issues",
+            "-f",
+            f"q={query}",
+            "-f",
+            f"per_page={self.SEARCH_PER_PAGE}",
+        )
+        items = (payload or {}).get("items", [])
+        if len(items) == self.SEARCH_PER_PAGE:
+            log.warning(
+                "search_prs: got exactly %d items -- results are likely "
+                "truncated. Pagination is deliberately not implemented "
+                "(same hard ceiling as search_issues); the window only "
+                "drains as PRs close or merge.",
+                self.SEARCH_PER_PAGE,
+            )
+
+        out: list[tuple[str, str, int]] = []
+        for item in items:
+            # repository_url looks like https://api.github.com/repos/<owner>/<repo>
+            parts = item.get("repository_url", "").rstrip("/").split("/")
+            if len(parts) < 2:
+                log.warning("could not parse repo from %s", item.get("repository_url"))
+                continue
+            try:
+                number = int(item["number"])
+            except (KeyError, TypeError, ValueError):
+                log.warning("could not parse PR number from %r", item.get("number"))
+                continue
+            out.append((parts[-2], parts[-1], number))
+        return out
+
+    def pull_request(self, owner: str, repo: str, number: int) -> PullRequest:
+        """The evaluate_pr() re-fetch: draft state, head, author, and the
+        pending review requests -- the consistency guard over search
+        staleness, like issue() is for the issue edge."""
+        data = self._api(f"repos/{owner}/{repo}/pulls/{number}") or {}
+        head = data.get("head") or {}
+        # Users carry `login`, teams `slug`; both hold the edge closed -- a
+        # pending TEAM re-request still means the ball is in a reviewer's
+        # court, so it must not read as "awaiting the author".
+        requested = tuple(
+            name
+            for entry in (
+                list(data.get("requested_reviewers") or [])
+                + list(data.get("requested_teams") or [])
+            )
+            if isinstance(entry, dict)
+            and (name := (entry.get("login") or entry.get("slug") or ""))
+        )
+        return PullRequest(
+            owner=owner,
+            repo=repo,
+            number=number,
+            state=data.get("state", ""),
+            title=data.get("title", ""),
+            author=(data.get("user") or {}).get("login", ""),
+            head_ref=head.get("ref") or "",
+            head_sha=head.get("sha") or "",
+            draft=bool(data.get("draft")),
+            url=data.get("html_url", ""),
+            requested_reviewers=requested,
+        )
+
+    def reviews(self, owner: str, repo: str, number: int) -> list[Review]:
+        """All review records on a PR, tolerant of malformed entries. The
+        substantive/reviewer filtering happens in the loop (it needs config);
+        per_page=100 is a documented single-page window like the searches --
+        a PR with more than 100 review records is far past the round cap.
+        """
+        data = (
+            self._api(
+                "-X",
+                "GET",
+                f"repos/{owner}/{repo}/pulls/{number}/reviews",
+                "-f",
+                "per_page=100",
+            )
+            or []
+        )
+        if not isinstance(data, list):
+            return []
+        return [
+            Review(
+                author=(r.get("user") or {}).get("login", ""),
+                state=r.get("state", ""),
+                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
+            if isinstance(r, dict)
+        ]
+
     def issue(self, owner: str, repo: str, number: int) -> Issue:
         # `or {}`: run_json returns None on empty stdout, and the siblings
         # (search_issues, assign_self) already guard the same way.
@@ -307,7 +495,10 @@ class GitHub:
         comments, labeled/assigned/mentioned events, bot noise -- ahead of
         the cross-reference, so a long pre-label discussion can push it past
         the first page, and a first-page-only probe would mis-read live work
-        as dead (and respawn over it). The walk is bounded: it stops at the
+        as dead (and respawn over it). The walk is bounded: it stops as soon
+        as a page has yielded any open same-repo PR (every caller's question
+        is effectively boolean -- further pages could only lengthen a
+        comment's URL list), it stops at the
         first short page (the timeline is exhausted) and hard-caps at
         TIMELINE_MAX_PAGES pages (TIMELINE_MAX_PAGES * TIMELINE_PAGE_SIZE
         events) -- a cross-reference past that ceiling is invisible to the
@@ -353,6 +544,12 @@ class GitHub:
                 if not url.startswith(same_repo_pull):
                     continue  # a mention from another repo says nothing here
                 urls.append(url)
+            if urls:
+                # The caller's question is boolean -- is ANY open same-repo
+                # PR linked? -- so once a page yields one, later pages can
+                # only add more URLs to a message, never change the
+                # decision: stop paying for them.
+                break
             if len(events) < TIMELINE_PAGE_SIZE:
                 break  # short page: the timeline is exhausted
         # One PR can cross-reference the issue more than once (body edit,