alissa-tools-github-devloop 0.5.0__tar.gz → 0.6.0__tar.gz

{alissa_tools_github_devloop-0.5.0/src/main/alissa_tools_github_devloop.egg-info → alissa_tools_github_devloop-0.6.0}/PKG-INFO

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

{alissa_tools_github_devloop-0.5.0 → alissa_tools_github_devloop-0.6.0}/src/main/alissa/tools/github/devloop/__main__.py

@@ -147,6 +147,24 @@ def build_parser() -> argparse.ArgumentParser:
         "sessions, even if the config enables it",
     )
 
+    resume = over.add_mutually_exclusive_group()
+    resume.add_argument(
+        "--resume",
+        dest="resume_enabled",
+        action="store_true",
+        default=None,
+        help="auto-resume a stale attempt whose session is provably dead "
+        "(absent from a successful `alissa tmux ls`) while its PR stays open, "
+        "instead of deferring behind an operator ping (the default)",
+    )
+    resume.add_argument(
+        "--no-resume",
+        dest="resume_enabled",
+        action="store_false",
+        help="legacy two-signal staleness: never read session liveness, "
+        "never auto-resume — a dead-with-PR lane waits for an operator",
+    )
+
     dry = over.add_mutually_exclusive_group()
     dry.add_argument(
         "--dry-run",
@@ -184,6 +202,7 @@ def overrides_from(args: argparse.Namespace) -> dict:
         "fix_rounds_enabled": args.fix_rounds_enabled,
         "maintain_label": args.maintain_label,
         "maintain_enabled": args.maintain_enabled,
+        "resume_enabled": args.resume_enabled,
         "dry_run": args.dry_run,
     }
 
@@ -215,12 +234,13 @@ 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; "
-        "max_sessions=%s; fix_rounds=%s; maintain=%s (label %r)",
+        "max_sessions=%s; fix_rounds=%s; maintain=%s (label %r); resume=%s",
         config.poll_interval, config.dry_run, config.attempt_cap,
         config.stale_minutes,
         config.max_sessions or "unlimited",
         config.fix_rounds_enabled,
         config.maintain_enabled, config.maintain_label,
+        config.resume_enabled,
     )
     log.debug("hub_template: %s", config.hub_template)
     log.debug("agent_profile: %s", config.agent_profile)

{alissa_tools_github_devloop-0.5.0 → alissa_tools_github_devloop-0.6.0}/src/main/alissa/tools/github/devloop/config.py

@@ -62,6 +62,7 @@ CONFIG_KEYS = (
     "fix_rounds_enabled",
     "maintain_label",
     "maintain_enabled",
+    "resume_enabled",
     "dry_run",
 )
 
@@ -161,6 +162,24 @@ class Config:
     maintain_label: str = "alissa:maintain"
     maintain_enabled: bool = True
 
+    # The third staleness signal (session liveness, read from the reaper's own
+    # tmux listing) and the auto-resume it unlocks: a stale attempt whose
+    # ledger session is provably gone is respawned with RESUME_DIRECTIVE /
+    # FIX_RESUME_DIRECTIVE instead of parking the lane behind an operator
+    # ping. Provably gone is necessary, not sufficient: a healthy handoff ends
+    # in `alissa tmux kill` too, so on the ISSUE edge the resume additionally
+    # requires the linked PR to show the handoff never happened AND to be this
+    # issue's own work -- exactly one linked open PR, still a DRAFT, no
+    # reviewer requested, authored by the token identity, daemon-shaped head
+    # ref, and a body that CLOSES this issue (a cross-reference is raised by
+    # any mention, so a sibling task's PR would otherwise qualify). Default ON
+    # -- it closes the loop's one
+    # deliberate self-healing gap, and every side effect still honors dry_run.
+    # false restores the legacy two-signal matrix WHOLESALE on both edges (the
+    # floored defer, no liveness lookup, no resume): the escape hatch for an
+    # operator who wants a dead-with-PR lane to wait for a human.
+    resume_enabled: bool = True
+
     dry_run: bool = False
 
     # Derived at build time: `repos` casefolded for matching. GitHub names are
@@ -316,6 +335,9 @@ class Config:
             maintain_enabled=bool(
                 raw.get("maintain_enabled", cls.maintain_enabled)
             ),
+            resume_enabled=bool(
+                raw.get("resume_enabled", cls.resume_enabled)
+            ),
             dry_run=bool(raw.get("dry_run", cls.dry_run)),
         )
 

{alissa_tools_github_devloop-0.5.0 → alissa_tools_github_devloop-0.6.0}/src/main/alissa/tools/github/devloop/ghclient.py

@@ -107,6 +107,13 @@ class PullRequest:
     head_sha: str
     draft: bool
     url: str
+    # The PR description. Carried for PROVENANCE: a cross-reference proves
+    # only that a PR mentioned an issue, while a closing keyword ("Closes
+    # #<n>") is the author's claim that this PR is the issue's work -- the
+    # one the developer directives mandate, and the only thing that tells
+    # THIS issue's PR from a sibling task's PR that merely said "related to
+    # #<n>". Empty when the PR has no body.
+    body: 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
@@ -147,6 +154,20 @@ class Review:
         return bool(self.body.strip())
 
 
