claude-dev-env 1.41.0 → 1.43.0

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

@@ -15,11 +15,11 @@ import subprocess
 import sys
 from pathlib import Path
 
-_pr_converge_dir = Path(__file__).resolve().parent.parent
+_pr_converge_dir = Path(__file__).absolute().parent.parent
 if str(_pr_converge_dir) not in sys.path:
     sys.path.insert(0, str(_pr_converge_dir))
 
-from config.constants import (
+from pr_converge_skill_constants.constants import (
     COPILOT_LOGIN_FILTER_SUBSTRING,
     GH_REVIEWS_PATH_TEMPLATE,
     REVIEWS_PER_PAGE,

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

@@ -20,11 +20,11 @@ import subprocess
 import sys
 from pathlib import Path
 
-_pr_converge_dir = Path(__file__).resolve().parent.parent
+_pr_converge_dir = Path(__file__).absolute().parent.parent
 if str(_pr_converge_dir) not in sys.path:
     sys.path.insert(0, str(_pr_converge_dir))
 
-from config.constants import (
+from pr_converge_skill_constants.constants import (
     EXIT_CODE_GH_ERROR,
     GH_INLINE_COMMENT_REPLY_PATH_TEMPLATE,
     GH_ISSUE_COMMENT_CREATE_PATH_TEMPLATE,

package/skills/pr-converge/scripts/{config → pr_converge_scripts_constants}/pr_converge_constants.py

@@ -11,7 +11,7 @@ settings) live here.
 import re
 from pathlib import Path
 
-from config.constants import (  # noqa: F401
+from pr_converge_skill_constants.constants import (  # noqa: F401
     ALL_BUGBOT_CHECK_RUN_ACTIVE_STATUSES,
     ALL_CLAUDE_DIRTY_REVIEW_STATES,
     ALL_COPILOT_DIRTY_REVIEW_STATES,

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

@@ -9,22 +9,9 @@ Run: python3 packages/claude-dev-env/skills/pr-converge/scripts/reflow_skill_md.
 
 from __future__ import annotations
 
-import sys
 import textwrap
-from pathlib import Path
 
-script_directory = str(Path(__file__).resolve().parent)
-
-while script_directory in sys.path:
-    sys.path.remove(script_directory)
-if script_directory not in sys.path:
-    sys.path.insert(0, script_directory)
-
-from evict_cached_config_modules import evict_cached_config_modules
-
-evict_cached_config_modules()
-
-from config.reflow_skill_md_constants import (
+from pr_converge_scripts_constants.reflow_skill_md_constants import (
     BASH_CONTINUATION_MARKER_WIDTH,
     BULLET_LIST_ITEM_PATTERN as BULLET_RE,
     MARKDOWN_REFERENCE_DEFINITION_PATTERN as REF_DEF_RE,
@@ -36,6 +23,14 @@ from config.reflow_skill_md_constants import (
 
 
 def wrap_paragraph_plain(text: str) -> list[str]:
+    """Wrap a plain paragraph to MAX_WIDTH after collapsing whitespace.
+
+    Args:
+        text: Paragraph text with internal whitespace runs to collapse.
+
+    Returns:
+        Wrapped lines; empty list when the input collapses to nothing.
+    """
     collapsed = " ".join(text.split())
     if not collapsed:
         return []
@@ -48,6 +43,17 @@ def wrap_paragraph_plain(text: str) -> list[str]:
 
 
 def wrap_list_item(lead_ws: str, marker: str, body: str) -> list[str]:
+    """Wrap a list item, preserving the leading marker and indentation.
+
+    Args:
+        lead_ws: Leading whitespace before the list marker.
+        marker: List marker such as a hyphen or numeric prefix.
+        body: Item body text to wrap.
+
+    Returns:
+        Wrapped lines with the marker on the first line and matching
+        indentation on subsequent lines.
+    """
     collapsed = " ".join(body.split())
     if not collapsed:
         return [lead_ws + marker.rstrip()]
@@ -67,6 +73,16 @@ def reflow_yaml_description_block(
     all_lines: list[str],
     body_start: int,
 ) -> tuple[list[str], int]:
+    """Reflow the YAML description block until the closing fence.
+
+    Args:
+        all_lines: Full SKILL.md lines.
+        body_start: Index of the first description body line.
+
+    Returns:
+        Tuple of wrapped description lines and the index just past the
+        closing fence.
+    """
     body_parts: list[str] = []
     index = body_start
     while index < len(all_lines):
@@ -95,6 +111,16 @@ def is_table_line(line: str) -> bool:
 
 
 def is_new_logical_line(stripped: str) -> bool:
+    """Decide whether ``stripped`` starts a new logical line.
+
+    Args:
+        stripped: Candidate line with leading whitespace already removed.
+
+    Returns:
+        True when the line begins a new markdown construct (fence, heading,
+        table row, list item, reference definition, or example tag) and
+        therefore must not be merged into the prior buffer.
+    """
     if not stripped:
         return False
     if stripped.startswith("```"):
@@ -115,7 +141,16 @@ def is_new_logical_line(stripped: str) -> bool:
 
 
 def merge_without_space(buffer: str, continuation: str) -> bool:
-    """Join without space only for split markdown link URL paths."""
+    """Join without space only for split markdown link URL paths.
+
+    Args:
+        buffer: Accumulated line preceding the candidate continuation.
+        continuation: Next line to evaluate for joining.
+
+    Returns:
+        True when continuation is the tail of a split markdown link target
+        and buffer ends inside an unfinished link target.
+    """
     base = buffer.rstrip()
     stripped = continuation.lstrip()
     if not base or not stripped:
@@ -126,6 +161,15 @@ def merge_without_space(buffer: str, continuation: str) -> bool:
 
 
 def merge_soft_breaks(all_lines: list[str]) -> list[str]:
+    """Merge soft line breaks across non-fence markdown paragraphs.
+
+    Args:
+        all_lines: Raw SKILL.md lines.
+
+    Returns:
+        Lines with each paragraph collapsed to a single buffer line; fences
+        and blank lines are preserved verbatim.
+    """
     reflowed_lines: list[str] = []
     index = 0
     is_inside_fence = False
@@ -166,6 +210,15 @@ def merge_soft_breaks(all_lines: list[str]) -> list[str]:
 
 
 def reflow_merged_line(line: str) -> list[str]:
+    """Reflow a single merged buffer line into MAX_WIDTH-bounded lines.
+
+    Args:
+        line: Buffer line produced by merge_soft_breaks.
+
+    Returns:
+        Wrapped lines; structural constructs (fences, tables, separators)
+        are returned unchanged.
+    """
     stripped = line.strip()
     if stripped == "":
         return [""]
@@ -221,6 +274,14 @@ def reflow_merged_line(line: str) -> list[str]:
 
 
 def reflow_markdown_body(all_lines: list[str]) -> list[str]:
+    """Merge soft breaks then reflow every line of the SKILL.md body.
+
+    Args:
+        all_lines: Raw SKILL.md body lines following the YAML front matter.
+
+    Returns:
+        Reflowed body lines bounded by MAX_WIDTH.
+    """
     merged = merge_soft_breaks(all_lines)
     reflowed_lines: list[str] = []
     for each_line in merged:
@@ -232,7 +293,15 @@ def reflow_markdown_body(all_lines: list[str]) -> list[str]:
 
 
 def wrap_long_bash_fence_lines(all_lines: list[str]) -> list[str]:
-    """Hard-wrap only ```bash fence bodies that still exceed MAX_WIDTH."""
+    """Hard-wrap bash fence bodies that still exceed MAX_WIDTH.
+
+    Args:
+        all_lines: SKILL.md body lines after paragraph reflow.
+
+    Returns:
+        Lines with overlong bash-fence bodies split on whitespace with a
+        trailing backslash continuation marker.
+    """
     wrapped_lines: list[str] = []
     is_inside_bash_fence = False
     for each_line in all_lines:
@@ -272,6 +341,11 @@ def wrap_long_bash_fence_lines(all_lines: list[str]) -> list[str]:
 
 
 def main() -> None:
+    """Read SKILL.md, reflow it to MAX_WIDTH, and write the result back.
+
+    Raises:
+        SystemExit: When the file does not start with YAML front matter.
+    """
     raw = SKILL_PATH.read_text(encoding="utf-8")
     lines = raw.splitlines()
     if not lines or lines[0].strip() != "---":

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

@@ -21,7 +21,7 @@ from unittest.mock import MagicMock, patch
 
 import pytest
 
-_SCRIPTS_DIRECTORY = Path(__file__).resolve().parent
+_SCRIPTS_DIRECTORY = Path(__file__).absolute().parent
 
 
 @pytest.fixture(scope="session")

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

@@ -0,0 +1,324 @@
+"""Tests for check_convergence.
+
+Covers the bugteam audit gate (`_check_bugteam_clean`) which identifies
+bugteam reviews by body header signature rather than by the posting user's
+GitHub login. Three scenarios are exercised:
+
+- a clean bugteam review on the current HEAD passes the gate
+- a dirty bugteam review on the current HEAD fails the gate
+- the absence of any bugteam review on the current HEAD fails the gate
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import sys
+from pathlib import Path
+from types import ModuleType
+from typing import Callable
+
+import pytest
+
+_SCRIPTS_DIRECTORY = Path(__file__).absolute().parent
+_PR_CONVERGE_DIRECTORY = _SCRIPTS_DIRECTORY.parent
+
+if str(_PR_CONVERGE_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(_PR_CONVERGE_DIRECTORY))
+
+
+def _load_module() -> ModuleType:
+    for each_cached_name in [
+        each_key
+        for each_key in list(sys.modules)
+        if each_key == "config" or each_key.startswith("config.")
+    ]:
+        sys.modules.pop(each_cached_name, None)
+    if str(_PR_CONVERGE_DIRECTORY) in sys.path:
+        sys.path.remove(str(_PR_CONVERGE_DIRECTORY))
+    sys.path.insert(0, str(_PR_CONVERGE_DIRECTORY))
+    module_path = _SCRIPTS_DIRECTORY / "check_convergence.py"
+    spec = importlib.util.spec_from_file_location(
+        "check_convergence_under_test", 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_convergence = _load_module()
+
+CURRENT_HEAD_SHA = "abcdef1234567890abcdef1234567890abcdef12"
+OTHER_HEAD_SHA = "0000000000000000000000000000000000000000"
+CLEAN_BUGTEAM_BODY = (
+    "**Bugteam audit completed** —— Clean — no findings\n"
+    "\n"
+    "---\n"
+    "### Audit pass clean\n"
+    "\n"
+    "The Bugteam audit pass against commit `abcdef1` found no findings.\n"
+)
+DIRTY_BUGTEAM_BODY = (
+    "**Bugteam audit completed** —— Findings requested\n"
+    "\n"
+    "---\n"
+    "### Findings recorded as inline review comments\n"
+    "\n"
+    "The Bugteam audit pass against commit `abcdef1` surfaced 2 finding(s).\n"
+)
+NON_BUGTEAM_BODY = (
+    "Cursor Bugbot has reviewed your changes and found 0 potential issues."
+)
+
+
+def _make_stub_gh_paginated(
+    all_review_objects: list[dict[str, object]],
+) -> Callable[[str], tuple[int, str]]:
+    pages_payload = [all_review_objects]
+    serialized = json.dumps(pages_payload)
+
+    def stub_gh_api_paginated(endpoint_path: str) -> tuple[int, str]:
+        return 0, serialized
+
+    return stub_gh_api_paginated
+
+
+def should_pass_when_clean_bugteam_review_present_on_current_head(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    reviews_payload = [
+        {
+            "id": 1001,
+            "body": CLEAN_BUGTEAM_BODY,
+            "commit_id": CURRENT_HEAD_SHA,
+            "submitted_at": "2026-05-17T12:00:00Z",
+        }
+    ]
+    stub = _make_stub_gh_paginated(reviews_payload)
+    monkeypatch.setattr(check_convergence, "_gh_api_paginated", stub)
+    passed, detail = check_convergence._check_bugteam_clean(
+        owner="JonEcho",
+        repo="tests",
+        number=42,
+        head_sha=CURRENT_HEAD_SHA,
+    )
+    assert passed is True
+    assert "clean bugteam audit" in detail
+    assert CURRENT_HEAD_SHA[:7] in detail
+
+
+def should_fail_when_dirty_bugteam_review_present_on_current_head(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    reviews_payload = [
+        {
+            "id": 1002,
+            "body": DIRTY_BUGTEAM_BODY,
+            "commit_id": CURRENT_HEAD_SHA,
+            "submitted_at": "2026-05-17T12:00:00Z",
+        }
+    ]
+    stub = _make_stub_gh_paginated(reviews_payload)
+    monkeypatch.setattr(check_convergence, "_gh_api_paginated", stub)
+    passed, detail = check_convergence._check_bugteam_clean(
+        owner="JonEcho",
+        repo="tests",
+        number=42,
+        head_sha=CURRENT_HEAD_SHA,
+    )
+    assert passed is False
+    assert "dirty bugteam audit" in detail
+    assert CURRENT_HEAD_SHA[:7] in detail
+
+
+def should_fail_when_no_bugteam_review_present_on_current_head(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    reviews_payload = [
+        {
+            "id": 1003,
+            "body": NON_BUGTEAM_BODY,
+            "commit_id": CURRENT_HEAD_SHA,
+            "submitted_at": "2026-05-17T12:00:00Z",
+        },
+        {
+            "id": 1004,
+            "body": CLEAN_BUGTEAM_BODY,
+            "commit_id": OTHER_HEAD_SHA,
+            "submitted_at": "2026-05-17T11:00:00Z",
+        },
+    ]
+    stub = _make_stub_gh_paginated(reviews_payload)
+    monkeypatch.setattr(check_convergence, "_gh_api_paginated", stub)
+    passed, detail = check_convergence._check_bugteam_clean(
+        owner="JonEcho",
+        repo="tests",
+        number=42,
+        head_sha=CURRENT_HEAD_SHA,
+    )
+    assert passed is False
+    assert "no bugteam review found" in detail
+
+
+def should_fail_with_shape_detail_when_gh_returns_non_list_payload(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    error_object_payload = {"message": "Not Found", "documentation_url": "https://docs.github.com/rest"}
+    serialized_error = json.dumps(error_object_payload)
+
+    def stub_gh_api_paginated_returning_object(endpoint_path: str) -> tuple[int, str]:
+        return 0, serialized_error
+
+    monkeypatch.setattr(
+        check_convergence, "_gh_api_paginated", stub_gh_api_paginated_returning_object
+    )
+    passed, detail = check_convergence._check_bugteam_clean(
+        owner="JonEcho",
+        repo="tests",
+        number=42,
+        head_sha=CURRENT_HEAD_SHA,
+    )
+    assert passed is False
+    assert "unexpected gh api response shape" in detail
+
+
+def test_private_helpers_recognize_clean_new_header_body() -> None:
+    assert check_convergence._is_bugteam_review(CLEAN_BUGTEAM_BODY) is True
+    assert check_convergence._is_clean_bugteam_review(CLEAN_BUGTEAM_BODY) is True
+
+
+def test_private_helpers_recognize_dirty_new_header_body() -> None:
+    assert check_convergence._is_bugteam_review(DIRTY_BUGTEAM_BODY) is True
+    assert check_convergence._is_clean_bugteam_review(DIRTY_BUGTEAM_BODY) is False
+
+
+def test_private_helpers_reject_non_bugteam_body() -> None:
+    assert check_convergence._is_bugteam_review(NON_BUGTEAM_BODY) is False
+    assert check_convergence._is_clean_bugteam_review(NON_BUGTEAM_BODY) is False
+
+
+CLEAN_LEGACY_BUGTEAM_BODY = (
+    "## /bugteam loop 1 audit: 0 P0 / 0 P1 / 0 P2 → clean"
+)
+DIRTY_LEGACY_BUGTEAM_BODY = (
+    "## /bugteam loop 1 audit: 1 P0 / 0 P1 / 0 P2 → dirty"
+)
+
+
+def test_private_helpers_recognize_clean_legacy_header_body() -> None:
+    assert check_convergence._is_bugteam_review(CLEAN_LEGACY_BUGTEAM_BODY) is True
+    assert check_convergence._is_clean_bugteam_review(CLEAN_LEGACY_BUGTEAM_BODY) is True
+
+
+def test_private_helpers_recognize_dirty_legacy_header_body() -> None:
+    assert check_convergence._is_bugteam_review(DIRTY_LEGACY_BUGTEAM_BODY) is True
+    assert check_convergence._is_clean_bugteam_review(DIRTY_LEGACY_BUGTEAM_BODY) is False
+
+
+def should_bypass_bugbot_gates_when_bugbot_down_is_true(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    all_invocation_names: list[str] = []
+
+    def stub_get_pr_head_sha(*, owner: str, repo: str, number: int) -> str:
+        all_invocation_names.append("_get_pr_head_sha")
+        return CURRENT_HEAD_SHA
+
+    def stub_check_bugbot_should_not_be_called(
+        *, owner: str, repo: str, sha: str
+    ) -> tuple[bool, str]:
+        all_invocation_names.append("_check_bugbot")
+        raise AssertionError("_check_bugbot must not be invoked when bugbot_down=True")
+
+    def stub_check_bugbot_not_dirty_should_not_be_called(
+        *, owner: str, repo: str, number: int, head_sha: str
+    ) -> tuple[bool, str]:
+        all_invocation_names.append("_check_bugbot_not_dirty")
+        raise AssertionError(
+            "_check_bugbot_not_dirty must not be invoked when bugbot_down=True"
+        )
+
+    def stub_check_bugteam_clean(
+        *, owner: str, repo: str, number: int, head_sha: str
+    ) -> tuple[bool, str]:
+        all_invocation_names.append("_check_bugteam_clean")
+        return True, "stub passing"
+
+    def stub_check_bot_review(
+        *,
+        owner: str,
+        repo: str,
+        number: int,
+        head_sha: str,
+        login_substring: str,
+        clean_states: tuple[str, ...],
+        dirty_states: tuple[str, ...],
+        label: str,
+    ) -> tuple[bool, str]:
+        all_invocation_names.append("_check_bot_review")
+        return True, "stub passing"
+
+    def stub_count_unresolved_bot_threads(
+        *, owner: str, repo: str, number: int
+    ) -> tuple[bool, str]:
+        all_invocation_names.append("_count_unresolved_bot_threads")
+        return True, "stub passing"
+
+    def stub_get_mergeable(
+        *, owner: str, repo: str, number: int
+    ) -> tuple[bool, str]:
+        all_invocation_names.append("_get_mergeable")
+        return True, "stub passing"
+
+    def stub_check_no_pending_reviews(
+        *, owner: str, repo: str, number: int
+    ) -> tuple[bool, str]:
+        all_invocation_names.append("_check_no_pending_reviews")
+        return True, "stub passing"
+
+    monkeypatch.setattr(check_convergence, "_get_pr_head_sha", stub_get_pr_head_sha)
+    monkeypatch.setattr(check_convergence, "_check_bugbot", stub_check_bugbot_should_not_be_called)
+    monkeypatch.setattr(
+        check_convergence,
+        "_check_bugbot_not_dirty",
+        stub_check_bugbot_not_dirty_should_not_be_called,
+    )
+    monkeypatch.setattr(check_convergence, "_check_bugteam_clean", stub_check_bugteam_clean)
+    monkeypatch.setattr(check_convergence, "_check_bot_review", stub_check_bot_review)
+    monkeypatch.setattr(
+        check_convergence, "_count_unresolved_bot_threads", stub_count_unresolved_bot_threads
+    )
+    monkeypatch.setattr(check_convergence, "_get_mergeable", stub_get_mergeable)
+    monkeypatch.setattr(
+        check_convergence, "_check_no_pending_reviews", stub_check_no_pending_reviews
+    )
+
+    exit_code = check_convergence.check_all(
+        owner="o", repo="r", number=1, bugbot_down=True
+    )
+    captured_stdout = capsys.readouterr().out
+
+    assert "_check_bugbot" not in all_invocation_names
+    assert "_check_bugbot_not_dirty" not in all_invocation_names
+    assert "bypassed (bugbot_down)" in captured_stdout
+    assert exit_code == 0
+
+
+def should_propagate_systemexit_from_get_pr_head_sha(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    def stub_get_pr_head_sha_raising_systemexit(
+        *, owner: str, repo: str, number: int
+    ) -> str:
+        raise SystemExit(check_convergence.EXIT_CODE_GH_ERROR)
+
+    monkeypatch.setattr(
+        check_convergence, "_get_pr_head_sha", stub_get_pr_head_sha_raising_systemexit
+    )
+
+    with pytest.raises(SystemExit) as exc_info:
+        check_convergence.check_all(owner="o", repo="r", number=1, bugbot_down=False)
+
+    assert exc_info.value.code == check_convergence.EXIT_CODE_GH_ERROR

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

@@ -108,27 +108,6 @@ def test_reflow_merged_line_preserves_long_markdown_reference_definition() -> No
     assert reflow_module.reflow_merged_line(line) == [stripped_line]
 
 
-def test_reflow_bootstrap_moves_script_directory_ahead_of_shadow_config(
-    tmp_path: Path,
-) -> None:
-    """sys.path bootstrap must move the script directory ahead of shadow config packages."""
-    shadow_config_directory = tmp_path / "shadow" / "config"
-    shadow_config_directory.mkdir(parents=True)
-    (shadow_config_directory / "__init__.py").write_text("", encoding="utf-8")
-    (shadow_config_directory / "pr_converge_constants.py").write_text(
-        "BROKEN = True\n", encoding="utf-8"
-    )
-    original_sys_path = list(sys.path)
-    try:
-        sys.path.insert(0, str(tmp_path / "shadow"))
-        loaded_module = _load_module()
-        assert loaded_module.MAX_WIDTH == 80
-        assert sys.path[0] == str(_SCRIPTS_DIRECTORY)
-        assert sys.path.count(str(_SCRIPTS_DIRECTORY)) == 1
-    finally:
-        sys.path[:] = original_sys_path
-
-
 def test_wrap_long_bash_fence_lines_uses_continuation_marker_for_long_lines() -> None:
     """Wrapped continuation lines use the bash continuation marker."""
     long_line = "echo " + "word " * 20
@@ -150,13 +129,3 @@ def test_reflow_uses_config_constant_for_continuation_marker_width() -> None:
         "reflow_skill_md.py must import BASH_CONTINUATION_MARKER_WIDTH from config"
     )
 
-def test_reflow_bootstrap_matches_code_rules_sys_path_pattern() -> None:
-    """Bootstrap must guard insert with a membership check."""
-    module_path = _SCRIPTS_DIRECTORY / "reflow_skill_md.py"
-    source = module_path.read_text(encoding="utf-8")
-    assert "while script_directory in sys.path:" in source, (
-        "Bootstrap must dedup script_directory entries before insert"
-    )
-    assert "sys.path.insert(0, script_directory)" in source, (
-        "Bootstrap must insert script_directory at index 0"
-    )