claude-dev-env 8.19.1 → 8.20.0

package/scripts/test_agent_merge_check.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import sys
+import urllib.parse
 from pathlib import Path
 
 import pytest
@@ -14,6 +15,7 @@ if str(_SCRIPTS_DIRECTORY) not in sys.path:
 import agent_merge_check
 from dev_env_scripts_constants.agent_merge_check_constants import (
     BEHIND_HOLD_REASON,
+    BEHIND_MERGE_QUEUE_HOLD_TEMPLATE,
     BLOCKED_HOLD_REASON,
     DIRTY_HOLD_REASON,
     DRAFT_HOLD_REASON,
@@ -288,6 +290,11 @@ 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_merge_queue_ejection",
+        lambda slug, number, token: False,
+    )
     assert agent_merge_check.main(["jl-cmd/claude-dev-env", "1442"]) == 0
 
 
@@ -303,6 +310,11 @@ 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_merge_queue_ejection",
+        lambda slug, number, token: False,
+    )
     assert agent_merge_check.main(["jl-cmd/claude-dev-env", "1442"]) == 1
 
 
@@ -315,3 +327,458 @@ def test_an_unreadable_pull_request_exits_two(
     monkeypatch.setenv("GH_TOKEN", "token")
     monkeypatch.setattr(agent_merge_check, "read_pull_request", _fail)
     assert agent_merge_check.main(["jl-cmd/claude-dev-env", "1442"]) == 2
+
+
+HEAD_COMMITTED_AT = "2026-09-26T16:00:00Z"
+PULL_REQUEST_4922_HEAD_SHA = "06bc18a1a8761a16e92c1419693a42f22dd4ae7c"
+REQUIRED_CHECK_APP_ID = 15368
+PULL_REQUEST_4922 = {
+    "number": 4922,
+    "draft": False,
+    "mergeable_state": "blocked",
+    "base": {"ref": "main"},
+    "head": {"sha": PULL_REQUEST_4922_HEAD_SHA},
+}
+MAIN_BRANCH_RULES = [
+    {
+        "type": "required_status_checks",
+        "parameters": {
+            "strict_required_status_checks_policy": False,
+            "required_status_checks": [
+                {"context": "Ruff", "integration_id": REQUIRED_CHECK_APP_ID},
+                {"context": "Tip Local green", "integration_id": REQUIRED_CHECK_APP_ID},
+            ],
+        },
+    },
+    {"type": "merge_queue", "parameters": {"merge_method": "MERGE"}},
+]
+
+
+def _check_run(
+    name: str,
+    conclusion: str | None,
+    run_id: int = 1,
+    app_id: int = REQUIRED_CHECK_APP_ID,
+    status: str = "completed",
+) -> dict[str, object]:
+    return {
+        "id": run_id,
+        "name": name,
+        "status": status,
+        "conclusion": conclusion,
+        "app": {"id": app_id},
+    }
+
+
+def _github_answers(
+    all_rules: list[object],
+    all_check_runs: list[dict[str, object]],
+    behind_by: int,
+    all_statuses: list[object] | None = None,
+) -> object:
+    def _answer(url: str, token: str, all_payload_fields: object) -> object:
+        parsed = urllib.parse.urlparse(url)
+        if parsed.path.endswith("/pulls/4922"):
+            return PULL_REQUEST_4922
+        if parsed.path.endswith("/ccr/review_threads"):
+            return []
+        if "/rules/branches/" in parsed.path:
+            return all_rules
+        if parsed.path.endswith("/check-runs"):
+            check_name = urllib.parse.parse_qs(parsed.query)["check_name"][0]
+            return {
+                "check_runs": [
+                    each_run
+                    for each_run in all_check_runs
+                    if each_run["name"] == check_name
+                ]
+            }
+        if parsed.path.endswith("/status"):
+            return {"statuses": all_statuses or []}
+        if "/compare/" in parsed.path:
+            return {"behind_by": behind_by, "ahead_by": 1}
+        if parsed.path.endswith("/graphql"):
+            return _merge_queue_document([])
+        raise AssertionError(url)
+
+    return _answer
+
+
+def _merge_queue_document(all_removals: list[dict[str, object]]) -> object:
+    return {
+        "data": {
+            "repository": {
+                "pullRequest": {
+                    "commits": {
+                        "nodes": [{"commit": {"committedDate": HEAD_COMMITTED_AT}}]
+                    },
+                    "timelineItems": {"nodes": all_removals},
+                }
+            }
+        }
+    }
+
+
+def _run_main(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+    answer: object,
+) -> tuple[int, str]:
+    monkeypatch.setenv("GH_TOKEN", "token")
+    monkeypatch.setattr(agent_merge_check, "_request_json", answer)
+    exit_code = agent_merge_check.main(["jl-cmd/claude-dev-env", "4922"])
+    return exit_code, capsys.readouterr().out
+
+
+def test_a_green_head_behind_a_merge_queue_base_reports_the_behind_reason(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    exit_code, line = _run_main(
+        monkeypatch,
+        capsys,
+        _github_answers(
+            MAIN_BRANCH_RULES,
+            [
+                _check_run("Ruff", "success", run_id=11),
+                _check_run("Tip Local green", "success", run_id=12),
+            ],
+            behind_by=225,
+        ),
+    )
+    assert exit_code == 1
+    assert BEHIND_MERGE_QUEUE_HOLD_TEMPLATE.format(count=225) in line
+    assert BLOCKED_HOLD_REASON not in line
+    assert "06bc18a" in line
+
+
+def test_a_red_required_check_is_named_ahead_of_the_behind_reason(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    exit_code, line = _run_main(
+        monkeypatch,
+        capsys,
+        _github_answers(
+            MAIN_BRANCH_RULES,
+            [
+                _check_run("Ruff", "success", run_id=11),
+                _check_run("Tip Local green", "failure", run_id=12),
+            ],
+            behind_by=225,
+        ),
+    )
+    assert exit_code == 1
+    assert "Tip Local green (failure)" in line
+    assert "Ruff" not in line
+    assert "behind" not in line
+
+
+def test_an_unreadable_branch_rule_keeps_the_generic_blocked_reason(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    routed_answer = _github_answers(MAIN_BRANCH_RULES, [], behind_by=225)
+
+    def _answer(url: str, token: str, all_payload_fields: object) -> object:
+        if "/rules/branches/" in url:
+            raise agent_merge_check.MergeCheckError("HTTP Error 403: Forbidden")
+        return routed_answer(url, token, all_payload_fields)
+
+    exit_code, line = _run_main(monkeypatch, capsys, _answer)
+    assert exit_code == 1
+    assert BLOCKED_HOLD_REASON in line
+
+
+def _evidence(
+    all_unmet_checks: tuple[str, ...] = (),
+    behind_by: int = 0,
+    has_merge_queue: bool = True,
+) -> agent_merge_check.BlockedEvidence:
+    return agent_merge_check.BlockedEvidence(
+        all_unmet_checks=all_unmet_checks,
+        behind_by=behind_by,
+        has_merge_queue=has_merge_queue,
+    )
+
+
+@pytest.mark.parametrize(
+    ("evidence", "expected_reason"),
+    [
+        (_evidence(behind_by=0), BLOCKED_HOLD_REASON),
+        (_evidence(behind_by=3, has_merge_queue=False), BLOCKED_HOLD_REASON),
+        (
+            _evidence(behind_by=3),
+            BEHIND_MERGE_QUEUE_HOLD_TEMPLATE.format(count=3),
+        ),
+    ],
+)
+def test_a_blocked_head_with_every_required_check_green_reads_its_reason(
+    evidence: agent_merge_check.BlockedEvidence,
+    expected_reason: str,
+) -> None:
+    assert (
+        agent_merge_check.hold_reason(
+            _pull_request(mergeable_state="blocked"), 0, evidence
+        )
+        == expected_reason
+    )
+
+
+def test_blocked_evidence_is_ignored_for_a_draft() -> None:
+    assert (
+        agent_merge_check.hold_reason(
+            _pull_request(mergeable_state="blocked", draft=True),
+            0,
+            _evidence(behind_by=3),
+        )
+        == DRAFT_HOLD_REASON
+    )
+
+
+def test_required_contexts_merge_every_required_status_checks_rule() -> None:
+    all_rules = [
+        *MAIN_BRANCH_RULES,
+        {
+            "type": "required_status_checks",
+            "parameters": {
+                "required_status_checks": [
+                    {"context": "Ruff", "integration_id": REQUIRED_CHECK_APP_ID},
+                    {"context": "Semgrep"},
+                ]
+            },
+        },
+    ]
+    assert agent_merge_check.required_contexts(all_rules) == (
+        agent_merge_check.RequiredContext("Ruff", REQUIRED_CHECK_APP_ID),
+        agent_merge_check.RequiredContext("Tip Local green", REQUIRED_CHECK_APP_ID),
+        agent_merge_check.RequiredContext("Semgrep", None),
+    )
+
+
+def test_a_rule_set_without_a_merge_queue_rule_reports_none() -> None:
+    assert agent_merge_check.has_merge_queue_rule(MAIN_BRANCH_RULES)
+    assert not agent_merge_check.has_merge_queue_rule(MAIN_BRANCH_RULES[:1])
+
+
+RUFF_FROM_REQUIRED_APP = agent_merge_check.RequiredContext(
+    "Ruff", REQUIRED_CHECK_APP_ID
+)
+
+
+@pytest.mark.parametrize(
+    ("all_check_runs", "all_statuses", "expected_state"),
+    [
+        ([_check_run("Ruff", "success")], [], None),
+        ([_check_run("Ruff", "skipped")], [], None),
+        ([_check_run("Ruff", "failure")], [], "failure"),
+        ([_check_run("Ruff", None, status="in_progress")], [], "pending"),
+        (
+            [
+                _check_run("Ruff", "failure", run_id=1),
+                _check_run("Ruff", "success", run_id=2),
+            ],
+            [],
+            None,
+        ),
+        (
+            [
+                _check_run("Ruff", "success", run_id=2),
+                _check_run("Ruff", "failure", run_id=3),
+            ],
+            [],
+            "failure",
+        ),
+        ([_check_run("Ruff", "success", app_id=1)], [], "missing"),
+        ([], [{"context": "Ruff", "state": "success"}], None),
+        ([], [{"context": "Ruff", "state": "pending"}], "pending"),
+        ([], [{"context": "Ruff", "state": "error"}], "error"),
+        ([], [], "missing"),
+    ],
+)
+def test_unmet_check_state_reads_the_newest_report_of_the_required_check(
+    all_check_runs: list[object],
+    all_statuses: list[object],
+    expected_state: str | None,
+) -> None:
+    assert (
+        agent_merge_check.unmet_check_state(
+            RUFF_FROM_REQUIRED_APP, all_check_runs, all_statuses
+        )
+        == expected_state
+    )
+
+
+def test_read_blocked_evidence_reads_the_pull_request_4922_shape(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        agent_merge_check,
+        "_request_json",
+        _github_answers(
+            MAIN_BRANCH_RULES,
+            [
+                _check_run("Ruff", "success", run_id=11),
+                _check_run("Tip Local green", "success", run_id=12),
+            ],
+            behind_by=225,
+        ),
+    )
+    assert agent_merge_check.read_blocked_evidence(
+        "jl-cmd/claude-dev-env", PULL_REQUEST_4922, "token"
+    ) == _evidence(behind_by=225)
+
+
+def test_blocked_hold_reason_names_every_unmet_required_check() -> None:
+    reason = agent_merge_check.blocked_hold_reason(
+        _evidence(
+            all_unmet_checks=("Ruff (failure)", "Tip Local green (missing)"),
+            behind_by=225,
+        )
+    )
+    assert "Ruff (failure), Tip Local green (missing)" in reason
+    assert "behind" not in reason
+
+
+QUEUED_PULL_REQUEST = {
+    "number": 1442,
+    "draft": False,
+    "mergeable_state": "clean",
+    "base": {"ref": "main"},
+    "head": {"sha": "ab845eb6945650055ebe852312a9057b9f067d6a"},
+}
+
+
+def _removal(created_at: str, reason: str) -> dict[str, object]:
+    return {"createdAt": created_at, "reason": reason}
+
+
+def _merge_queue_answers(
+    all_removals: list[dict[str, object]],
+) -> object:
+    def _answer(url: str, token: str, all_payload_fields: object) -> object:
+        if url.endswith("/pulls/1442"):
+            return QUEUED_PULL_REQUEST
+        if url.endswith("/ccr/review_threads"):
+            return []
+        if url.endswith("/graphql"):
+            return _merge_queue_document(all_removals)
+        raise AssertionError(url)
+
+    return _answer
+
+
+def _run_queued_main(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+    all_removals: list[dict[str, object]],
+) -> tuple[int, str]:
+    monkeypatch.setenv("GH_TOKEN", "token")
+    monkeypatch.setattr(
+        agent_merge_check, "_request_json", _merge_queue_answers(all_removals)
+    )
+    exit_code = agent_merge_check.main(["jl-cmd/claude-dev-env", "1442"])
+    return exit_code, capsys.readouterr().out
+
+
+def test_a_head_ejected_from_the_merge_queue_for_failed_checks_holds(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    exit_code, line = _run_queued_main(
+        monkeypatch,
+        capsys,
+        [
+            _removal("2026-09-26T15:09:20Z", "failed_checks"),
+            _removal("2026-09-26T17:11:35Z", "failed_checks"),
+        ],
+    )
+    assert exit_code == 1
+    assert line.startswith(HOLD_VERDICT_LABEL)
+    assert "merge queue" in line
+    assert "failed checks" in line
+    assert "merge_group" in line
+    assert "gh-readonly-queue/main/pr-1442-<sha>" in line
+    assert "before you enqueue it again" in line
+
+
+def test_a_fix_pushed_after_the_merge_queue_ejection_clears_the_hold(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    exit_code, line = _run_queued_main(
+        monkeypatch,
+        capsys,
+        [_removal("2026-09-26T15:09:20Z", "failed_checks")],
+    )
+    assert exit_code == 0
+    assert line.startswith(MERGE_VERDICT_LABEL)
+
+
+def test_a_manual_merge_queue_removal_does_not_hold(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    exit_code, line = _run_queued_main(
+        monkeypatch,
+        capsys,
+        [
+            _removal("2026-09-26T15:09:20Z", "failed_checks"),
+            _removal("2026-09-26T17:58:17Z", "manual"),
+        ],
+    )
+    assert exit_code == 0
+    assert line.startswith(MERGE_VERDICT_LABEL)
+
+
+def test_a_repository_with_no_merge_queue_removal_may_merge(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    exit_code, line = _run_queued_main(monkeypatch, capsys, [])
+    assert exit_code == 0
+    assert line.startswith(MERGE_VERDICT_LABEL)
+
+
+def test_a_merge_queue_answer_of_another_shape_exits_two(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    routed_answer = _merge_queue_answers([])
+
+    def _answer(url: str, token: str, all_payload_fields: object) -> object:
+        if url.endswith("/graphql"):
+            return {"errors": [{"message": "Bad credentials"}]}
+        return routed_answer(url, token, all_payload_fields)
+
+    monkeypatch.setenv("GH_TOKEN", "token")
+    monkeypatch.setattr(agent_merge_check, "_request_json", _answer)
+    assert agent_merge_check.main(["jl-cmd/claude-dev-env", "1442"]) == 2
+    assert capsys.readouterr().out == ""
+
+
+@pytest.mark.parametrize(
+    ("all_removals", "expected_ejection"),
+    [
+        ([_removal("2026-09-26T17:11:35Z", "failed_checks")], True),
+        ([_removal("2026-09-26T15:09:20Z", "failed_checks")], False),
+        ([_removal("2026-09-26T17:58:17Z", "manual")], False),
+        ([], False),
+    ],
+)
+def test_read_merge_queue_ejection_compares_failed_checks_removals_to_the_head(
+    monkeypatch: pytest.MonkeyPatch,
+    all_removals: list[dict[str, object]],
+    expected_ejection: bool,
+) -> None:
+    monkeypatch.setattr(
+        agent_merge_check,
+        "_request_json",
+        lambda url, token, all_payload_fields: _merge_queue_document(all_removals),
+    )
+    assert (
+        agent_merge_check.read_merge_queue_ejection(
+            "jl-cmd/claude-dev-env", 1442, "token"
+        )
+        is expected_ejection
+    )

package/scripts/tests/test_review_closure.py

@@ -139,6 +139,7 @@ def should_print_the_url_of_a_waiting_top_level_comment(
     bot_summary = model.TopLevelComment(
         identifier=1,
         author_login="qodo-merge-pro[bot]",
+        is_bot=True,
         created_at=posted,
         updated_at=posted,
         url=summary_url,

package/scripts/tests/test_review_closure_model.py

@@ -21,6 +21,7 @@ from dev_env_scripts_constants.review_closure_constants import (
 
 DRIVING_AGENT = frozenset({"claude[bot]"})
 REVIEW_BOT = "qodo-merge-pro[bot]"
+REVIEWER = "maintainer"
 
 
 def thread(
@@ -313,10 +314,12 @@ def top_level_comment(
     posted_minute: int,
     edited_minute: int | None = None,
     url: str = BOT_SUMMARY_URL,
+    is_bot: bool = True,
 ) -> model.TopLevelComment:
     return model.TopLevelComment(
         identifier=posted_minute,
         author_login=author_login,
+        is_bot=is_bot,
         created_at=at_minute(posted_minute),
         updated_at=at_minute(posted_minute if edited_minute is None else edited_minute),
         url=url,
@@ -355,9 +358,9 @@ def should_close_every_earlier_comment_with_one_driver_comment() -> None:
     assert model.top_level_findings(all_comments, DRIVING_AGENT) == ()
 
 
-def should_reopen_a_bot_comment_edited_after_the_driver_reply() -> None:
+def should_reopen_a_person_comment_edited_after_the_driver_reply() -> None:
     all_comments = (
-        top_level_comment(REVIEW_BOT, 1, edited_minute=5),
+        top_level_comment(REVIEWER, 1, edited_minute=5, is_bot=False),
         top_level_comment("claude[bot]", 2),
     )
 
@@ -366,6 +369,15 @@ def should_reopen_a_bot_comment_edited_after_the_driver_reply() -> None:
     assert [each.subject for each in all_findings] == [BOT_SUMMARY_URL]
 
 
+def should_keep_a_bot_summary_closed_when_edited_after_the_driver_reply() -> None:
+    all_comments = (
+        top_level_comment(REVIEW_BOT, 1, edited_minute=5),
+        top_level_comment("claude[bot]", 2),
+    )
+
+    assert model.top_level_findings(all_comments, DRIVING_AGENT) == ()
+
+
 def should_leave_a_bot_comment_posted_after_the_driver_open() -> None:
     all_comments = (
         top_level_comment("claude[bot]", 1),
@@ -403,9 +415,28 @@ def should_close_a_bot_comment_last_edited_at_the_driver_time() -> None:
     assert model.top_level_finding(comment, DRIVING_AGENT, at_minute(4)) is None
 
 
-def should_open_a_bot_comment_edited_after_the_driver_time() -> None:
+def should_open_a_person_comment_edited_after_the_driver_time() -> None:
+    comment = top_level_comment(REVIEWER, 1, edited_minute=5, is_bot=False)
+
+    assert model.top_level_finding(
+        comment, DRIVING_AGENT, at_minute(4)
+    ) == model.OpenFinding(
+        subject=BOT_SUMMARY_URL,
+        reason=TOP_LEVEL_OPEN_REASON_TEMPLATE.format(author=REVIEWER),
+    )
+
+
+def should_close_a_bot_comment_posted_before_and_edited_after_the_driver_time() -> (
+    None
+):
     comment = top_level_comment(REVIEW_BOT, 1, edited_minute=5)
 
+    assert model.top_level_finding(comment, DRIVING_AGENT, at_minute(4)) is None
+
+
+def should_open_a_bot_comment_posted_after_the_driver_time() -> None:
+    comment = top_level_comment(REVIEW_BOT, 5)
+
     assert model.top_level_finding(
         comment, DRIVING_AGENT, at_minute(4)
     ) == model.OpenFinding(
@@ -426,7 +457,7 @@ def should_read_a_top_level_comment_record() -> None:
     comment = model.parse_top_level_comment(
         {
             "id": 1,
-            "user": {"login": REVIEW_BOT},
+            "user": {"login": REVIEW_BOT, "type": "Bot"},
             "created_at": "2026-09-26T12:01:00Z",
             "updated_at": "2026-09-26T12:05:00Z",
             "html_url": BOT_SUMMARY_URL,
@@ -434,3 +465,17 @@ def should_read_a_top_level_comment_record() -> None:
     )
 
     assert comment == top_level_comment(REVIEW_BOT, 1, edited_minute=5)
+
+
+def should_read_a_person_top_level_comment_record() -> None:
+    comment = model.parse_top_level_comment(
+        {
+            "id": 1,
+            "user": {"login": REVIEWER, "type": "User"},
+            "created_at": "2026-09-26T12:01:00Z",
+            "updated_at": "2026-09-26T12:05:00Z",
+            "html_url": BOT_SUMMARY_URL,
+        }
+    )
+
+    assert comment == top_level_comment(REVIEWER, 1, edited_minute=5, is_bot=False)

package/settings.json

@@ -3,5 +3,6 @@
         "allow": [
             "WebFetch(domain:docs.github.com)"
         ]
-    }
+    },
+    "advisorModel": "opus"
 }