claude-dev-env 8.48.3 → 8.48.4

package/package.json

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

package/scripts/agent_merge_check.py

@@ -607,6 +607,7 @@ def read_pull_request(slug: str, number: int, token: str) -> Mapping[str, object
 def read_blocked_evidence(
     slug: str,
     all_pull_request_fields: Mapping[str, object],
+    all_rules: list[object] | MergeCheckError,
     token: str,
 ) -> BlockedEvidence:
     """Read what stands behind a ``blocked`` merge state.
@@ -615,6 +616,8 @@ def read_blocked_evidence(
         slug: The repository as ``owner/name``.
         all_pull_request_fields: The pull request, carrying its base branch
             and its head commit.
+        all_rules: The base branch rules, or the failure that kept them
+            unread.
         token: The GitHub token the requests authenticate with.
 
     Returns:
@@ -628,7 +631,8 @@ def read_blocked_evidence(
         str(_nested_field(all_pull_request_fields, BASE_KEY, REF_KEY))
     )
     head_sha = str(_nested_field(all_pull_request_fields, HEAD_KEY, SHA_KEY))
-    all_rules = _read_branch_rules(slug, base_ref, token)
+    if isinstance(all_rules, MergeCheckError):
+        raise all_rules
     return BlockedEvidence(
         all_unmet_checks=_read_unmet_checks(slug, head_sha, all_rules, token),
         behind_by=_read_behind_by(slug, base_ref, head_sha, token),
@@ -636,13 +640,30 @@ def read_blocked_evidence(
     )
 
 
-def _read_branch_rules(slug: str, base_ref: str, token: str) -> list[object]:
-    return _request_list(
-        BRANCH_RULES_ENDPOINT_TEMPLATE.format(
-            api_root=GITHUB_API_ROOT, slug=slug, branch=base_ref
-        ),
-        token,
-    )
+def read_branch_rules(
+    slug: str, base_ref: str, token: str
+) -> list[object] | MergeCheckError:
+    """Read the rules GitHub reports as active on the base branch.
+
+    Args:
+        slug: The repository as ``owner/name``.
+        base_ref: The branch the pull request merges into.
+        token: The GitHub token the request authenticates with.
+
+    Returns:
+        The rules, or the failure that kept them unread.
+    """
+    try:
+        return _request_list(
+            BRANCH_RULES_ENDPOINT_TEMPLATE.format(
+                api_root=GITHUB_API_ROOT,
+                slug=slug,
+                branch=urllib.parse.quote(base_ref),
+            ),
+            token,
+        )
+    except MergeCheckError as failure:
+        return failure
 
 
 def read_unstable_checks(
@@ -879,7 +900,11 @@ def _field_at(document: object, all_fields: object, key: str) -> object:
 
 
 def read_merge_queue_ejection(
-    slug: str, number: int, base_ref: str, token: str
+    slug: str,
+    number: int,
+    base_ref: str,
+    all_rules: list[object] | MergeCheckError,
+    token: str,
 ) -> bool:
     """Read whether the merge queue ejected the pull request's current head.
 
@@ -891,6 +916,8 @@ def read_merge_queue_ejection(
         slug: The repository as ``owner/name``.
         number: The pull request number.
         base_ref: The branch the pull request merges into.
+        all_rules: The base branch rules, or the failure that kept them
+            unread.
         token: The GitHub token the request authenticates with.
 
     Returns:
@@ -901,7 +928,9 @@ def read_merge_queue_ejection(
         MergeCheckError: A read failed, or answered with another shape. A
             refused GraphQL query names the merge queue that needed it.
     """
-    if not _may_merge_through_a_queue(slug, base_ref, token):
+    if not isinstance(all_rules, MergeCheckError) and not has_merge_queue_rule(
+        all_rules
+    ):
         return False
     document = _merge_queue_removal_document(slug, number, base_ref, token)
     return _is_ejected_on_head(
@@ -924,14 +953,6 @@ def _merge_queue_removal_document(
         ) from failure
 
 
-def _may_merge_through_a_queue(slug: str, base_ref: str, token: str) -> bool:
-    try:
-        all_rules = _read_branch_rules(slug, urllib.parse.quote(base_ref), token)
-    except MergeCheckError:
-        return True
-    return has_merge_queue_rule(all_rules)
-
-
 def _list_along(document: object, all_keys: Sequence[str]) -> list[object]:
     all_records = functools.reduce(
         functools.partial(_field_at, document), all_keys, document
@@ -1009,11 +1030,10 @@ def main(all_arguments: Sequence[str]) -> int:
         unresolved_thread_count = read_unresolved_thread_count(
             parsed.slug, parsed.number, token
         )
+        base_ref = str(_nested_field(all_pull_request_fields, BASE_KEY, REF_KEY))
+        all_rules = read_branch_rules(parsed.slug, base_ref, token)
         is_ejected_from_merge_queue = read_merge_queue_ejection(
-            parsed.slug,
-            parsed.number,
-            str(_nested_field(all_pull_request_fields, BASE_KEY, REF_KEY)),
-            token,
+            parsed.slug, parsed.number, base_ref, all_rules, token
         )
     except MergeCheckError as failure:
         print(failure, file=sys.stderr)
@@ -1022,7 +1042,7 @@ def main(all_arguments: Sequence[str]) -> int:
     if all_pull_request_fields.get(MERGEABLE_STATE_KEY) == MERGEABLE_STATE_BLOCKED:
         try:
             blocked_evidence = read_blocked_evidence(
-                parsed.slug, all_pull_request_fields, token
+                parsed.slug, all_pull_request_fields, all_rules, token
             )
         except MergeCheckError as failure:
             print(failure, file=sys.stderr)

package/scripts/test_agent_merge_check.py

@@ -291,10 +291,15 @@ def test_a_ready_pull_request_exits_zero(monkeypatch: pytest.MonkeyPatch) -> Non
         "read_unresolved_thread_count",
         lambda slug, number, token: 0,
     )
+    monkeypatch.setattr(
+        agent_merge_check,
+        "read_branch_rules",
+        lambda slug, base_ref, token: [],
+    )
     monkeypatch.setattr(
         agent_merge_check,
         "read_merge_queue_ejection",
-        lambda slug, number, base_ref, token: False,
+        lambda slug, number, base_ref, all_rules, token: False,
     )
     assert agent_merge_check.main(["jl-cmd/claude-dev-env", "1442"]) == 0
 
@@ -311,10 +316,15 @@ def test_a_held_pull_request_exits_one(monkeypatch: pytest.MonkeyPatch) -> None:
         "read_unresolved_thread_count",
         lambda slug, number, token: 0,
     )
+    monkeypatch.setattr(
+        agent_merge_check,
+        "read_branch_rules",
+        lambda slug, base_ref, token: [],
+    )
     monkeypatch.setattr(
         agent_merge_check,
         "read_merge_queue_ejection",
-        lambda slug, number, base_ref, token: False,
+        lambda slug, number, base_ref, all_rules, token: False,
     )
     assert agent_merge_check.main(["jl-cmd/claude-dev-env", "1442"]) == 1
 
@@ -491,6 +501,65 @@ def test_an_unreadable_branch_rule_keeps_the_generic_blocked_reason(
     assert BLOCKED_HOLD_REASON in line
 
 
+def test_a_blocked_pull_request_reads_the_branch_rules_once(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    routed_answer = _github_answers(
+        MAIN_BRANCH_RULES,
+        [
+            _check_run("Ruff", "success", run_id=11),
+            _check_run("Tip Local green", "success", run_id=12),
+        ],
+        behind_by=225,
+    )
+    all_rules_urls: list[str] = []
+
+    def _answer(url: str, token: str, all_payload_fields: object) -> object:
+        if "/rules/branches/" in url:
+            all_rules_urls.append(url)
+        return routed_answer(url, token, all_payload_fields)
+
+    exit_code, line = _run_main(monkeypatch, capsys, _answer)
+    assert exit_code == 1
+    assert BEHIND_MERGE_QUEUE_HOLD_TEMPLATE.format(count=225) in line
+    assert len(all_rules_urls) == 1
+
+
+def test_read_branch_rules_quotes_the_base_branch_and_returns_its_rules(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    all_rules_urls: list[str] = []
+
+    def _answer(url: str, token: str, all_payload_fields: object) -> object:
+        all_rules_urls.append(url)
+        return MAIN_BRANCH_RULES
+
+    monkeypatch.setattr(agent_merge_check, "_request_json", _answer)
+    assert (
+        agent_merge_check.read_branch_rules(
+            "jl-cmd/claude-dev-env", "release/2026 q4", "token"
+        )
+        == MAIN_BRANCH_RULES
+    )
+    assert all_rules_urls[0].endswith("/rules/branches/release/2026%20q4")
+
+
+def test_read_branch_rules_returns_the_failure_of_a_refused_read(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    refusal = agent_merge_check.MergeCheckError("HTTP Error 403: Forbidden")
+
+    def _refuse(url: str, token: str, all_payload_fields: object) -> object:
+        raise refusal
+
+    monkeypatch.setattr(agent_merge_check, "_request_json", _refuse)
+    assert (
+        agent_merge_check.read_branch_rules("jl-cmd/claude-dev-env", "main", "token")
+        is refusal
+    )
+
+
 def _evidence(
     all_unmet_checks: tuple[str, ...] = (),
     behind_by: int = 0,
@@ -626,7 +695,7 @@ def test_read_blocked_evidence_reads_the_pull_request_4922_shape(
         ),
     )
     assert agent_merge_check.read_blocked_evidence(
-        "jl-cmd/claude-dev-env", PULL_REQUEST_4922, "token"
+        "jl-cmd/claude-dev-env", PULL_REQUEST_4922, MAIN_BRANCH_RULES, "token"
     ) == _evidence(behind_by=225)
 
 
@@ -821,7 +890,7 @@ def test_read_merge_queue_ejection_compares_failed_checks_removals_to_the_head(
     )
     assert (
         agent_merge_check.read_merge_queue_ejection(
-            "jl-cmd/claude-dev-env", 1442, "main", "token"
+            "jl-cmd/claude-dev-env", 1442, "main", MAIN_BRANCH_RULES, "token"
         )
         is expected_ejection
     )