claude-dev-env 1.37.0 → 1.38.0

package/_shared/pr-loop/scripts/gh_util.py

@@ -1,193 +0,0 @@
-"""Shared helpers for invoking GitHub CLI with basic resiliency."""
-
-import json
-import subprocess
-import sys
-import time
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Sequence
-
-sys.modules.pop("config", None)
-if str(Path(__file__).resolve().parent) not in sys.path:
-    sys.path.insert(0, str(Path(__file__).resolve().parent))
-
-from config.gh_util_constants import (
-    ALL_AUTH_ERROR_MARKERS,
-    ALL_TRANSIENT_ERROR_MARKERS,
-    DEFAULT_BACKOFF_SECONDS,
-    DEFAULT_RETRIES,
-    DEFAULT_TIMEOUT_SECONDS,
-    EXPONENTIAL_BACKOFF_BASE,
-    GH_TIMEOUT_RETURN_CODE,
-    INLINE_REVIEW_COMMENTS_PATH_TEMPLATE,
-)
-
-
-@dataclass(frozen=True)
-class GhResult:
-    returncode: int
-    stdout: str
-    stderr: str
-    is_timed_out: bool = False
-
-
-def _is_transient_error(message: str) -> bool:
-    lowered = message.lower()
-    return any(each_marker in lowered for each_marker in ALL_TRANSIENT_ERROR_MARKERS)
-
-
-def _is_auth_error(message: str) -> bool:
-    lowered = message.lower()
-    return any(each_marker in lowered for each_marker in ALL_AUTH_ERROR_MARKERS)
-
-
-def _ensure_text(text_or_bytes: str | bytes | None) -> str:
-    if text_or_bytes is None:
-        return ""
-    if isinstance(text_or_bytes, bytes):
-        return text_or_bytes.decode(errors="replace")
-    return text_or_bytes
-
-
-def run_gh(
-    all_command: Sequence[str],
-    *,
-    timeout_seconds: int = DEFAULT_TIMEOUT_SECONDS,
-) -> GhResult:
-    """Run a gh command with timeout + transient retry handling.
-
-    Retries are attempted only for transient failures (network/server/rate-limit style
-    messages). Auth/scope failures are returned immediately to fail closed.
-    """
-    if timeout_seconds <= 0:
-        raise ValueError("timeout_seconds must be positive")
-    max_attempts = DEFAULT_RETRIES + 1
-    each_attempt = 0
-    while True:
-        try:
-            gh_completion = subprocess.run(
-                all_command,
-                check=False,
-                capture_output=True,
-                text=True,
-                timeout=timeout_seconds,
-            )
-        except subprocess.TimeoutExpired as error:
-            error_stderr = _ensure_text(error.stderr)
-            error_stdout = _ensure_text(error.stdout)
-            message = (
-                error_stderr or error_stdout or ""
-            ).strip() or "gh command timed out"
-            last_result = GhResult(
-                returncode=GH_TIMEOUT_RETURN_CODE,
-                stdout="",
-                stderr=message,
-                is_timed_out=True,
-            )
-            if each_attempt < max_attempts - 1:
-                time.sleep(
-                    DEFAULT_BACKOFF_SECONDS
-                    * (EXPONENTIAL_BACKOFF_BASE**each_attempt)
-                )
-                each_attempt += 1
-                continue
-            return last_result
-
-        gh_result = GhResult(
-            returncode=gh_completion.returncode,
-            stdout=gh_completion.stdout,
-            stderr=gh_completion.stderr,
-        )
-        if gh_result.returncode == 0:
-            return gh_result
-
-        combined = f"{gh_result.stderr}\n{gh_result.stdout}".strip()
-        if _is_auth_error(combined):
-            return gh_result
-        if each_attempt < max_attempts - 1 and _is_transient_error(combined):
-            time.sleep(
-                DEFAULT_BACKOFF_SECONDS * (EXPONENTIAL_BACKOFF_BASE**each_attempt)
-            )
-            each_attempt += 1
-            continue
-        return gh_result
-
-
-def fetch_inline_review_comments(
-    owner: str,
-    repo: str,
-    pull_number: int,
-    timeout_seconds: int = DEFAULT_TIMEOUT_SECONDS,
-) -> list[dict[str, object]] | None:
-    """Fetch inline review comments for a pull request from the GitHub API.
-
-    Returns the parsed list of comment objects on success, or None when the
-    gh call fails or returns invalid/unexpected JSON. This preserves the
-    distinction between "no inline comments" and "unable to determine
-    inline comments".
-    """
-    api_path = INLINE_REVIEW_COMMENTS_PATH_TEMPLATE.format(
-        owner=owner, repo=repo, pull_number=pull_number
-    )
-    fetch_result = run_gh(
-        [
-            "gh",
-            "-R",
-            f"{owner}/{repo}",
-            "api",
-            api_path,
-            "--paginate",
-        ],
-        timeout_seconds=timeout_seconds,
-    )
-    if fetch_result.returncode != 0:
-        return None
-    parsed = _parse_paginated_json_array_documents(fetch_result.stdout)
-    if parsed is None:
-        return None
-    if not all(isinstance(each_item, dict) for each_item in parsed):
-        return None
-    return parsed
-
-
-def _parse_paginated_json_array_documents(
-    raw_output: str,
-) -> list[dict[str, object]] | None:
-    """Parse gh --paginate output that emits one JSON array per page.
-
-    Concatenated array documents (`[...][...]`) are decoded one at a time
-    using json.JSONDecoder.raw_decode and merged into a single flat list.
-    Returns None when any decoded document is not a JSON array.
-    """
-    decoder = json.JSONDecoder()
-    cursor_index = 0
-    output_length = len(raw_output)
-    flattened: list[dict[str, object]] = []
-    while cursor_index < output_length:
-        while cursor_index < output_length and raw_output[cursor_index].isspace():
-            cursor_index += 1
-        if cursor_index >= output_length:
-            break
-        try:
-            decoded_document, end_index = decoder.raw_decode(
-                raw_output, cursor_index
-            )
-        except json.JSONDecodeError:
-            return None
-        if not isinstance(decoded_document, list):
-            return None
-        flattened.extend(decoded_document)
-        cursor_index = end_index
-    return flattened
-
-
-def parse_owner_repo(repository: str) -> tuple[str, str]:
-    if "/" not in repository:
-        raise ValueError("repository must be owner/repo with exactly one slash")
-    owner, name = repository.split("/", maxsplit=1)
-    if not owner or not name:
-        raise ValueError("repository must be owner/repo with exactly one slash")
-    if "/" in name:
-        raise ValueError("repository must be owner/repo with exactly one slash")
-    return owner, name

