claude-dev-env 1.36.1 → 1.37.0

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

@@ -0,0 +1,162 @@
+"""Tests for reflow_skill_md.
+
+Covers:
+- wrap_long_bash_line returns unchanged when indent leaves zero/negative width
+- wrap_long_bash_fence_lines handles deeply-indented bash content safely
+- structural string literals are imported from config, not inline
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+
+_SCRIPTS_DIRECTORY = Path(__file__).resolve().parent
+
+
+def _load_module() -> ModuleType:
+    if str(_SCRIPTS_DIRECTORY) not in sys.path:
+        sys.path.insert(0, str(_SCRIPTS_DIRECTORY))
+    module_path = _SCRIPTS_DIRECTORY / "reflow_skill_md.py"
+    spec = importlib.util.spec_from_file_location("reflow_skill_md", 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
+
+
+reflow_module = _load_module()
+
+
+def test_should_preserve_pr_converge_state_json_path_in_yaml_description() -> None:
+    lines = [
+        "  Multi-PR runs persist traffic in",
+        "  `<TMPDIR>/pr-converge-<session_id>/state.json` per Multi-PR",
+        "  orchestration model.",
+        "---",
+    ]
+    all_reflowed_lines, next_index = reflow_module.reflow_yaml_description_block(lines, 0)
+    reflowed_description = " ".join(each_line.strip() for each_line in all_reflowed_lines)
+
+    assert next_index == len(lines)
+    assert "`<TMPDIR>/pr-converge-<session_id>/state.json`" in reflowed_description
+    assert "`<TMPDIR>/pr-converge-<session_id>/state.json>`" not in reflowed_description
+
+
+def test_wrap_long_bash_fence_lines_does_not_modify_deeply_indented_line() -> None:
+    """When indentation >= MAX_WIDTH, return line as-is."""
+    deep_indent = " " * 85
+    long_line = deep_indent + "echo hello world this is a long command"
+    all_input_lines = ["```bash", long_line, "```"]
+    all_result_lines = reflow_module.wrap_long_bash_fence_lines(all_input_lines)
+    assert all_result_lines == ["```bash", long_line, "```"]
+
+
+def test_wrap_long_bash_fence_lines_does_not_modify_max_width_indent_line() -> None:
+    """When indentation == MAX_WIDTH, return line as-is."""
+    deep_indent = " " * 80
+    long_line = deep_indent + "echo hello"
+    all_input_lines = ["```bash", long_line, "```"]
+    all_result_lines = reflow_module.wrap_long_bash_fence_lines(all_input_lines)
+    assert all_result_lines == ["```bash", long_line, "```"]
+
+
+def test_wrap_long_bash_fence_lines_handles_deeply_indented_bash() -> None:
+    """Full pipeline does not hang on bash fence with extreme indentation."""
+    deep_indent = " " * 90
+    all_input_lines = [
+        "```bash",
+        deep_indent + "some_command --flag value --other long argument text here",
+        "```",
+    ]
+    all_result_lines = reflow_module.wrap_long_bash_fence_lines(all_input_lines)
+    assert len(all_result_lines) == 3
+    assert all_result_lines[0] == "```bash"
+    assert all_result_lines[2] == "```"
+    assert all_result_lines[1] == all_input_lines[1]
+
+
+def test_is_new_logical_line_recognizes_fence_via_constant() -> None:
+    """Code fence detection uses the imported constant marker."""
+    assert reflow_module.is_new_logical_line("```bash") is True
+    assert reflow_module.is_new_logical_line("```") is True
+
+
+def test_reflow_merged_line_recognizes_example_tags_via_constant() -> None:
+    """Example tag detection uses imported constant markers."""
+    assert reflow_module.reflow_merged_line("<example>") == ["<example>"]
+    close_result = reflow_module.reflow_merged_line("</example>")
+    assert close_result == ["</example>"]
+
+
+def test_reflow_merged_line_recognizes_yaml_delimiter_via_constant() -> None:
+    """YAML delimiter detection uses imported constant."""
+    assert reflow_module.reflow_merged_line("---") == ["---"]
+
+
+def test_reflow_merged_line_preserves_long_markdown_reference_definition() -> None:
+    """Lines matching reference definitions survive reflow without paragraph wrapping."""
+    long_url_token = "x" * 90
+    line = f"[bugbot-ref]: https://example.com/{long_url_token}"
+    stripped_line = line.strip()
+    maximum_width = reflow_module.MAX_WIDTH
+    assert len(stripped_line) > maximum_width
+    assert reflow_module.REF_DEF_RE.match(stripped_line) is not None
+    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
+    all_input_lines = ["```bash", long_line, "```"]
+    all_result_lines = reflow_module.wrap_long_bash_fence_lines(all_input_lines)
+    wrapped_content = all_result_lines[1:-1]
+    assert len(wrapped_content) > 1, "Line must be long enough to wrap"
+    assert wrapped_content[-1].lstrip(), "Final segment must have content"
+    assert all(len(each) <= reflow_module.MAX_WIDTH for each in wrapped_content), (
+        "All wrapped lines must be within MAX_WIDTH"
+    )
+
+
+def test_reflow_uses_config_constant_for_continuation_marker_width() -> None:
+    """The bash continuation marker width must come from config, not inline."""
+    module_path = _SCRIPTS_DIRECTORY / "reflow_skill_md.py"
+    source = module_path.read_text(encoding="utf-8")
+    assert "BASH_CONTINUATION_MARKER_WIDTH" in source, (
+        "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"
+    )

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

@@ -0,0 +1,448 @@
+"""Tests for reviewer_fetch_core.
+
+Covers:
+- fetch_reviewer_reviews invokes gh against the reviews endpoint with --paginate --slurp
+- login filter applies case-insensitively as a substring on user.login
+- entries missing submitted_at or id are filtered out
+- reviews are sorted newest-first by submitted_at
+- the spec.classify_review callable is invoked for each surviving review
+- subprocess errors propagate
+- fetch_reviewer_inline_comments returns empty when no review for current_head
+- fetch_reviewer_inline_comments only returns comments anchored to the latest review
+- fetch_reviewer_inline_comments invokes gh against the comments endpoint with --paginate --slurp
+"""
+
+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
+
+
+def _load_module() -> ModuleType:
+    module_path = Path(__file__).parent / "reviewer_fetch_core.py"
+    spec = importlib.util.spec_from_file_location("reviewer_fetch_core", 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
+
+
+reviewer_fetch_core_module = _load_module()
+
+
+def _completed(stdout: str) -> subprocess.CompletedProcess:
+    process = MagicMock(spec=subprocess.CompletedProcess)
+    process.stdout = stdout
+    process.returncode = 0
+    return process
+
+
+def _fake_spec(*, login_filter_substring: str = "test") -> object:
+    fake_spec_object = MagicMock()
+    fake_spec_object.login_filter_substring = login_filter_substring
+    fake_spec_object.classify_review = MagicMock(return_value="clean")
+    return fake_spec_object
+
+
+def test_fetch_reviewer_reviews_invokes_gh_with_paginate_slurp_against_reviews_endpoint() -> (
+    None
+):
+    pages_payload = json.dumps([[]])
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(pages_payload)
+        reviewer_fetch_core_module.fetch_reviewer_reviews(
+            _fake_spec(), owner="acme", repo="widget", number=42
+        )
+    invoked_argv = mock_run.call_args[0][0]
+    assert invoked_argv[0] == "gh"
+    assert invoked_argv[1] == "api"
+    assert "repos/acme/widget/pulls/42/reviews?per_page=100" in invoked_argv[2]
+    assert "--paginate" in invoked_argv
+    assert "--slurp" in invoked_argv
+
+
+def test_fetch_reviewer_reviews_filters_by_login_filter_substring_case_insensitively() -> (
+    None
+):
+    pages_payload = json.dumps(
+        [
+            [
+                {
+                    "id": 1,
+                    "user": {"login": "TestBot[bot]"},
+                    "state": "APPROVED",
+                    "commit_id": "abc",
+                    "submitted_at": "2026-01-01T00:00:00Z",
+                    "body": "uppercase login",
+                },
+                {
+                    "id": 2,
+                    "user": {"login": "other-reviewer"},
+                    "state": "APPROVED",
+                    "commit_id": "abc",
+                    "submitted_at": "2026-01-02T00:00:00Z",
+                    "body": "no match",
+                },
+            ]
+        ]
+    )
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(pages_payload)
+        all_reviews = reviewer_fetch_core_module.fetch_reviewer_reviews(
+            _fake_spec(login_filter_substring="test"),
+            owner="acme",
+            repo="widget",
+            number=42,
+        )
+    assert len(all_reviews) == 1
+    assert all_reviews[0]["review_id"] == 1
+
+
+def test_fetch_reviewer_reviews_drops_entries_missing_submitted_at() -> None:
+    pages_payload = json.dumps(
+        [
+            [
+                {
+                    "id": 1,
+                    "user": {"login": "test[bot]"},
+                    "state": "APPROVED",
+                    "commit_id": "abc",
+                    "body": "no submitted_at",
+                },
+                {
+                    "id": 2,
+                    "user": {"login": "test[bot]"},
+                    "state": "APPROVED",
+                    "commit_id": "abc",
+                    "submitted_at": "2026-01-02T00:00:00Z",
+                    "body": "valid",
+                },
+            ]
+        ]
+    )
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(pages_payload)
+        all_reviews = reviewer_fetch_core_module.fetch_reviewer_reviews(
+            _fake_spec(), owner="acme", repo="widget", number=42
+        )
+    assert [each_review["review_id"] for each_review in all_reviews] == [2]
+
+
+def test_fetch_reviewer_reviews_drops_entries_missing_id() -> None:
+    pages_payload = json.dumps(
+        [
+            [
+                {
+                    "user": {"login": "test[bot]"},
+                    "state": "APPROVED",
+                    "commit_id": "abc",
+                    "submitted_at": "2026-01-01T00:00:00Z",
+                    "body": "no id",
+                },
+                {
+                    "id": 99,
+                    "user": {"login": "test[bot]"},
+                    "state": "APPROVED",
+                    "commit_id": "abc",
+                    "submitted_at": "2026-01-02T00:00:00Z",
+                    "body": "valid",
+                },
+            ]
+        ]
+    )
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(pages_payload)
+        all_reviews = reviewer_fetch_core_module.fetch_reviewer_reviews(
+            _fake_spec(), owner="acme", repo="widget", number=42
+        )
+    assert [each_review["review_id"] for each_review in all_reviews] == [99]
+
+
+def test_fetch_reviewer_reviews_sorts_newest_first_across_pages() -> None:
+    pages_payload = json.dumps(
+        [
+            [
+                {
+                    "id": 10,
+                    "user": {"login": "test[bot]"},
+                    "state": "APPROVED",
+                    "commit_id": "old",
+                    "submitted_at": "2026-01-01T00:00:00Z",
+                    "body": "oldest",
+                }
+            ],
+            [
+                {
+                    "id": 11,
+                    "user": {"login": "test[bot]"},
+                    "state": "CHANGES_REQUESTED",
+                    "commit_id": "new",
+                    "submitted_at": "2026-01-03T00:00:00Z",
+                    "body": "newest",
+                },
+                {
+                    "id": 12,
+                    "user": {"login": "test[bot]"},
+                    "state": "APPROVED",
+                    "commit_id": "mid",
+                    "submitted_at": "2026-01-02T00:00:00Z",
+                    "body": "middle",
+                },
+            ],
+        ]
+    )
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(pages_payload)
+        all_reviews = reviewer_fetch_core_module.fetch_reviewer_reviews(
+            _fake_spec(), owner="acme", repo="widget", number=42
+        )
+    assert [each_review["submitted_at"] for each_review in all_reviews] == [
+        "2026-01-03T00:00:00Z",
+        "2026-01-02T00:00:00Z",
+        "2026-01-01T00:00:00Z",
+    ]
+
+
+def test_fetch_reviewer_reviews_invokes_classify_callable_per_review() -> None:
+    pages_payload = json.dumps(
+        [
+            [
+                {
+                    "id": 1,
+                    "user": {"login": "test[bot]"},
+                    "state": "APPROVED",
+                    "commit_id": "abc",
+                    "submitted_at": "2026-01-01T00:00:00Z",
+                    "body": "first",
+                },
+                {
+                    "id": 2,
+                    "user": {"login": "test[bot]"},
+                    "state": "CHANGES_REQUESTED",
+                    "commit_id": "abc",
+                    "submitted_at": "2026-01-02T00:00:00Z",
+                    "body": "second",
+                },
+            ]
+        ]
+    )
+    classify_callable = MagicMock(side_effect=["dirty", "clean"])
+    fake_spec_object = MagicMock()
+    fake_spec_object.login_filter_substring = "test"
+    fake_spec_object.classify_review = classify_callable
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(pages_payload)
+        all_reviews = reviewer_fetch_core_module.fetch_reviewer_reviews(
+            fake_spec_object, owner="acme", repo="widget", number=42
+        )
+    assert classify_callable.call_count == 2
+    assert {each_review["classification"] for each_review in all_reviews} == {
+        "dirty",
+        "clean",
+    }
+
+
+def test_fetch_reviewer_reviews_propagates_subprocess_errors() -> None:
+    failure = subprocess.CalledProcessError(
+        returncode=1, cmd=["gh"], stderr="auth failure"
+    )
+    with patch("subprocess.run", side_effect=failure):
+        try:
+            reviewer_fetch_core_module.fetch_reviewer_reviews(
+                _fake_spec(), owner="acme", repo="widget", number=42
+            )
+            assert False, "expected CalledProcessError"
+        except subprocess.CalledProcessError:
+            pass
+
+
+def test_fetch_reviewer_inline_comments_returns_empty_when_no_review_for_head() -> None:
+    no_matching_review = [
+        {
+            "review_id": 1,
+            "commit_id": "other_sha",
+            "submitted_at": "2026-01-01T00:00:00Z",
+            "state": "APPROVED",
+            "body": "",
+            "classification": "clean",
+        }
+    ]
+    with patch("subprocess.run") as mock_run:
+        all_inline_comments = reviewer_fetch_core_module.fetch_reviewer_inline_comments(
+            _fake_spec(),
+            owner="acme",
+            repo="widget",
+            number=42,
+            current_head="missing_sha",
+            all_reviews=no_matching_review,
+        )
+    assert all_inline_comments == []
+    mock_run.assert_not_called()
+
+
+def test_fetch_reviewer_inline_comments_invokes_gh_against_comments_endpoint() -> None:
+    pages_payload = json.dumps([[]])
+    matching_review = [
+        {
+            "review_id": 1,
+            "commit_id": "abc123",
+            "submitted_at": "2026-01-01T00:00:00Z",
+            "state": "APPROVED",
+            "body": "",
+            "classification": "clean",
+        }
+    ]
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(pages_payload)
+        reviewer_fetch_core_module.fetch_reviewer_inline_comments(
+            _fake_spec(),
+            owner="acme",
+            repo="widget",
+            number=42,
+            current_head="abc123",
+            all_reviews=matching_review,
+        )
+    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_fetch_reviewer_inline_comments_anchors_to_latest_review_id_for_head() -> None:
+    reviews_newest_first = [
+        {
+            "review_id": 11,
+            "commit_id": "same_sha",
+            "submitted_at": "2026-01-02T00:00:00Z",
+            "state": "APPROVED",
+            "body": "lgtm",
+            "classification": "clean",
+        },
+        {
+            "review_id": 10,
+            "commit_id": "same_sha",
+            "submitted_at": "2026-01-01T00:00:00Z",
+            "state": "CHANGES_REQUESTED",
+            "body": "fix",
+            "classification": "dirty",
+        },
+    ]
+    pages_payload = json.dumps(
+        [
+            [
+                {
+                    "id": 100,
+                    "user": {"login": "test[bot]"},
+                    "commit_id": "same_sha",
+                    "pull_request_review_id": 10,
+                    "body": "stale",
+                    "path": "x.py",
+                    "line": 1,
+                },
+                {
+                    "id": 101,
+                    "user": {"login": "test[bot]"},
+                    "commit_id": "same_sha",
+                    "pull_request_review_id": 11,
+                    "body": "current",
+                    "path": "x.py",
+                    "line": 2,
+                },
+            ]
+        ]
+    )
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(pages_payload)
+        all_inline_comments = reviewer_fetch_core_module.fetch_reviewer_inline_comments(
+            _fake_spec(),
+            owner="acme",
+            repo="widget",
+            number=42,
+            current_head="same_sha",
+            all_reviews=reviews_newest_first,
+        )
+    assert [each_comment["comment_id"] for each_comment in all_inline_comments] == [101]
+
+
+def test_fetch_reviewer_inline_comments_filters_login_substring() -> None:
+    matching_review = [
+        {
+            "review_id": 9,
+            "commit_id": "abc",
+            "submitted_at": "2026-01-01T00:00:00Z",
+            "state": "APPROVED",
+            "body": "",
+            "classification": "clean",
+        }
+    ]
+    pages_payload = json.dumps(
+        [
+            [
+                {
+                    "id": 1,
+                    "user": {"login": "test[bot]"},
+                    "commit_id": "abc",
+                    "pull_request_review_id": 9,
+                    "body": "match",
+                    "path": "f.py",
+                    "line": 1,
+                },
+                {
+                    "id": 2,
+                    "user": {"login": "other-reviewer"},
+                    "commit_id": "abc",
+                    "pull_request_review_id": 9,
+                    "body": "no match",
+                    "path": "f.py",
+                    "line": 2,
+                },
+            ]
+        ]
+    )
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(pages_payload)
+        all_inline_comments = reviewer_fetch_core_module.fetch_reviewer_inline_comments(
+            _fake_spec(login_filter_substring="test"),
+            owner="acme",
+            repo="widget",
+            number=42,
+            current_head="abc",
+            all_reviews=matching_review,
+        )
+    assert [each_comment["comment_id"] for each_comment in all_inline_comments] == [1]
+
+
+def test_fetch_reviewer_inline_comments_propagates_subprocess_errors() -> None:
+    matching_review = [
+        {
+            "review_id": 1,
+            "commit_id": "abc",
+            "submitted_at": "2026-01-01T00:00:00Z",
+            "state": "APPROVED",
+            "body": "",
+            "classification": "clean",
+        }
+    ]
+    failure = subprocess.CalledProcessError(
+        returncode=1, cmd=["gh"], stderr="auth failure"
+    )
+    with patch("subprocess.run", side_effect=failure):
+        try:
+            reviewer_fetch_core_module.fetch_reviewer_inline_comments(
+                _fake_spec(),
+                owner="acme",
+                repo="widget",
+                number=42,
+                current_head="abc",
+                all_reviews=matching_review,
+            )
+            assert False, "expected CalledProcessError"
+        except subprocess.CalledProcessError:
+            pass