npm - claude-dev-env - Versions diffs - 1.41.0 → 1.42.0 - Mend

claude-dev-env 1.41.0 → 1.42.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (33) hide show

package/skills/implement/scripts/test_append_note.py ADDED Viewed

@@ -0,0 +1,191 @@
+"""Tests for append_note.
+Covers:
+- _build_skeleton emits a four-section HTML document keyed by every slug
+- _ensure_file creates a fresh file on first call and round-trips on subsequent calls
+- _render_entry HTML-escapes the about label and the note body
+- _insert_entry puts the first <li> on its own line and keeps a 6-space indent across entries
+- _insert_entry raises a descriptive RuntimeError when the section block is missing
+- _insert_entry raises a descriptive RuntimeError when the closing </ul> is missing
+- main appends through the CLI surface against a real on-disk file
+"""
+from __future__ import annotations
+import importlib.util
+import subprocess
+import sys
+from pathlib import Path
+from types import ModuleType
+import pytest
+_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 / "append_note.py"
+    spec = importlib.util.spec_from_file_location("append_note", 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
+append_note_module = _load_module()
+HEADING_BY_SLUG = append_note_module.HEADING_BY_SLUG
+def test_should_build_skeleton_with_every_section_slug() -> None:
+    skeleton = append_note_module._build_skeleton()
+    for each_slug, each_heading in HEADING_BY_SLUG.items():
+        assert f'<section id="{each_slug}">' in skeleton
+        assert f"<h2>{each_heading}</h2>" in skeleton
+    assert skeleton.count("<ul></ul>") == len(HEADING_BY_SLUG)
+def test_should_create_file_with_skeleton_on_first_ensure(tmp_path: Path) -> None:
+    target = tmp_path / "subdir" / "implementation-notes.html"
+    document = append_note_module._ensure_file(target)
+    assert target.exists()
+    assert document == target.read_text(encoding="utf-8")
+    assert '<section id="decisions">' in document
+def test_should_return_existing_content_on_subsequent_ensure(tmp_path: Path) -> None:
+    target = tmp_path / "notes.html"
+    custom_content = "<!doctype html><html><body>existing</body></html>\n"
+    target.write_text(custom_content, encoding="utf-8")
+    returned = append_note_module._ensure_file(target)
+    assert returned == custom_content
+def test_should_escape_html_metacharacters_in_about_and_note() -> None:
+    entry = append_note_module._render_entry("a<b & c>d", "<script>x</script>")
+    assert "<script>" not in entry
+    assert "&lt;script&gt;" in entry
+    assert "a&lt;b &amp; c&gt;d" in entry
+def test_should_put_first_entry_on_its_own_line_inside_empty_ul() -> None:
+    skeleton = append_note_module._build_skeleton()
+    entry = append_note_module._render_entry("First", "alpha")
+    after_first = append_note_module._insert_entry(skeleton, "decisions", entry)
+    assert "<ul>      <li>" not in after_first
+    assert "<ul>\n      <li>" in after_first
+def test_should_keep_uniform_six_space_indent_across_multiple_entries() -> None:
+    skeleton = append_note_module._build_skeleton()
+    first_entry = append_note_module._render_entry("First", "alpha")
+    second_entry = append_note_module._render_entry("Second", "beta")
+    after_first = append_note_module._insert_entry(skeleton, "decisions", first_entry)
+    after_second = append_note_module._insert_entry(after_first, "decisions", second_entry)
+    decisions_section_start = after_second.index('<section id="decisions">')
+    decisions_section_end = after_second.index("</section>", decisions_section_start)
+    decisions_section = after_second[decisions_section_start:decisions_section_end]
+    assert "          <li>" not in decisions_section
+    assert decisions_section.count("\n      <li>") == 2
+def test_should_raise_when_requested_section_is_absent() -> None:
+    document_without_section = "<html><body></body></html>\n"
+    entry = append_note_module._render_entry("x", "y")
+    with pytest.raises(RuntimeError, match="section 'decisions' not found"):
+        append_note_module._insert_entry(document_without_section, "decisions", entry)
+def test_should_raise_when_closing_ul_is_missing() -> None:
+    truncated_section = '<section id="decisions">\n    <h2>Design decisions</h2>\n    <ul>\n  </section>\n'
+    entry = append_note_module._render_entry("x", "y")
+    with pytest.raises(RuntimeError, match="missing its closing </ul>"):
+        append_note_module._insert_entry(truncated_section, "decisions", entry)
+def test_should_not_borrow_closing_ul_from_a_later_section() -> None:
+    malformed_first_with_intact_second = (
+        '<section id="decisions">\n'
+        '    <h2>Design decisions</h2>\n'
+        '    <ul>\n'
+        '  </section>\n'
+        '  <section id="deviations">\n'
+        '    <h2>Deviations</h2>\n'
+        '    <ul></ul>\n'
+        '  </section>\n'
+    )
+    entry = append_note_module._render_entry("x", "y")
+    with pytest.raises(RuntimeError, match="missing its closing </ul>"):
+        append_note_module._insert_entry(malformed_first_with_intact_second, "decisions", entry)
+def test_should_raise_when_closing_section_is_missing() -> None:
+    section_without_close = '<section id="decisions">\n    <h2>Design decisions</h2>\n    <ul></ul>\n'
+    entry = append_note_module._render_entry("x", "y")
+    with pytest.raises(RuntimeError, match="missing its closing </section>"):
+        append_note_module._insert_entry(section_without_close, "decisions", entry)
+def test_should_append_through_cli_against_real_file(tmp_path: Path) -> None:
+    target = tmp_path / "notes.html"
+    script_path = _SCRIPTS_DIRECTORY / "append_note.py"
+    first_run = subprocess.run(
+        [
+            sys.executable,
+            str(script_path),
+            "--section",
+            "decisions",
+            "--about",
+            "First",
+            "--note",
+            "alpha",
+            "--file",
+            str(target),
+        ],
+        cwd=str(_SCRIPTS_DIRECTORY),
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    second_run = subprocess.run(
+        [
+            sys.executable,
+            str(script_path),
+            "--section",
+            "questions",
+            "--about",
+            "Q1",
+            "--note",
+            "<beta & gamma>",
+            "--file",
+            str(target),
+        ],
+        cwd=str(_SCRIPTS_DIRECTORY),
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert first_run.returncode == 0, first_run.stderr
+    assert second_run.returncode == 0, second_run.stderr
+    output = target.read_text(encoding="utf-8")
+    assert "<li><strong>First:</strong> alpha</li>" in output
+    assert "<li><strong>Q1:</strong> &lt;beta &amp; gamma&gt;</li>" in output

package/skills/pr-converge/config/constants.py CHANGED Viewed

@@ -33,6 +33,11 @@ ALL_BUGBOT_CHECK_RUN_COMPLETE_CONCLUSIONS = ("success", "neutral")
 BUGBOT_RUN_TRIGGER_PHRASE = "bugbot run\n"
 BUGBOT_RUN_TRIGGER_WAIT_SECONDS = 8
+BUGTEAM_NEW_HEADER_PREFIX = "**Bugteam audit completed**"
+BUGTEAM_LEGACY_HEADER_PREFIX = "## /bugteam loop "
+BUGTEAM_NEW_CLEAN_LABEL = "Clean — no findings"
+BUGTEAM_LEGACY_CLEAN_TOKEN = "→ clean"
 GH_INLINE_COMMENTS_PATH_TEMPLATE = "repos/{owner}/{repo}/pulls/{number}/comments"
 GH_REVIEW_COMMENTS_PATH_TEMPLATE = (
     "repos/{owner}/{repo}/pulls/{number}/reviews/{review_id}/comments"

package/skills/pr-converge/scripts/check_bugbot_ci.py CHANGED Viewed

@@ -29,7 +29,7 @@ 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))

package/skills/pr-converge/scripts/check_convergence.py CHANGED Viewed

@@ -2,9 +2,10 @@
 Usage:
   python scripts/check_convergence.py --owner <O> --repo <R> --pr-number <N>
+                                      [--bugbot-down]
 Exit codes:
-  0 — all seven pre-conditions met
+  0 — all pre-conditions met
   1 — one or more conditions not met (FAIL lines printed to stdout)
   2 — gh CLI error
 """
@@ -18,18 +19,20 @@ 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 (
-    ALL_CLAUDE_DIRTY_REVIEW_STATES,
     ALL_COPILOT_DIRTY_REVIEW_STATES,
     ALL_BUGBOT_CHECK_RUN_COMPLETE_CONCLUSIONS,
     BUGBOT_CHECK_RUN_NAME_SUBSTRING,
     BUGBOT_DIRTY_BODY_REGEX,
+    BUGTEAM_LEGACY_CLEAN_TOKEN,
+    BUGTEAM_LEGACY_HEADER_PREFIX,
+    BUGTEAM_NEW_CLEAN_LABEL,
+    BUGTEAM_NEW_HEADER_PREFIX,
     CHECK_RUNS_PER_PAGE,
-    ALL_CLAUDE_CLEAN_REVIEW_STATES,
     CLAUDE_LOGIN_FILTER_SUBSTRING,
     ALL_COPILOT_CLEAN_REVIEW_STATES,
     COPILOT_LOGIN_FILTER_SUBSTRING,
@@ -46,6 +49,93 @@ from config.constants import (
 )
+def _is_bugteam_review(review_body: str) -> bool:
+    """Return True when a review body opens with a bugteam audit header.
+    Args:
+        review_body: Full body text of a PR review.
+    Returns:
+        True when the body opens with either the new audit-template header
+        prefix or the legacy bugteam loop header prefix; False otherwise.
+        Used to identify bugteam audit reviews by body content rather than
+        by the posting user's GitHub login (the underlying ``gh`` token is
+        typically the PR-owner or reviewer identity, not ``claude[bot]``).
+    """
+    return (
+        review_body.startswith(BUGTEAM_NEW_HEADER_PREFIX)
+        or review_body.startswith(BUGTEAM_LEGACY_HEADER_PREFIX)
+    )
+def _is_clean_bugteam_review(review_body: str) -> bool:
+    """Return True when a bugteam audit review body declares a clean pass.
+    Args:
+        review_body: Body text of a review that has already satisfied
+            :func:`_is_bugteam_review`.
+    Returns:
+        True when the new-shape body's first line carries the clean state
+        label, or the legacy-shape body ends with the legacy clean token.
+        False for any other shape, including dirty audit reviews and
+        bodies that do not match the bugteam header signature.
+    """
+    if review_body.startswith(BUGTEAM_NEW_HEADER_PREFIX):
+        first_line = review_body.splitlines()[0]
+        return BUGTEAM_NEW_CLEAN_LABEL in first_line
+    if review_body.startswith(BUGTEAM_LEGACY_HEADER_PREFIX):
+        return review_body.rstrip().endswith(BUGTEAM_LEGACY_CLEAN_TOKEN)
+    return False
+def _check_bugteam_clean(
+    *, owner: str, repo: str, number: int, head_sha: str
+) -> tuple[bool, str]:
+    endpoint = GH_REVIEWS_PATH_TEMPLATE.format(owner=owner, repo=repo, number=number)
+    returncode, stdout = _gh_api_paginated(f"{endpoint}?per_page={REVIEWS_PER_PAGE}")
+    if returncode != 0:
+        return False, f"gh api error: {stdout}"
+    try:
+        raw_output = json.loads(stdout)
+    except json.JSONDecodeError:
+        return False, "gh api response not valid JSON"
+    if not isinstance(raw_output, list):
+        return False, "unexpected gh api response shape (expected list)"
+    all_pages = [p for p in raw_output if isinstance(p, list)]
+    all_flat: list[dict[str, object]] = [
+        each_entry
+        for page in all_pages
+        for each_entry in page
+        if isinstance(each_entry, dict)
+    ]
+    all_flat.sort(
+        key=lambda each_review: str(each_review.get("submitted_at", "")),
+        reverse=True,
+    )
+    for each_review in all_flat:
+        body = each_review.get("body", "")
+        if not isinstance(body, str):
+            continue
+        if not _is_bugteam_review(body):
+            continue
+        commit_id = each_review.get("commit_id", "")
+        if not isinstance(commit_id, str) or not commit_id.startswith(head_sha):
+            continue
+        review_id = each_review.get("id", "?")
+        short_commit = commit_id[:7]
+        if _is_clean_bugteam_review(body):
+            return (
+                True,
+                f"review #{review_id}, clean bugteam audit, commit: {short_commit}",
+            )
+        return (
+            False,
+            f"review #{review_id}, dirty bugteam audit, commit: {short_commit}",
+        )
+    return False, f"no bugteam review found on {head_sha[:7]}"
 def _gh_api(endpoint_path: str) -> tuple[int, str]:
     completed_process = subprocess.run(
         ["gh", "api", endpoint_path],
@@ -387,38 +477,60 @@ def _check_no_pending_reviews(
     return True, "no pending reviewers"
-def check_all(*, owner: str, repo: str, number: int) -> int:
+def check_all(*, owner: str, repo: str, number: int, bugbot_down: bool) -> int:
+    """Run every convergence gate and print one PASS/FAIL line per condition.
+    Args:
+        owner: GitHub repository owner login.
+        repo: GitHub repository name.
+        number: Pull request number to inspect.
+        bugbot_down: When True, bypass both the Cursor Bugbot check-run
+            presence gate and the bugbot review-body content gate. The
+            check-run gate appears in the condition list with a
+            ``bypassed (bugbot_down)`` note; the review-body gate is
+            omitted entirely. Callers pass True when the lead has
+            declared Cursor Bugbot unreachable on the current HEAD so the
+            broader convergence gate can still close on the remaining
+            signals.
+    Returns:
+        ``0`` when every gate reports PASS, ``1`` when at least one gate
+        reports FAIL. The function never raises for gate-level failures;
+        gh-api transport failures surface as gate FAILs in the printed
+        output and contribute to the ``1`` exit code.
+    """
     head_sha = _get_pr_head_sha(owner=owner, repo=repo, number=number)
     print(f"HEAD: {head_sha[:7]}\n")
     conditions: list[tuple[str, tuple[bool, str]]] = []
-    conditions.append(
-        (
-            "bugbot_clean_at == current_head",
-            _check_bugbot(owner=owner, repo=repo, sha=head_sha),
+    if bugbot_down:
+        conditions.append(
+            (
+                "bugbot_clean_at == current_head",
+                (True, "bypassed (bugbot_down)"),
+            )
         )
-    )
-    if conditions[-1][1][0]:
+    else:
         conditions.append(
             (
-                "bugbot review body clean",
-                _check_bugbot_not_dirty(owner=owner, repo=repo, number=number, head_sha=head_sha),
+                "bugbot_clean_at == current_head",
+                _check_bugbot(owner=owner, repo=repo, sha=head_sha),
             )
         )
+        if conditions[-1][1][0]:
+            conditions.append(
+                (
+                    "bugbot review body clean",
+                    _check_bugbot_not_dirty(owner=owner, repo=repo, number=number, head_sha=head_sha),
+                )
+            )
     conditions.append(
         (
             "bugteam_clean_at == current_head",
-            _check_bot_review(
-                owner=owner,
-                repo=repo,
-                number=number,
-                head_sha=head_sha,
-                login_substring=CLAUDE_LOGIN_FILTER_SUBSTRING,
-                clean_states=ALL_CLAUDE_CLEAN_REVIEW_STATES,
-                dirty_states=ALL_CLAUDE_DIRTY_REVIEW_STATES,
-                label="claude[bot]",
+            _check_bugteam_clean(
+                owner=owner, repo=repo, number=number, head_sha=head_sha
             ),
         )
     )
@@ -458,13 +570,11 @@ def check_all(*, owner: str, repo: str, number: int) -> int:
     )
     is_all_passed = True
-    index = 1
-    for label, (passed, detail) in conditions:
-        status = "PASS" if passed else "FAIL"
-        print(f"{index}. {label}: {status} — {detail}")
-        if not passed:
+    for each_index, (each_label, (each_passed, each_detail)) in enumerate(conditions, start=1):
+        status = "PASS" if each_passed else "FAIL"
+        print(f"{each_index}. {each_label}: {status} — {each_detail}")
+        if not each_passed:
             is_all_passed = False
-        index += 1
     print()
     if is_all_passed:
@@ -475,21 +585,50 @@ def check_all(*, owner: str, repo: str, number: int) -> int:
 def parse_arguments(all_argv: list[str]) -> argparse.Namespace:
+    """Parse command-line arguments for the convergence checker.
+    Args:
+        all_argv: Argument list excluding the program name, typically
+            ``sys.argv[1:]``.
+    Returns:
+        Namespace exposing ``owner``, ``repo``, ``pr_number``, and
+        ``bugbot_down`` attributes. ``bugbot_down`` defaults to False so
+        the unmodified hook contract (``--owner X --repo Y --pr-number N``)
+        still picks up the full gate set.
+    """
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--owner", required=True, help="GitHub repository owner")
     parser.add_argument("--repo", required=True, help="GitHub repository name")
     parser.add_argument(
         "--pr-number", required=True, type=int, help="Pull request number"
     )
+    parser.add_argument(
+        "--bugbot-down",
+        action="store_true",
+        help=(
+            "Bypass the bugbot check-run gate (gate 1) when the lead has "
+            "declared Cursor Bugbot unreachable on the current HEAD."
+        ),
+    )
     return parser.parse_args(all_argv)
 def main(all_arguments: list[str]) -> int:
+    """Run the script end-to-end against parsed CLI arguments.
+    Args:
+        all_arguments: Argument list excluding the program name.
+    Returns:
+        ``0`` on full convergence, ``1`` on one or more gate failures.
+    """
     arguments = parse_arguments(all_arguments)
     return check_all(
         owner=arguments.owner,
         repo=arguments.repo,
         number=getattr(arguments, "pr_number"),
+        bugbot_down=arguments.bugbot_down,
     )

package/skills/pr-converge/scripts/check_pending_reviews.py CHANGED Viewed

@@ -17,7 +17,7 @@ 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))

package/skills/pr-converge/scripts/conftest.py ADDED Viewed

@@ -0,0 +1,60 @@
+"""Test fixtures for skills/pr-converge/scripts/.
+Two unrelated Python packages live under the name ``config`` in this repo:
+  - ``skills/pr-converge/config/`` (constants for the pr-converge scripts)
+  - ``hooks/config/`` (constants for the code-rules enforcer and other hooks)
+When tests under this directory exercise pr-converge scripts that load
+``from config.constants import ...`` and other code paths in the same
+pytest process also load a different ``config`` package,
+``sys.modules['config']`` and ``sys.modules['config.<submodule>']`` cache
+entries from one package leak into the other. The next
+``from config.<submodule> import ...`` then fails with
+``ModuleNotFoundError`` because the cached parent package does not
+expose that submodule.
+Independently, several scripts in this folder do
+``Path(__file__).resolve()`` then prepend the resulting directory to
+``sys.path``. On Windows when the working tree lives under a mapped drive
+backed by a UNC share (``Y:`` -> ``\\\\server\\share\\...``), ``.resolve()``
+returns the UNC form, and Python's import machinery on this host cannot
+locate ``config`` packages from a UNC ``sys.path`` entry. The Y:-form entry
+gets pushed to a later index by subsequent inserts, making
+``from config.<submodule> import ...`` fail.
+This autouse fixture restores both invariants once per pytest session,
+immediately before the first test executes (after collection and module
+imports have completed; session-scoped fixtures run after import, not
+before, so test-module-level ``import`` of pr-converge scripts is
+isolated by each module's own ``_load_module()`` helper rather than by
+this fixture):
+  1. evict every ``config`` and ``config.*`` entry from ``sys.modules``
+  2. prepend the drive-letter (``.absolute()``) form of the pr-converge
+     directory to ``sys.path`` so package resolution always has a
+     non-UNC path to search first
+"""
+from __future__ import annotations
+import sys
+from pathlib import Path
+import pytest
+PR_CONVERGE_DIRECTORY_DRIVE_LETTER_FORM = str(Path(__file__).absolute().parent.parent)
+if PR_CONVERGE_DIRECTORY_DRIVE_LETTER_FORM not in sys.path:
+    sys.path.insert(0, PR_CONVERGE_DIRECTORY_DRIVE_LETTER_FORM)
+@pytest.fixture(scope="session", autouse=True)
+def _evict_config_namespace_at_session_start() -> None:
+    for each_module_name in [
+        each_key
+        for each_key in list(sys.modules)
+        if each_key == "config" or each_key.startswith("config.")
+    ]:
+        sys.modules.pop(each_module_name, None)
+    if PR_CONVERGE_DIRECTORY_DRIVE_LETTER_FORM in sys.path:
+        sys.path.remove(PR_CONVERGE_DIRECTORY_DRIVE_LETTER_FORM)
+    sys.path.insert(0, PR_CONVERGE_DIRECTORY_DRIVE_LETTER_FORM)

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

@@ -15,7 +15,7 @@ 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))

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

@@ -20,7 +20,7 @@ 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))

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

@@ -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")