+@dataclass(frozen=True)
+class IssueComment:
+    """An issue comment on an issue OR a PR (a PR is an issue on the issues
+    endpoints). Distinct from Review: issue comments live on the
+    `/issues/{n}/comments` endpoints and never create review records, so
+    posting or PATCHing one can never disturb the fix edge's round counting
+    or its author-activity liveness probe -- the non-interference the
+    mechanical activity comment leans on."""
+
+    id: int
+    author: str
+    body: str
+
+
 class RateLimited(RuntimeError):
     pass
 
@@ -522,9 +543,11 @@ class GitHub:
         return newest
 
     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."""
+        """The evaluate_pr() re-fetch: draft state, head, author, body, and
+        the pending review requests -- the consistency guard over search
+        staleness, like issue() is for the issue edge. (The body is what the
+        issue edge's resume probe reads for provenance; it rides along on the
+        same GET rather than costing a call of its own.)"""
         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
@@ -550,6 +573,8 @@ class GitHub:
             head_sha=head.get("sha") or "",
             draft=bool(data.get("draft")),
             url=data.get("html_url", ""),
+            # `or ""`: GitHub sends null for an empty description.
+            body=data.get("body") or "",
             requested_reviewers=requested,
         )
 
@@ -605,7 +630,14 @@ class GitHub:
             ),
         )
 
-    def linked_open_prs(self, owner: str, repo: str, number: int) -> list[str]:
+    def linked_open_prs(
+        self,
+        owner: str,
+        repo: str,
+        number: int,
+        *,
+        exhaustive: bool = False,
+    ) -> list[str]:
         """URLs of OPEN same-repo pull requests linked to the issue -- the
         external liveness signal behind the stale-retry decision.
 
@@ -633,10 +665,9 @@ 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 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
+        as dead (and respawn over it). The walk is bounded: by default it
+        stops as soon as a page has yielded any open same-repo PR (see
+        `exhaustive` below), 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
@@ -646,6 +677,21 @@ class GitHub:
         explicit `page=` loop is the safe shape for this client. Malformed
         events are skipped, never fatal -- one odd timeline entry must not
         wedge the staleness decision.
+
+        `exhaustive` picks WHICH question the walk answers. Default False is
+        the boolean one -- is ANY open same-repo PR linked? -- and stops at
+        the first page that yields a URL, because for that question later
+        pages can only lengthen a log message. True keeps walking to the
+        short page (or the TIMELINE_MAX_PAGES ceiling) and returns the
+        COMPLETE set within it: the issue edge's resume probe does not ask
+        whether a PR is linked but WHICH one, and it deliberately refuses to
+        act on more than one candidate -- against a truncated list that
+        refusal is unreachable, because "exactly one survivor" can just mean
+        the second was on the next page, and the daemon would push to the one
+        it happened to page in. The ceiling applies to both modes: a
+        cross-reference past TIMELINE_MAX_PAGES * TIMELINE_PAGE_SIZE events
+        is invisible either way, so `exhaustive` means complete UP TO the
+        documented ceiling, not unbounded.
         """
         same_repo_pull = f"https://github.com/{owner}/{repo}/pull/"
         urls: list[str] = []
@@ -682,11 +728,13 @@ 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.
+            if urls and not exhaustive:
+                # The DEFAULT 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. An `exhaustive` caller is
+                # asking which PR, not whether, and for THAT question the
+                # later pages are the whole point -- so it keeps walking.
                 break
             if len(events) < TIMELINE_PAGE_SIZE:
                 break  # short page: the timeline is exhausted
@@ -739,3 +787,50 @@ class GitHub:
             "-f",
             f"body={body}",
         )
+
+    def issue_comments(
+        self, owner: str, repo: str, number: int
+    ) -> list[IssueComment]:
+        """Issue comments on an issue or PR (find-or-create reads these to
+        locate THE activity comment). per_page=100 is a documented single-page
+        window like the searches -- the activity comment is authored by the
+        daemon itself, so it lands on the first page unless a hundred other
+        comments were filed after it, and even then find-or-create degrades to
+        creating a second activity comment, never to touching a foreign one.
+        Malformed entries are tolerated (never fatal): one odd comment must not
+        wedge a spawn's telemetry."""
+        data = (
+            self._api(
+                "-X",
+                "GET",
+                f"repos/{owner}/{repo}/issues/{number}/comments",
+                "-f",
+                "per_page=100",
+            )
+            or []
+        )
+        if not isinstance(data, list):
+            return []
+        return [
+            IssueComment(
+                id=int(c.get("id") or 0),
+                author=(c.get("user") or {}).get("login", ""),
+                body=c.get("body") or "",
+            )
+            for c in data
+            if isinstance(c, dict)
+        ]
+
+    def update_comment(
+        self, owner: str, repo: str, comment_id: int, body: str
+    ) -> None:
+        """PATCH an existing issue comment's body -- the append half of the
+        activity comment's find-or-create. Keyed on the comment id, so it only
+        ever rewrites a comment the caller already located and authored."""
+        self._api(
+            "-X",
+            "PATCH",
+            f"repos/{owner}/{repo}/issues/comments/{comment_id}",
+            "-f",
+            f"body={body}",
+        )