claude-dev-env 8.54.1 → 8.54.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.54.1",
+    "version": "8.54.2",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

package/scripts/dev_env_scripts_constants/review_closure_constants.py

@@ -30,10 +30,16 @@ CHECK_RUN_PAGE_SIZE: int = 100
 """How many check runs one request asks for."""
 
 REVIEW_THREAD_QUERY: str = """
-query($owner: String!, $name: String!, $number: Int!, $pageSize: Int!) {
+query(
+  $owner: String!, $name: String!, $number: Int!, $pageSize: Int!, $after: String
+) {
   repository(owner: $owner, name: $name) {
     pullRequest(number: $number) {
-      reviewThreads(first: $pageSize) {
+      reviewThreads(first: $pageSize, after: $after) {
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
         nodes {
           path
           isResolved
@@ -52,14 +58,13 @@ query($owner: String!, $name: String!, $number: Int!, $pageSize: Int!) {
 """
 """GraphQL query for the review threads on one pull request."""
 
-ALL_THREAD_NODE_KEYS: tuple[str, ...] = (
+ALL_THREAD_CONNECTION_KEYS: tuple[str, ...] = (
     "data",
     "repository",
     "pullRequest",
     "reviewThreads",
-    "nodes",
 )
-"""Path from the GraphQL answer down to the review-thread list."""
+"""Path from the GraphQL answer down to the review-thread connection."""
 
 ALL_RESOLVED_KEYS: tuple[str, ...] = ("isResolved", "resolved", "is_resolved")
 """Field names either route uses for a resolved review thread."""
@@ -174,6 +179,29 @@ NUMBER_VARIABLE: str = "number"
 PAGE_SIZE_VARIABLE: str = "pageSize"
 """GraphQL variable naming the page size."""
 
+AFTER_VARIABLE: str = "after"
+"""GraphQL variable naming the cursor a page starts after."""
+
+NODES_KEY: str = "nodes"
+"""GraphQL connection field carrying one page of records."""
+
+PAGE_INFO_KEY: str = "pageInfo"
+"""GraphQL connection field describing the page boundaries."""
+
+HAS_NEXT_PAGE_KEY: str = "hasNextPage"
+"""Page-info field that is true while more records follow."""
+
+END_CURSOR_KEY: str = "endCursor"
+"""Page-info field naming the cursor the next page starts after."""
+
+MAX_REVIEW_THREAD_PAGES: int = 20
+"""How many review-thread pages one read follows before it reports an error."""
+
+TOO_MANY_THREAD_PAGES_TEMPLATE: str = (
+    "review threads on {slug}#{number} span more than {page_count} pages"
+)
+"""Error raised when the review threads outrun the page limit."""
+
 ALL_TOKEN_ENVIRONMENT_VARIABLES: tuple[str, ...] = (
     "GITHUB_TOKEN",
     "GH_TOKEN",

package/scripts/review_closure_github.py

@@ -26,20 +26,26 @@ import urllib.request
 from collections.abc import Mapping, Sequence
 
 from dev_env_scripts_constants.review_closure_constants import (
-    ALL_THREAD_NODE_KEYS,
+    AFTER_VARIABLE,
+    ALL_THREAD_CONNECTION_KEYS,
     ALL_TOKEN_ENVIRONMENT_VARIABLES,
     CHECK_RUN_PAGE_SIZE,
     CHECK_RUNS_ENDPOINT_TEMPLATE,
     CHECK_RUNS_KEY,
     COMMENT_PAGE_SIZE,
+    END_CURSOR_KEY,
     GET_METHOD,
     GITHUB_API_ROOT,
     GITHUB_GRAPHQL_ENDPOINT,
+    HAS_NEXT_PAGE_KEY,
     MAX_COMMENT_PAGES,
+    MAX_REVIEW_THREAD_PAGES,
     NAME_VARIABLE,
     NO_SIGN_IN_MESSAGE,
+    NODES_KEY,
     NUMBER_VARIABLE,
     OWNER_VARIABLE,
+    PAGE_INFO_KEY,
     PAGE_SIZE_VARIABLE,
     POST_METHOD,
     PULL_REQUEST_ENDPOINT_TEMPLATE,
@@ -51,6 +57,7 @@ from dev_env_scripts_constants.review_closure_constants import (
     REVIEW_THREAD_QUERY,
     REVIEW_THREADS_ENDPOINT_TEMPLATE,
     SLUG_SEPARATOR,
+    TOO_MANY_THREAD_PAGES_TEMPLATE,
     TOP_LEVEL_COMMENTS_ENDPOINT_TEMPLATE,
     UNREADABLE_TOP_LEVEL_COMMENT_TEMPLATE,
     VARIABLES_KEY,
@@ -372,21 +379,46 @@ def _thread_records_over_rest(
 
 
 def _thread_records_over_graphql(slug: str, number: int, token: str) -> list[object]:
+    all_records: list[object] = []
+    after_cursor: object = None
+    for _ in range(MAX_REVIEW_THREAD_PAGES):
+        page_records, after_cursor = _thread_page_over_graphql(
+            slug, number, token, after_cursor
+        )
+        all_records.extend(page_records)
+        if after_cursor is None:
+            return all_records
+    raise GitHubError(
+        TOO_MANY_THREAD_PAGES_TEMPLATE.format(
+            slug=slug, number=number, page_count=MAX_REVIEW_THREAD_PAGES
+        )
+    )
+
+
+def _thread_page_over_graphql(
+    slug: str, number: int, token: str, after_cursor: object
+) -> tuple[list[object], object]:
     document = request_json(
         POST_METHOD,
         GITHUB_GRAPHQL_ENDPOINT,
         token,
-        _thread_query_payload(slug, number),
+        _thread_query_payload(slug, number, after_cursor),
     )
-    all_records = functools.reduce(
-        functools.partial(_field_at, document), ALL_THREAD_NODE_KEYS, document
+    connection = functools.reduce(
+        functools.partial(_field_at, document), ALL_THREAD_CONNECTION_KEYS, document
     )
-    if not isinstance(all_records, list):
+    page_records = _field_at(document, connection, NODES_KEY)
+    if not isinstance(page_records, list):
         raise GitHubError(str(document))
-    return all_records
+    page_info = _field_at(document, connection, PAGE_INFO_KEY)
+    if not isinstance(page_info, Mapping) or not page_info.get(HAS_NEXT_PAGE_KEY):
+        return page_records, None
+    return page_records, page_info.get(END_CURSOR_KEY)
 
 
-def _thread_query_payload(slug: str, number: int) -> dict[str, object]:
+def _thread_query_payload(
+    slug: str, number: int, after_cursor: object
+) -> dict[str, object]:
     owner, _, name = slug.partition(SLUG_SEPARATOR)
     return {
         QUERY_KEY: REVIEW_THREAD_QUERY,
@@ -395,6 +427,7 @@ def _thread_query_payload(slug: str, number: int) -> dict[str, object]:
             NAME_VARIABLE: name,
             NUMBER_VARIABLE: number,
             PAGE_SIZE_VARIABLE: REVIEW_THREAD_PAGE_SIZE,
+            AFTER_VARIABLE: after_cursor,
         },
     }
 

package/scripts/tests/test_review_closure_github.py

@@ -192,6 +192,76 @@ def should_fall_back_to_the_graphql_query(monkeypatch: pytest.MonkeyPatch) -> No
     assert any("graphql" in each_url for each_url in all_requested_urls)
 
 
+def _thread_page(path: str, end_cursor: str | None) -> dict[str, object]:
+    return {
+        "data": {
+            "repository": {
+                "pullRequest": {
+                    "reviewThreads": {
+                        "pageInfo": {
+                            "hasNextPage": end_cursor is not None,
+                            "endCursor": end_cursor,
+                        },
+                        "nodes": [
+                            {
+                                "path": path,
+                                "isResolved": False,
+                                "isOutdated": False,
+                                "comments": {"nodes": []},
+                            }
+                        ],
+                    }
+                }
+            }
+        }
+    }
+
+
+def should_read_every_graphql_page_of_review_threads(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    all_pages_by_cursor = {
+        None: _thread_page("scripts/first.py", "cursor-1"),
+        "cursor-1": _thread_page("scripts/second.py", None),
+    }
+    all_requested_cursors: list[object] = []
+
+    @contextmanager
+    def fake_urlopen(request: object, timeout: int = 0) -> Iterator[FakeReply]:
+        if "ccr/review_threads" in request.full_url:
+            yield FakeReply(404, {})
+            return
+        cursor = json.loads(request.data)["variables"].get("after")
+        all_requested_cursors.append(cursor)
+        yield FakeReply(200, all_pages_by_cursor[cursor])
+
+    monkeypatch.setattr(reader.urllib.request, "urlopen", fake_urlopen)
+
+    all_threads = reader.read_review_threads("jl-cmd/claude-dev-env", 7, TOKEN)
+
+    assert [each.subject for each in all_threads] == [
+        "scripts/first.py",
+        "scripts/second.py",
+    ]
+    assert all_requested_cursors == [None, "cursor-1"]
+
+
+def should_report_review_threads_that_outrun_the_page_limit(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    @contextmanager
+    def fake_urlopen(request: object, timeout: int = 0) -> Iterator[FakeReply]:
+        if "ccr/review_threads" in request.full_url:
+            yield FakeReply(404, {})
+            return
+        yield FakeReply(200, _thread_page("scripts/endless.py", "cursor-next"))
+
+    monkeypatch.setattr(reader.urllib.request, "urlopen", fake_urlopen)
+
+    with pytest.raises(GitHubError):
+        reader.read_review_threads("jl-cmd/claude-dev-env", 7, TOKEN)
+
+
 def should_report_a_graphql_answer_carrying_no_threads(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None: