claude-dev-env 1.35.0 → 1.36.1

package/skills/pr-converge/scripts/resolve_pr_head.py

@@ -0,0 +1,58 @@
+"""Resolve the current HEAD SHA of a pull request.
+
+Calls the single-object PR endpoint (`repos/{owner}/{repo}/pulls/{number}`) which
+is NOT paginated, so `--paginate` / `--slurp` are unnecessary and `gh`'s
+built-in `--jq` is safe to use here.
+"""
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+if str(Path(__file__).resolve().parent) not in sys.path:
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from evict_cached_config_modules import evict_cached_config_modules
+
+evict_cached_config_modules()
+
+from config.pr_converge_constants import GH_PR_OBJECT_PATH_TEMPLATE
+
+
+def resolve_pr_head(*, owner: str, repo: str, number: int) -> str:
+    """Return the head_sha for the given PR."""
+    pr_endpoint = GH_PR_OBJECT_PATH_TEMPLATE.format(
+        owner=owner, repo=repo, number=number
+    )
+    gh_command: list[str] = [
+        "gh",
+        "api",
+        pr_endpoint,
+        "--jq",
+        ".head.sha",
+    ]
+    completed = subprocess.run(
+        gh_command,
+        capture_output=True,
+        check=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+    return completed.stdout.strip()
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--owner", required=True)
+    parser.add_argument("--repo", required=True)
+    parser.add_argument("--number", required=True, type=int)
+    parsed_arguments = parser.parse_args()
+    head_sha = resolve_pr_head(owner=parsed_arguments.owner, repo=parsed_arguments.repo, number=parsed_arguments.number)
+    sys.stdout.write(f"{head_sha}\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/pr-converge/scripts/review_field_helpers.py

@@ -0,0 +1,43 @@
+"""Shared field-extraction helpers for GitHub PR review and inline-comment payloads.
+
+The four ``fetch_*_reviews.py`` and ``fetch_*_inline_comments.py`` scripts in
+this directory each parse the same JSON shapes and need the same defensive
+field-coercion logic for ``user.login``, ``body``, ``submitted_at``, and
+``state``. Centralizing the helpers here keeps a single source of truth and
+prevents the bug-fix-in-one-copy-only failure mode flagged on PR #337.
+"""
+
+
+def login_of(field_by_key: dict[str, object]) -> str | None:
+    """Return the ``user.login`` string from a review/comment payload, or ``None``."""
+    user_field = field_by_key.get("user")
+    if not isinstance(user_field, dict):
+        return None
+    login_field = user_field.get("login")
+    if not isinstance(login_field, str):
+        return None
+    return login_field
+
+
+def body_of(field_by_key: dict[str, object]) -> str:
+    """Return the ``body`` string from a review/comment payload, or ``""`` when missing."""
+    body_field = field_by_key.get("body")
+    if not isinstance(body_field, str):
+        return ""
+    return body_field
+
+
+def submitted_at_of(field_by_key: dict[str, object]) -> str:
+    """Return the ``submitted_at`` string from a review payload, or ``""`` when missing."""
+    submitted_at_field = field_by_key.get("submitted_at")
+    if not isinstance(submitted_at_field, str):
+        return ""
+    return submitted_at_field
+
+
+def state_of(field_by_key: dict[str, object]) -> str:
+    """Return the ``state`` string from a review payload, or ``""`` when missing."""
+    state_field = field_by_key.get("state")
+    if not isinstance(state_field, str):
+        return ""
+    return state_field

package/skills/pr-converge/scripts/test_check_pr_mergeability.py

@@ -0,0 +1,126 @@
+"""Tests for check_pr_mergeability.
+
+Covers:
+- gh pr view is invoked with the documented mergeability --json field list
+- the parsed JSON object is returned with mergeable/mergeStateStatus/headRefOid keys
+- subprocess errors propagate
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import subprocess
+from pathlib import Path
+from types import ModuleType
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+def _load_module() -> ModuleType:
+    module_path = Path(__file__).parent / "check_pr_mergeability.py"
+    spec = importlib.util.spec_from_file_location("check_pr_mergeability", module_path)
+    assert spec is not None
+    assert spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+check_pr_mergeability_module = _load_module()
+
+
+def _completed(stdout: str) -> subprocess.CompletedProcess:
+    process = MagicMock(spec=subprocess.CompletedProcess)
+    process.stdout = stdout
+    process.returncode = 0
+    return process
+
+
+def test_should_invoke_gh_pr_view_with_mergeability_field_list() -> None:
+    payload = json.dumps(
+        {
+            "mergeable": "MERGEABLE",
+            "mergeStateStatus": "CLEAN",
+            "headRefOid": "abc123",
+        }
+    )
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(payload)
+        check_pr_mergeability_module.check_pr_mergeability(
+            owner="acme", repo="widget", number=42
+        )
+    invoked_argv = mock_run.call_args[0][0]
+    assert invoked_argv[0:3] == ["gh", "pr", "view"]
+    assert "--json" in invoked_argv
+    fields_arg = invoked_argv[invoked_argv.index("--json") + 1]
+    for required_field in ("mergeable", "mergeStateStatus", "headRefOid"):
+        assert required_field in fields_arg
+
+
+def test_should_pass_pr_number_and_repo_arg_for_explicit_targeting() -> None:
+    payload = json.dumps(
+        {
+            "mergeable": "MERGEABLE",
+            "mergeStateStatus": "CLEAN",
+            "headRefOid": "abc123",
+        }
+    )
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(payload)
+        check_pr_mergeability_module.check_pr_mergeability(
+            owner="acme", repo="widget", number=42
+        )
+    invoked_argv = mock_run.call_args[0][0]
+    assert invoked_argv[3] == "42"
+    assert "--repo" in invoked_argv
+    repo_arg_value = invoked_argv[invoked_argv.index("--repo") + 1]
+    assert repo_arg_value == "acme/widget"
+
+
+def test_should_return_parsed_json_object_with_mergeability_keys() -> None:
+    payload = {
+        "mergeable": "CONFLICTING",
+        "mergeStateStatus": "DIRTY",
+        "headRefOid": "deadbeef",
+    }
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(json.dumps(payload))
+        mergeability_state = check_pr_mergeability_module.check_pr_mergeability(
+            owner="acme", repo="widget", number=42
+        )
+    assert mergeability_state == payload
+    assert mergeability_state["mergeable"] == "CONFLICTING"
+    assert mergeability_state["mergeStateStatus"] == "DIRTY"
+    assert mergeability_state["headRefOid"] == "deadbeef"
+
+
+def test_should_raise_when_gh_subprocess_fails() -> None:
+    failure = subprocess.CalledProcessError(
+        returncode=1, cmd=["gh"], stderr="auth failure"
+    )
+    with patch("subprocess.run", side_effect=failure):
+        with pytest.raises(subprocess.CalledProcessError):
+            check_pr_mergeability_module.check_pr_mergeability(
+                owner="acme", repo="widget", number=42
+            )
+
+
+def test_should_pass_imported_constant_directly_without_local_alias() -> None:
+    payload = json.dumps(
+        {
+            "mergeable": "MERGEABLE",
+            "mergeStateStatus": "CLEAN",
+            "headRefOid": "abc",
+        }
+    )
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(payload)
+        check_pr_mergeability_module.check_pr_mergeability(
+            owner="acme", repo="widget", number=42
+        )
+    invoked_argv = mock_run.call_args[0][0]
+    fields_arg = invoked_argv[invoked_argv.index("--json") + 1]
+    expected_fields = check_pr_mergeability_module.MERGEABILITY_FIELDS
+    assert fields_arg is expected_fields

package/skills/pr-converge/scripts/test_evict_cached_config_modules.py

@@ -0,0 +1,22 @@
+"""Tests for evict_cached_config_modules."""
+
+from __future__ import annotations
+
+import sys
+import types
+from pathlib import Path
+
+_scripts_directory = Path(__file__).resolve().parent
+if str(_scripts_directory) not in sys.path:
+    sys.path.insert(0, str(_scripts_directory))
+
+from evict_cached_config_modules import evict_cached_config_modules
+
+
+def test_should_remove_root_config_and_submodules() -> None:
+    fake = types.ModuleType("config")
+    sys.modules["config"] = fake
+    sys.modules["config.stale_submodule"] = types.ModuleType("config.stale_submodule")
+    evict_cached_config_modules()
+    assert "config" not in sys.modules
+    assert "config.stale_submodule" not in sys.modules

package/skills/pr-converge/scripts/test_fetch_bugbot_inline_comments.py

@@ -0,0 +1,342 @@
+"""Tests for fetch_bugbot_inline_comments.
+
+Covers:
+- gh command uses --paginate --slurp on the comments endpoint
+- only cursor[bot] inline comments are returned
+- comments not anchored to the requested commit are filtered out
+- comments on the same commit but from an older Bugbot review are filtered out
+- multi-page responses are flattened correctly
+- subprocess errors propagate
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import subprocess
+from pathlib import Path
+from types import ModuleType
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+def _load_module() -> ModuleType:
+    module_path = Path(__file__).parent / "fetch_bugbot_inline_comments.py"
+    spec = importlib.util.spec_from_file_location(
+        "fetch_bugbot_inline_comments", module_path
+    )
+    assert spec is not None
+    assert spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+fetch_bugbot_inline_comments_module = _load_module()
+
+
+def _completed(stdout: str) -> subprocess.CompletedProcess:
+    process = MagicMock(spec=subprocess.CompletedProcess)
+    process.stdout = stdout
+    process.returncode = 0
+    return process
+
+
+def _default_review_for_head(*, commit: str, review_id: int) -> list[dict]:
+    return [
+        {
+            "review_id": review_id,
+            "commit_id": commit,
+            "submitted_at": "2026-01-01T00:00:00Z",
+            "body": "Cursor Bugbot has reviewed your changes and found 0 potential issue",
+            "classification": "clean",
+        }
+    ]
+
+
+def test_should_invoke_gh_with_paginate_slurp_against_comments_endpoint() -> None:
+    pages_payload = json.dumps([[]])
+    with patch.object(
+        fetch_bugbot_inline_comments_module,
+        "fetch_bugbot_reviews",
+        return_value=_default_review_for_head(commit="abc123", review_id=1),
+    ), patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(pages_payload)
+        fetch_bugbot_inline_comments_module.fetch_bugbot_inline_comments(
+            owner="acme", repo="widget", number=42, current_head="abc123"
+        )
+    invoked_argv = mock_run.call_args[0][0]
+    assert invoked_argv[0] == "gh"
+    assert invoked_argv[1] == "api"
+    assert "repos/acme/widget/pulls/42/comments?per_page=100" in invoked_argv[2]
+    assert "--paginate" in invoked_argv
+    assert "--slurp" in invoked_argv
+
+
+def test_should_filter_to_cursor_bot_only() -> None:
+    pages_payload = json.dumps(
+        [
+            [
+                {
+                    "id": 100,
+                    "user": {"login": "copilot-pull-request-reviewer[bot]"},
+                    "commit_id": "abc123",
+                    "pull_request_review_id": 1,
+                    "body": "copilot finding",
+                    "path": "x.py",
+                    "line": 5,
+                },
+                {
+                    "id": 101,
+                    "user": {"login": "cursor[bot]"},
+                    "commit_id": "abc123",
+                    "pull_request_review_id": 1,
+                    "body": "bugbot finding",
+                    "path": "x.py",
+                    "line": 6,
+                },
+            ]
+        ]
+    )
+    with patch.object(
+        fetch_bugbot_inline_comments_module,
+        "fetch_bugbot_reviews",
+        return_value=_default_review_for_head(commit="abc123", review_id=1),
+    ), patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(pages_payload)
+        all_inline_comments = (
+            fetch_bugbot_inline_comments_module.fetch_bugbot_inline_comments(
+                owner="acme", repo="widget", number=42, current_head="abc123"
+            )
+        )
+    assert len(all_inline_comments) == 1
+    assert all_inline_comments[0]["comment_id"] == 101
+
+
+def test_should_filter_out_comments_not_on_current_head() -> None:
+    pages_payload = json.dumps(
+        [
+            [
+                {
+                    "id": 200,
+                    "user": {"login": "cursor[bot]"},
+                    "commit_id": "old_sha",
+                    "pull_request_review_id": 1,
+                    "body": "stale finding",
+                    "path": "x.py",
+                    "line": 5,
+                },
+                {
+                    "id": 201,
+                    "user": {"login": "cursor[bot]"},
+                    "commit_id": "current_sha",
+                    "pull_request_review_id": 2,
+                    "body": "fresh finding",
+                    "path": "x.py",
+                    "line": 6,
+                },
+            ]
+        ]
+    )
+    with patch.object(
+        fetch_bugbot_inline_comments_module,
+        "fetch_bugbot_reviews",
+        return_value=_default_review_for_head(commit="current_sha", review_id=2),
+    ), patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(pages_payload)
+        all_inline_comments = (
+            fetch_bugbot_inline_comments_module.fetch_bugbot_inline_comments(
+                owner="acme", repo="widget", number=42, current_head="current_sha"
+            )
+        )
+    assert len(all_inline_comments) == 1
+    assert all_inline_comments[0]["comment_id"] == 201
+
+
+def test_should_ignore_inline_comments_from_older_bugbot_review_on_same_commit() -> None:
+    pages_payload = json.dumps(
+        [
+            [
+                {
+                    "id": 300,
+                    "user": {"login": "cursor[bot]"},
+                    "commit_id": "same_sha",
+                    "pull_request_review_id": 10,
+                    "body": "stale dirty thread",
+                    "path": "x.py",
+                    "line": 1,
+                },
+                {
+                    "id": 301,
+                    "user": {"login": "cursor[bot]"},
+                    "commit_id": "same_sha",
+                    "pull_request_review_id": 11,
+                    "body": "current clean thread",
+                    "path": "x.py",
+                    "line": 2,
+                },
+            ]
+        ]
+    )
+    reviews_newest_first = [
+        {
+            "review_id": 11,
+            "commit_id": "same_sha",
+            "submitted_at": "2026-01-02T00:00:00Z",
+            "body": "clean",
+            "classification": "clean",
+        },
+        {
+            "review_id": 10,
+            "commit_id": "same_sha",
+            "submitted_at": "2026-01-01T00:00:00Z",
+            "body": "Cursor Bugbot has reviewed your changes and found 1 potential issue",
+            "classification": "dirty",
+        },
+    ]
+    with patch.object(
+        fetch_bugbot_inline_comments_module,
+        "fetch_bugbot_reviews",
+        return_value=reviews_newest_first,
+    ), patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(pages_payload)
+        all_inline_comments = (
+            fetch_bugbot_inline_comments_module.fetch_bugbot_inline_comments(
+                owner="acme", repo="widget", number=42, current_head="same_sha"
+            )
+        )
+    assert [each_comment["comment_id"] for each_comment in all_inline_comments] == [301]
+
+
+def test_should_return_empty_when_no_bugbot_review_exists_for_commit() -> None:
+    with patch.object(
+        fetch_bugbot_inline_comments_module,
+        "fetch_bugbot_reviews",
+        return_value=[
+            {
+                "review_id": 1,
+                "commit_id": "other_sha",
+                "submitted_at": "2026-01-01T00:00:00Z",
+                "body": "",
+                "classification": "clean",
+            }
+        ],
+    ), patch("subprocess.run") as mock_run:
+        all_inline_comments = (
+            fetch_bugbot_inline_comments_module.fetch_bugbot_inline_comments(
+                owner="acme", repo="widget", number=42, current_head="missing_sha"
+            )
+        )
+    assert all_inline_comments == []
+    mock_run.assert_not_called()
+
+
+def test_should_flatten_across_pages() -> None:
+    pages_payload = json.dumps(
+        [
+            [
+                {
+                    "id": 1,
+                    "user": {"login": "cursor[bot]"},
+                    "commit_id": "abc",
+                    "pull_request_review_id": 9,
+                    "body": "a",
+                    "path": "f.py",
+                    "line": 1,
+                }
+            ],
+            [
+                {
+                    "id": 2,
+                    "user": {"login": "cursor[bot]"},
+                    "commit_id": "abc",
+                    "pull_request_review_id": 9,
+                    "body": "b",
+                    "path": "f.py",
+                    "line": 2,
+                },
+                {
+                    "id": 3,
+                    "user": {"login": "cursor[bot]"},
+                    "commit_id": "abc",
+                    "pull_request_review_id": 9,
+                    "body": "c",
+                    "path": "f.py",
+                    "line": 3,
+                },
+            ],
+        ]
+    )
+    with patch.object(
+        fetch_bugbot_inline_comments_module,
+        "fetch_bugbot_reviews",
+        return_value=_default_review_for_head(commit="abc", review_id=9),
+    ), patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(pages_payload)
+        all_inline_comments = (
+            fetch_bugbot_inline_comments_module.fetch_bugbot_inline_comments(
+                owner="acme", repo="widget", number=42, current_head="abc"
+            )
+        )
+    assert [each_comment["comment_id"] for each_comment in all_inline_comments] == [
+        1,
+        2,
+        3,
+    ]
+
+
+def test_should_reference_cursor_bot_login_constant_directly_without_local_alias() -> None:
+    source_text = (
+        Path(__file__).resolve().parent / "fetch_bugbot_inline_comments.py"
+    ).read_text(encoding="utf-8")
+    assert "cursor_bot_login = CURSOR_BOT_LOGIN" not in source_text
+    assert "CURSOR_BOT_LOGIN" in source_text
+
+
+def test_should_raise_when_gh_subprocess_fails() -> None:
+    failure = subprocess.CalledProcessError(
+        returncode=1, cmd=["gh"], stderr="auth failure"
+    )
+    with patch.object(
+        fetch_bugbot_inline_comments_module,
+        "fetch_bugbot_reviews",
+        return_value=_default_review_for_head(commit="abc", review_id=1),
+    ), patch("subprocess.run", side_effect=failure):
+        with pytest.raises(subprocess.CalledProcessError):
+            fetch_bugbot_inline_comments_module.fetch_bugbot_inline_comments(
+                owner="acme", repo="widget", number=42, current_head="abc"
+            )
+
+
+def test_should_return_entries_whose_keys_are_strings() -> None:
+    pages_payload = json.dumps(
+        [
+            [
+                {
+                    "id": 101,
+                    "user": {"login": "cursor[bot]"},
+                    "commit_id": "abc123",
+                    "pull_request_review_id": 1,
+                    "body": "bugbot finding",
+                    "path": "x.py",
+                    "line": 6,
+                }
+            ]
+        ]
+    )
+    with patch.object(
+        fetch_bugbot_inline_comments_module,
+        "fetch_bugbot_reviews",
+        return_value=_default_review_for_head(commit="abc123", review_id=1),
+    ), patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(pages_payload)
+        all_inline_comments = (
+            fetch_bugbot_inline_comments_module.fetch_bugbot_inline_comments(
+                owner="acme", repo="widget", number=42, current_head="abc123"
+            )
+        )
+    assert len(all_inline_comments) == 1
+    first_comment_entry = all_inline_comments[0]
+    assert isinstance(first_comment_entry, dict)
+    assert all(isinstance(each_key, str) for each_key in first_comment_entry.keys())