package/_shared/pr-loop/scripts/tests/test_gh_util.py

@@ -1,257 +0,0 @@
-"""Tests for shared gh_util.py promoted from babysit-pr/skills/babysit-prs/scripts/."""
-
-import importlib.util
-import inspect
-import subprocess
-import sys
-import unittest
-from pathlib import Path
-from types import ModuleType
-from unittest.mock import patch
-
-
-def _load_gh_util_module() -> ModuleType:
-    module_path = Path(__file__).parent.parent / "gh_util.py"
-    spec = importlib.util.spec_from_file_location("gh_util", module_path)
-    assert spec is not None
-    assert spec.loader is not None
-    module = importlib.util.module_from_spec(spec)
-    sys.modules["gh_util"] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-gh_util = _load_gh_util_module()
-
-
-class ParseOwnerRepositoryTests(unittest.TestCase):
-    def test_accepts_owner_repo(self) -> None:
-        self.assertEqual(
-            gh_util.parse_owner_repo("JonEcho/babysit-pr"),
-            ("JonEcho", "babysit-pr"),
-        )
-
-    def test_rejects_missing_slash(self) -> None:
-        with self.assertRaises(ValueError):
-            gh_util.parse_owner_repo("babysit-pr")
-
-    def test_rejects_empty_owner(self) -> None:
-        with self.assertRaises(ValueError):
-            gh_util.parse_owner_repo("/babysit-pr")
-
-    def test_rejects_empty_name(self) -> None:
-        with self.assertRaises(ValueError):
-            gh_util.parse_owner_repo("JonEcho/")
-
-    def test_rejects_extra_slash_segment(self) -> None:
-        with self.assertRaises(ValueError):
-            gh_util.parse_owner_repo("JonEcho/babysit-pr/extra")
-
-
-class RunGhTests(unittest.TestCase):
-    def test_returns_on_first_success(self) -> None:
-        success = subprocess.CompletedProcess(
-            args=("gh",),
-            returncode=0,
-            stdout="ok",
-            stderr="",
-        )
-        with patch.object(gh_util.subprocess, "run", return_value=success) as run_mock:
-            with patch.object(gh_util.time, "sleep") as sleep_mock:
-                result = gh_util.run_gh(("gh", "pr", "list"))
-        self.assertEqual(result.returncode, 0)
-        self.assertEqual(run_mock.call_count, 1)
-        sleep_mock.assert_not_called()
-
-    def test_retries_transient_failure_then_succeeds(self) -> None:
-        failure = subprocess.CompletedProcess(
-            args=("gh",),
-            returncode=1,
-            stdout="",
-            stderr="connection reset by peer",
-        )
-        success = subprocess.CompletedProcess(
-            args=("gh",),
-            returncode=0,
-            stdout="ok",
-            stderr="",
-        )
-        with patch.object(
-            gh_util.subprocess, "run", side_effect=[failure, success]
-        ) as run_mock:
-            with patch.object(gh_util.time, "sleep") as sleep_mock:
-                result = gh_util.run_gh(("gh", "api", "ping"))
-        self.assertEqual(result.returncode, 0)
-        self.assertEqual(run_mock.call_count, 2)
-        self.assertEqual(sleep_mock.call_count, 1)
-
-    def test_does_not_retry_authentication_failure(self) -> None:
-        failure = subprocess.CompletedProcess(
-            args=("gh",),
-            returncode=1,
-            stdout="",
-            stderr="HTTP 401: Bad credentials",
-        )
-        with patch.object(gh_util.subprocess, "run", return_value=failure) as run_mock:
-            with patch.object(gh_util.time, "sleep") as sleep_mock:
-                result = gh_util.run_gh(("gh", "pr", "view", "1"))
-        self.assertEqual(result.returncode, 1)
-        self.assertEqual(run_mock.call_count, 1)
-        sleep_mock.assert_not_called()
-
-
-class FetchInlineReviewCommentsTests(unittest.TestCase):
-    def test_returns_parsed_list_on_success(self) -> None:
-        payload = [{"id": 1, "path": "foo.py", "line": 10, "body": "Fix this please"}]
-        success = subprocess.CompletedProcess(
-            args=("gh",),
-            returncode=0,
-            stdout='[{"id": 1, "path": "foo.py", "line": 10, "body": "Fix this please"}]',
-            stderr="",
-        )
-        with patch.object(gh_util.subprocess, "run", return_value=success):
-            result = gh_util.fetch_inline_review_comments("JonEcho", "babysit-pr", 17)
-        self.assertEqual(result, payload)
-
-    def test_returns_none_on_gh_failure(self) -> None:
-        failure = subprocess.CompletedProcess(
-            args=("gh",),
-            returncode=1,
-            stdout="",
-            stderr="Not Found",
-        )
-        with patch.object(gh_util.subprocess, "run", return_value=failure):
-            result = gh_util.fetch_inline_review_comments("JonEcho", "babysit-pr", 17)
-        self.assertIsNone(result)
-
-    def test_returns_none_on_invalid_json_with_success_returncode(self) -> None:
-        success_with_invalid_json = subprocess.CompletedProcess(
-            args=("gh",),
-            returncode=0,
-            stdout="not valid json",
-            stderr="",
-        )
-        with patch.object(
-            gh_util.subprocess, "run", return_value=success_with_invalid_json
-        ):
-            result = gh_util.fetch_inline_review_comments("JonEcho", "babysit-pr", 17)
-        self.assertIsNone(result)
-
-    def test_returns_none_when_response_is_not_a_list(self) -> None:
-        success_with_object = subprocess.CompletedProcess(
-            args=("gh",),
-            returncode=0,
-            stdout='{"message": "unexpected object"}',
-            stderr="",
-        )
-        with patch.object(gh_util.subprocess, "run", return_value=success_with_object):
-            result = gh_util.fetch_inline_review_comments("JonEcho", "babysit-pr", 17)
-        self.assertIsNone(result)
-
-    def test_returns_none_when_inner_items_are_not_dicts(self) -> None:
-        success_with_non_dict_items = subprocess.CompletedProcess(
-            args=("gh",),
-            returncode=0,
-            stdout="[1, 2, 3]",
-            stderr="",
-        )
-        with patch.object(
-            gh_util.subprocess, "run", return_value=success_with_non_dict_items
-        ):
-            result = gh_util.fetch_inline_review_comments("JonEcho", "babysit-pr", 17)
-        self.assertIsNone(result)
-
-    def test_returns_none_when_inner_items_mix_dict_and_string(self) -> None:
-        success_with_mixed_items = subprocess.CompletedProcess(
-            args=("gh",),
-            returncode=0,
-            stdout='[{"id": 1, "path": "a.py"}, "stray string"]',
-            stderr="",
-        )
-        with patch.object(
-            gh_util.subprocess, "run", return_value=success_with_mixed_items
-        ):
-            result = gh_util.fetch_inline_review_comments("JonEcho", "babysit-pr", 17)
-        self.assertIsNone(result)
-
-
-class RunGhUnreachableAssertionRemovedTests(unittest.TestCase):
-    def test_run_gh_function_body_does_not_contain_unreachable_assertion(self) -> None:
-        run_gh_source_text = inspect.getsource(gh_util.run_gh)
-        assert "AssertionError" not in run_gh_source_text
-
-
-class RunGhUnreachableTrailingReturnRemovedTests(unittest.TestCase):
-    """Regression: every for-loop branch in run_gh returns a GhResult, so the
-    trailing `return GhResult(...)` block after the loop is unreachable. The
-    body must terminate with the for-loop's own returns, not a fallback block
-    referencing 'exhausted all attempts'.
-    """
-
-    def test_run_gh_function_body_does_not_contain_unreachable_trailing_return(
-        self,
-    ) -> None:
-        run_gh_source_text = inspect.getsource(gh_util.run_gh)
-        assert "exhausted all attempts" not in run_gh_source_text
-
-
-class EnsureTextParameterNameTests(unittest.TestCase):
-    """The `_ensure_text` parameter must not use the banned name `value`.
-
-    CODE_RULES.md §5 bans generic names like `value`. The parameter must
-    describe what it carries -- a subprocess stdout/stderr field that may be
-    str, bytes, or None.
-    """
-
-    def test_ensure_text_parameter_is_not_named_value(self) -> None:
-        ensure_text_signature = inspect.signature(gh_util._ensure_text)
-        all_parameter_names = list(ensure_text_signature.parameters)
-        assert "value" not in all_parameter_names
-
-
-class FetchInlineReviewCommentsPaginationTests(unittest.TestCase):
-    """Regression: gh --paginate emits one JSON document per page concatenated.
-
-    Per the project's gh-paginate rule, --paginate for a list endpoint emits
-    one JSON array per page (e.g. `[...]\\n[...]\\n[...]`), and json.loads
-    fails on the second `[`. fetch_inline_review_comments must merge those
-    documents and return the flattened list rather than returning None.
-    """
-
-    def test_returns_flattened_list_for_concatenated_pages(self) -> None:
-        page_one_body = '[{"id": 1, "path": "a.py"}, {"id": 2, "path": "b.py"}]'
-        page_two_body = '[{"id": 3, "path": "c.py"}]'
-        concatenated_pages = f"{page_one_body}\n{page_two_body}\n"
-        success = subprocess.CompletedProcess(
-            args=("gh",),
-            returncode=0,
-            stdout=concatenated_pages,
-            stderr="",
-        )
-        with patch.object(gh_util.subprocess, "run", return_value=success):
-            fetched_comments = gh_util.fetch_inline_review_comments(
-                "JonEcho", "babysit-pr", 17
-            )
-        assert fetched_comments == [
-            {"id": 1, "path": "a.py"},
-            {"id": 2, "path": "b.py"},
-            {"id": 3, "path": "c.py"},
-        ]
-
-    def test_returns_none_when_concatenated_page_is_not_a_list(self) -> None:
-        concatenated_with_object = '[{"id": 1}]\n{"message": "oops"}\n'
-        success = subprocess.CompletedProcess(
-            args=("gh",),
-            returncode=0,
-            stdout=concatenated_with_object,
-            stderr="",
-        )
-        with patch.object(gh_util.subprocess, "run", return_value=success):
-            fetched_comments = gh_util.fetch_inline_review_comments(
-                "JonEcho", "babysit-pr", 17
-            )
-        assert fetched_comments is None
-
-
-if __name__ == "__main__":
-    unittest.main()

