alissa-tools-github-devloop 0.8.31__py3-none-any.whl → 0.8.33__py3-none-any.whl

alissa/tools/github/devloop/ghclient.py

@@ -53,6 +53,13 @@ FIRST_PARENT_MAX_PAGES = 3
 SUBMITTED_STATES = {"APPROVED", "CHANGES_REQUESTED", "COMMENTED", "DISMISSED"}
 
 
+# The states `GitHub.linked_pull_requests` reports a cross-referenced pull request in
+# (issue #144): still open, merged, or closed without a merge.
+PR_OPEN = "open"
+PR_MERGED = "merged"
+PR_CLOSED = "closed"
+
+
 def parse_github_timestamp(ts: "str | None") -> "int | None":
     """A GitHub API timestamp (`2026-07-23T02:13:56Z`) as unix seconds, or
     None when absent/unparseable. GitHub emits UTC `Z` timestamps
@@ -1325,8 +1332,45 @@ class GitHub:
         is invisible either way, so `exhaustive` means complete UP TO the
         documented ceiling, not unbounded.
         """
+        return [
+            url
+            for url, state in self.linked_pull_requests(
+                owner, repo, number, exhaustive=exhaustive
+            )
+            if state == PR_OPEN
+        ]
+
+    def linked_pull_requests(
+        self,
+        owner: str,
+        repo: str,
+        number: int,
+        *,
+        exhaustive: bool = False,
+    ) -> "list[tuple[str, str]]":
+        """Every same-repo pull request the issue's timeline cross-references,
+        in ANY state, as `(url, state)` pairs -- `state` is `PR_OPEN`,
+        `PR_MERGED` or `PR_CLOSED` (closed without a merge). The one walk
+        behind `linked_open_prs` (which filters it to the open ones) and the
+        issue edge's respawn rule (issue #144, design studio.alissa.app
+        docs/design/loop-operator-surface.md §8.4): a DEAD session's lane
+        with no open PR is only an implement-phase death when no MERGED or
+        closed PR claims the issue either -- 2026-09-28, an operator's hand
+        merge closed issue #1620 two seconds before the daemon read "no PR
+        opened" off the open-only probe and spawned a duplicate lane.
+
+        Merged is read off the cross-reference's own payload
+        (`source.issue.pull_request.merged_at`), so the walk costs nothing
+        more than it did; the caller still fetches a candidate before acting
+        on it, because a cross-reference proves only a MENTION (provenance is
+        the fetched body's closing keyword and author). The walk, its bounds,
+        its same-repo filter and the `exhaustive` switch are exactly
+        `linked_open_prs`'s: the default stops at the first page that yields
+        an OPEN PR (closed ones never stop it), so a lane with no open PR
+        walks the whole timeline -- up to TIMELINE_MAX_PAGES -- and sees
+        every closed one."""
         same_repo_pull = f"https://github.com/{owner}/{repo}/pull/"
-        urls: list[str] = []
+        found: "dict[str, str]" = {}
         for page in range(1, TIMELINE_MAX_PAGES + 1):
             events = (
                 self._api(
@@ -1352,15 +1396,25 @@ class GitHub:
                 src = source.get("issue") if isinstance(source, dict) else None
                 if not isinstance(src, dict):
                     continue
-                if not src.get("pull_request"):
+                pull = src.get("pull_request")
+                if not pull:
                     continue  # the cross-reference came from a plain issue
-                if src.get("state") != "open":
-                    continue
                 url = src.get("html_url") or ""
                 if not url.startswith(same_repo_pull):
                     continue  # a mention from another repo says nothing here
-                urls.append(url)
-            if urls and not exhaustive:
+                if src.get("state") == "open":
+                    state = PR_OPEN
+                elif isinstance(pull, dict) and pull.get("merged_at"):
+                    state = PR_MERGED
+                elif src.get("state") == "closed":
+                    state = PR_CLOSED
+                else:
+                    continue  # no readable state: never guess
+                # One PR can cross-reference the issue more than once (body
+                # edit, comment mention); report it once, in its first
+                # position -- the state is the PR's, not the event's.
+                found.setdefault(url, state)
+            if not exhaustive and PR_OPEN in found.values():
                 # 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
@@ -1370,9 +1424,7 @@ class GitHub:
                 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,
-        # comment mention); report it once.
-        return list(dict.fromkeys(urls))
+        return list(found.items())
 
     def assign_self(self, owner: str, repo: str, number: int) -> None:
         """Assign the token identity -- the server-side in-flight marker.