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

claude-dev-env 1.41.0 → 1.43.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 (214) hide show

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

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""Append an entry to implementation-notes.html under one of four sections.
+Used by the `implement` skill. Creates the file with all four sections if it
+does not exist; otherwise appends a new <li> under the requested section.
+Usage:
+    python append_note.py --section decisions --about "Where to write the file" --note "Wrote next to spec rather than CWD because spec path was known."
+    python append_note.py --section questions --about "Auth model" --note "Spec didn't say whether sessions persist across restarts." --file ./notes.html
+"""
+from __future__ import annotations
+import argparse
+import html
+import sys
+from pathlib import Path
+from implement_scripts_constants.notes_constants import DEFAULT_NOTES_FILENAME, HEADING_BY_SLUG
+def _build_skeleton() -> str:
+    section_blocks = "\n".join(
+        f'  <section id="{each_slug}">\n    <h2>{each_heading}</h2>\n    <ul></ul>\n  </section>'
+        for each_slug, each_heading in HEADING_BY_SLUG.items()
+    )
+    return (
+        "<!doctype html>\n"
+        '<html lang="en">\n'
+        "<head>\n"
+        '  <meta charset="utf-8">\n'
+        "  <title>Implementation notes</title>\n"
+        "</head>\n"
+        "<body>\n"
+        "  <h1>Implementation notes</h1>\n"
+        f"{section_blocks}\n"
+        "</body>\n"
+        "</html>\n"
+    )
+def _ensure_file(target: Path) -> str:
+    if not target.exists():
+        target.parent.mkdir(parents=True, exist_ok=True)
+        skeleton = _build_skeleton()
+        target.write_text(skeleton, encoding="utf-8")
+        return skeleton
+    return target.read_text(encoding="utf-8")
+def _render_entry(about: str, note: str) -> str:
+    return f"<li><strong>{html.escape(about)}:</strong> {html.escape(note)}</li>"
+def _insert_entry(document: str, slug: str, entry: str) -> str:
+    open_marker = f'<section id="{slug}">'
+    section_close_marker = "</section>"
+    close_marker = "</ul>"
+    section_start = document.find(open_marker)
+    if section_start == -1:
+        raise RuntimeError(
+            f"section '{slug}' not found in file — the file may have been "
+            f"edited by hand. Restore the four <section id=...> blocks or "
+            f"delete the file so it can be regenerated."
+        )
+    section_end = document.find(section_close_marker, section_start)
+    if section_end == -1:
+        raise RuntimeError(
+            f"section '{slug}' is missing its closing </section> — the file "
+            f"may have been edited by hand."
+        )
+    close_at = document.find(close_marker, section_start, section_end)
+    if close_at == -1:
+        raise RuntimeError(
+            f"section '{slug}' is missing its closing </ul> — the file may "
+            f"have been edited by hand."
+        )
+    boundary = close_at
+    while boundary > 0 and document[boundary - 1] in (" ", "\n"):
+        boundary -= 1
+    new_line = f"\n      {entry}"
+    return document[:boundary] + new_line + "\n    " + document[close_at:]
+def _parse_arguments() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=f"Append an entry to {DEFAULT_NOTES_FILENAME}.",
+    )
+    parser.add_argument(
+        "--section",
+        required=True,
+        choices=sorted(HEADING_BY_SLUG.keys()),
+        help="Which section to append under.",
+    )
+    parser.add_argument(
+        "--about",
+        required=True,
+        help="Short label naming the part of the spec this entry relates to.",
+    )
+    parser.add_argument(
+        "--note",
+        required=True,
+        help="The decision / deviation / tradeoff / question itself.",
+    )
+    parser.add_argument(
+        "--file",
+        default=DEFAULT_NOTES_FILENAME,
+        help=(
+            f"Path to the notes file. Defaults to ./{DEFAULT_NOTES_FILENAME} "
+            f"in the current working directory."
+        ),
+    )
+    return parser.parse_args()
+def main() -> int:
+    """Parse CLI arguments and append one entry to the notes file.
+    Returns:
+        Process exit code (0 on success).
+    """
+    arguments = _parse_arguments()
+    target_path = Path(arguments.file).expanduser().resolve()
+    document = _ensure_file(target_path)
+    entry = _render_entry(arguments.about, arguments.note)
+    updated = _insert_entry(document, arguments.section, entry)
+    target_path.write_text(updated, encoding="utf-8")
+    print(f"appended to [{arguments.section}] in {target_path}")
+    return 0
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/implement/scripts/implement_scripts_constants/__init__.py ADDED Viewed

File without changes

package/skills/implement/scripts/implement_scripts_constants/notes_constants.py ADDED Viewed

@@ -0,0 +1,12 @@
+"""Configuration for the implementation-notes append script."""
+from __future__ import annotations
+HEADING_BY_SLUG: dict[str, str] = {
+    "decisions": "Design decisions",
+    "deviations": "Deviations",
+    "tradeoffs": "Tradeoffs",
+    "questions": "Open questions",
+}
+DEFAULT_NOTES_FILENAME = "implementation-notes.html"

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/pr_converge_skill_constants/__init__.py ADDED Viewed

File without changes

package/skills/pr-converge/{config → pr_converge_skill_constants}/constants.py RENAMED Viewed

@@ -2,7 +2,7 @@
 All runtime and API constants live here. Script-specific constants
 (CLI args, markdown patterns, reflow settings) stay in
-``packages/claude-dev-env/skills/pr-converge/scripts/config/pr_converge_constants.py``,
+``packages/claude-dev-env/skills/pr-converge/scripts/pr_converge_scripts_constants/pr_converge_constants.py``,
 which imports from here.
 """
@@ -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,11 +29,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 (
     ALL_BUGBOT_CHECK_RUN_ACTIVE_STATUSES,
     ALL_BUGBOT_CHECK_RUN_COMPLETE_CONCLUSIONS,
     BUGBOT_CHECK_RUN_COMPLETED_STATUS,

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,
+from pr_converge_skill_constants.constants import (
     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,67 @@ 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. Per-gate ``gh api`` transport failures surface as
+        gate FAIL lines in the printed output and contribute to the ``1``
+        exit code.
+    Raises:
+        SystemExit: Propagated by the initial ``_get_pr_head_sha`` call
+            with ``EXIT_CODE_GH_ERROR`` when the PR-head-SHA fetch fails
+            before any gate runs. The function does not catch this
+            exception; the caller is responsible for converting it into
+            an 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 +577,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 +592,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,11 +17,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_REVIEWS_PATH_TEMPLATE,
     REVIEWS_PER_PAGE,