package/_shared/pr-loop/scripts/tests/test_gh_util_constants.py

@@ -1,61 +0,0 @@
-"""Tests for gh_util_constants.py extracted constant set."""
-
-import importlib.util
-from pathlib import Path
-from types import ModuleType
-
-
-def _load_constants_module() -> ModuleType:
-    module_path = Path(__file__).parent.parent / "config" / "gh_util_constants.py"
-    specification = importlib.util.spec_from_file_location(
-        "config.gh_util_constants", module_path
-    )
-    assert specification is not None
-    assert specification.loader is not None
-    module = importlib.util.module_from_spec(specification)
-    specification.loader.exec_module(module)
-    return module
-
-
-constants_module = _load_constants_module()
-
-
-def test_default_timeout_seconds_is_typed_integer() -> None:
-    assert isinstance(constants_module.DEFAULT_TIMEOUT_SECONDS, int)
-    assert constants_module.DEFAULT_TIMEOUT_SECONDS == 30
-
-
-def test_default_retries_is_typed_integer() -> None:
-    assert isinstance(constants_module.DEFAULT_RETRIES, int)
-    assert constants_module.DEFAULT_RETRIES == 2
-
-
-def test_default_backoff_seconds_is_typed_float() -> None:
-    assert isinstance(constants_module.DEFAULT_BACKOFF_SECONDS, float)
-
-
-def test_exponential_backoff_base_is_typed_integer() -> None:
-    assert isinstance(constants_module.EXPONENTIAL_BACKOFF_BASE, int)
-    assert constants_module.EXPONENTIAL_BACKOFF_BASE == 2
-
-
-def test_gh_timeout_return_code_is_typed_integer() -> None:
-    assert isinstance(constants_module.GH_TIMEOUT_RETURN_CODE, int)
-    assert constants_module.GH_TIMEOUT_RETURN_CODE == 124
-
-
-def test_inline_review_comments_path_template_renders() -> None:
-    rendered = constants_module.INLINE_REVIEW_COMMENTS_PATH_TEMPLATE.format(
-        owner="acme", repo="lib", pull_number=7
-    )
-    assert rendered == "/repos/acme/lib/pulls/7/comments"
-
-
-def test_all_transient_error_markers_is_tuple() -> None:
-    assert isinstance(constants_module.ALL_TRANSIENT_ERROR_MARKERS, tuple)
-    assert "timeout" in constants_module.ALL_TRANSIENT_ERROR_MARKERS
-
-
-def test_all_auth_error_markers_is_tuple() -> None:
-    assert isinstance(constants_module.ALL_AUTH_ERROR_MARKERS, tuple)
-    assert "authentication failed" in constants_module.ALL_AUTH_ERROR_MARKERS

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

@@ -1,78 +0,0 @@
-"""Resolve the per-tick mergeability state of an explicitly-targeted PR.
-
-Wraps ``gh pr view <number> --repo <owner>/<repo> --json mergeable,mergeStateStatus,headRefOid``
-so the skill body emits one script invocation. Single-object endpoint - no
-pagination. Explicit ``--owner``/``--repo``/``--number`` targeting matches every
-sibling convergence-gate script (``fetch_*_reviews.py``,
-``fetch_*_inline_comments.py``, ``request_copilot_review.py``,
-``mark_pr_ready.py``); under multi-PR orchestration the gate is guaranteed
-to query the intended PR rather than whichever PR the current git context
-points at.
-
-The returned dict gates pr-converge's mark-ready step against PRs whose base
-branch state is DIRTY (conflicts) or otherwise non-CLEAN.
-"""
-
-import argparse
-import json
-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_REPO_ARG_TEMPLATE, MERGEABILITY_FIELDS
-
-
-def check_pr_mergeability(
-    *,
-    owner: str,
-    repo: str,
-    number: int,
-) -> dict[str, object]:
-    """Return ``{mergeable, mergeStateStatus, headRefOid}`` from ``gh pr view`` for the targeted PR."""
-    repo_arg = GH_REPO_ARG_TEMPLATE.format(owner=owner, repo=repo)
-    gh_command: list[str] = [
-        "gh",
-        "pr",
-        "view",
-        str(number),
-        "--repo",
-        repo_arg,
-        "--json",
-        MERGEABILITY_FIELDS,
-    ]
-    completed = subprocess.run(
-        gh_command,
-        capture_output=True,
-        check=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-    )
-    return json.loads(completed.stdout)
-
-
-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()
-    mergeability_state = check_pr_mergeability(
-        owner=parsed_arguments.owner,
-        repo=parsed_arguments.repo,
-        number=parsed_arguments.number,
-    )
-    json.dump(mergeability_state, sys.stdout)
-    sys.stdout.write("\n")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())