claude-dev-env 1.34.1 → 1.36.0

package/skills/pr-converge/scripts/cursor-agents-continue.ahk

@@ -0,0 +1,172 @@
+; cursor-agents-continue.ahk
+; Sends "continue" + Enter to a Cursor Agents window every 5 minutes when enabled.
+; Toggle with Ctrl+Alt+A. Optional first CLI arg overrides the target window title substring.
+; A small colored pill on the upper-right corner of the rightmost monitor shows ON/OFF state.
+
+#Requires AutoHotkey v2.0
+#SingleInstance Force
+
+SetTitleMatchMode 2
+
+DEFAULT_TARGET_WINDOW_TITLE := "Cursor Agents"
+SEND_INTERVAL_MILLISECONDS  := 300000
+ACTIVATION_TIMEOUT_SECONDS  := 2
+FOCUS_SETTLE_SLEEP_MS       := 150
+POST_TEXT_SLEEP_MS          := 50
+CONTINUE_PHRASE             := "continue"
+
+INDICATOR_DESIGN_WIDTH_PX        := 230
+INDICATOR_DESIGN_HEIGHT_PX       := 28
+INDICATOR_DESIGN_RIGHT_OFFSET_PX := 16
+INDICATOR_DESIGN_TOP_OFFSET_PX   := 8
+INDICATOR_TEXT_DESIGN_PADDING_PX := 4
+INDICATOR_TEXT_DESIGN_HEIGHT_PX  := 20
+
+INDICATOR_FONT_NAME       := "Segoe UI"
+INDICATOR_FONT_POINT_SIZE := 9
+INDICATOR_FONT_OPTIONS    := "s" INDICATOR_FONT_POINT_SIZE " cWhite Bold"
+
+COLOR_OFF_BACKGROUND := "800000"
+COLOR_ON_BACKGROUND  := "006400"
+LABEL_OFF            := "AGENTS: OFF  (Ctrl+Alt+A)"
+LABEL_ON             := "AGENTS: ON  (Ctrl+Alt+A)"
+
+DPI_REFERENCE := 96
+
+AUTO_START_FLAG := "--start-on"
+
+INT32_MINIMUM_VALUE := -2147483648
+
+terminate_other_script_instances() {
+    stop_script := A_ScriptDir "\cursor-agents-continue-stop-others.ps1"
+    if !FileExist(stop_script)
+        return
+    RunWait('pwsh -NoProfile -NoLogo -ExecutionPolicy Bypass -File "' stop_script '" -KeepProcessId ' ProcessExist(), , "Hide")
+}
+
+terminate_other_script_instances()
+
+target_window_title := resolve_target_window_title_from_arguments()
+should_auto_start := has_auto_start_flag()
+is_enabled := false
+
+indicator := unset
+indicator_label := unset
+build_indicator()
+render_indicator(false)
+if (should_auto_start)
+    apply_enabled_state(true)
+
+^!a:: {
+    global is_enabled
+    apply_enabled_state(!is_enabled)
+}
+
+apply_enabled_state(next_enabled) {
+    global is_enabled
+    is_enabled := next_enabled
+    render_indicator(is_enabled)
+    if (is_enabled) {
+        send_continue_to_target()
+        SetTimer(send_continue_to_target, SEND_INTERVAL_MILLISECONDS)
+        return
+    }
+    SetTimer(send_continue_to_target, 0)
+}
+
+has_auto_start_flag() {
+    each_arg_index := 1
+    while (each_arg_index <= A_Args.Length) {
+        if (A_Args[each_arg_index] = AUTO_START_FLAG)
+            return true
+        each_arg_index++
+    }
+    return false
+}
+
+resolve_target_window_title_from_arguments() {
+    candidate := ""
+    each_arg_index := 1
+    while (each_arg_index <= A_Args.Length) {
+        arg_value := A_Args[each_arg_index]
+        if (arg_value = AUTO_START_FLAG) {
+            each_arg_index++
+            continue
+        }
+        if (candidate = "") {
+            candidate := arg_value
+        }
+        each_arg_index++
+    }
+    if (candidate = "")
+        return DEFAULT_TARGET_WINDOW_TITLE
+    return IsInteger(candidate) ? "ahk_pid " candidate : candidate
+}
+
+
+build_indicator() {
+    global indicator, indicator_label
+    dpi_scale_factor := A_ScreenDPI / DPI_REFERENCE
+    scaled_width        := Round(INDICATOR_DESIGN_WIDTH_PX        * dpi_scale_factor)
+    scaled_height       := Round(INDICATOR_DESIGN_HEIGHT_PX       * dpi_scale_factor)
+    scaled_right_offset := Round(INDICATOR_DESIGN_RIGHT_OFFSET_PX * dpi_scale_factor)
+    scaled_top_offset   := Round(INDICATOR_DESIGN_TOP_OFFSET_PX   * dpi_scale_factor)
+    scaled_text_padding := Round(INDICATOR_TEXT_DESIGN_PADDING_PX * dpi_scale_factor)
+    scaled_text_height  := Round(INDICATOR_TEXT_DESIGN_HEIGHT_PX  * dpi_scale_factor)
+    scaled_text_width   := scaled_width - (scaled_text_padding * 2)
+
+    rightmost_monitor_bounds := find_rightmost_monitor_bounds()
+
+    indicator := Gui("-Caption +AlwaysOnTop +ToolWindow -DPIScale")
+    indicator.BackColor := COLOR_OFF_BACKGROUND
+    indicator.SetFont(INDICATOR_FONT_OPTIONS, INDICATOR_FONT_NAME)
+    indicator_label := indicator.Add(
+        "Text",
+        "x" scaled_text_padding " y" scaled_text_padding
+        . " w" scaled_text_width " h" scaled_text_height
+        . " Center BackgroundTrans",
+        LABEL_OFF
+    )
+
+    indicator_x := rightmost_monitor_bounds.right_edge - scaled_width - scaled_right_offset
+    indicator_y := rightmost_monitor_bounds.top_edge + scaled_top_offset
+    indicator.Show("x" indicator_x " y" indicator_y " w" scaled_width " h" scaled_height " NoActivate")
+}
+
+render_indicator(is_currently_enabled) {
+    global indicator, indicator_label
+    indicator.BackColor := is_currently_enabled ? COLOR_ON_BACKGROUND : COLOR_OFF_BACKGROUND
+    indicator_label.Text := is_currently_enabled ? LABEL_ON : LABEL_OFF
+    WinRedraw("ahk_id " indicator.Hwnd)
+}
+
+send_continue_to_target() {
+    global target_window_title
+    if (!WinExist(target_window_title))
+        return
+    try {
+        WinActivate(target_window_title)
+        if (!WinWaitActive(target_window_title, , ACTIVATION_TIMEOUT_SECONDS))
+            return
+    } catch TargetError {
+        return
+    }
+    Sleep FOCUS_SETTLE_SLEEP_MS
+    SendText CONTINUE_PHRASE
+    Sleep POST_TEXT_SLEEP_MS
+    Send "{Enter}"
+}
+
+find_rightmost_monitor_bounds() {
+    monitor_count := MonitorGetCount()
+    rightmost_edge_px := INT32_MINIMUM_VALUE
+    rightmost_monitor_top_px := 0
+    loop monitor_count {
+        MonitorGet(A_Index, &monitor_left, &monitor_top, &monitor_right, &monitor_bottom)
+        if (monitor_right > rightmost_edge_px) {
+            rightmost_edge_px := monitor_right
+            rightmost_monitor_top_px := monitor_top
+        }
+    }
+    return { right_edge: rightmost_edge_px, top_edge: rightmost_monitor_top_px }
+}

package/skills/pr-converge/scripts/cursor-agents-continue.cmd

@@ -0,0 +1,2 @@
+@echo off
+start "" "C:\Program Files\AutoHotkey\v2\AutoHotkey64.exe" "%~dp0cursor-agents-continue.ahk" %*

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

@@ -0,0 +1,20 @@
+"""Evict cached ``config`` package bindings before local ``config`` imports.
+
+Mirrors ``_evict_config_module`` in the repository root ``conftest.py``: stale
+``config`` or ``config.*`` entries from other packages must not satisfy
+``from config.…`` in these scripts after ``sys.path`` inserts the script directory.
+"""
+
+from __future__ import annotations
+
+import importlib
+import sys
+
+
+def evict_cached_config_modules() -> None:
+    for each_cached_module_name in list(sys.modules):
+        is_config_root = each_cached_module_name == "config"
+        is_config_submodule = each_cached_module_name.startswith("config.")
+        if is_config_root or is_config_submodule:
+            sys.modules.pop(each_cached_module_name, None)
+    importlib.invalidate_caches()

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

@@ -0,0 +1,110 @@
+"""Fetch unaddressed Cursor Bugbot inline comments for the latest Bugbot review on a commit.
+
+Uses ``fetch_bugbot_reviews`` to find the newest submitted Bugbot review whose ``commit_id`` matches the caller
+``current_head``, then returns only ``cursor[bot]`` inline comments whose ``pull_request_review_id`` matches that
+review. This avoids misclassifying a PR when Bugbot posts more than one review on the same SHA: older inline threads
+stay anchored to the earlier review id even when they share the same commit id.
+
+Wraps the gh CLI invocation required by the gh-paginate rule for the comments list:
+``gh api`` on ``repos/{owner}/{repo}/pulls/{number}/comments`` with ``--paginate --slurp`` and external JSON handling.
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+if str(Path(__file__).resolve().parent) not in sys.path:
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from evict_cached_config_modules import evict_cached_config_modules
+
+evict_cached_config_modules()
+
+from config.pr_converge_constants import (
+    CURSOR_BOT_LOGIN,
+    GH_INLINE_COMMENTS_PATH_TEMPLATE,
+)
+from fetch_bugbot_reviews import fetch_bugbot_reviews
+from review_field_helpers import body_of, login_of
+
+
+def fetch_bugbot_inline_comments(
+    *,
+    owner: str,
+    repo: str,
+    number: int,
+    current_head: str,
+) -> list[dict[str, object]]:
+    """Return cursor[bot] inline comments for the latest Bugbot review on ``current_head``.
+
+    Each entry contains comment_id, commit_id, path, line, and body.
+    """
+    all_bugbot_reviews = fetch_bugbot_reviews(owner=owner, repo=repo, number=number)
+    latest_bugbot_review_for_head = next(
+        (
+            each_review
+            for each_review in all_bugbot_reviews
+            if each_review.get("commit_id") == current_head
+        ),
+        None,
+    )
+    if latest_bugbot_review_for_head is None:
+        return []
+    target_pull_request_review_id = latest_bugbot_review_for_head["review_id"]
+    comments_endpoint = GH_INLINE_COMMENTS_PATH_TEMPLATE.format(
+        owner=owner, repo=repo, number=number
+    )
+    gh_command: list[str] = [
+        "gh",
+        "api",
+        comments_endpoint,
+        "--paginate",
+        "--slurp",
+    ]
+    completed = subprocess.run(
+        gh_command,
+        capture_output=True,
+        check=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+    pages: list[list[dict[str, object]]] = json.loads(completed.stdout)
+    all_flat_comments = [each_comment for each_page in pages for each_comment in each_page]
+    return [
+        {
+            "comment_id": each_comment["id"],
+            "commit_id": each_comment.get("commit_id"),
+            "path": each_comment.get("path"),
+            "line": each_comment.get("line"),
+            "body": body_of(each_comment),
+        }
+        for each_comment in all_flat_comments
+        if login_of(each_comment) == CURSOR_BOT_LOGIN
+        and each_comment.get("commit_id") == current_head
+        and each_comment.get("pull_request_review_id") == target_pull_request_review_id
+    ]
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--owner", required=True)
+    parser.add_argument("--repo", required=True)
+    parser.add_argument("--number", required=True, type=int)
+    parser.add_argument("--commit", required=True, dest="current_head")
+    parsed_arguments = parser.parse_args()
+    all_comments = fetch_bugbot_inline_comments(
+        owner=parsed_arguments.owner,
+        repo=parsed_arguments.repo,
+        number=parsed_arguments.number,
+        current_head=parsed_arguments.current_head,
+    )
+    json.dump(all_comments, sys.stdout)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -0,0 +1,103 @@
+"""Fetch Cursor Bugbot reviews newest-first, classified as dirty or clean.
+
+Wraps the gh CLI invocation required by the gh-paginate rule:
+`gh api '...?per_page=100' --paginate --slurp` piped through external Python
+JSON handling (instead of `gh --jq`, which runs per-page and breaks cross-page
+operations like sort/reverse — see GitHub CLI #10459).
+"""
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+if str(Path(__file__).resolve().parent) not in sys.path:
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from evict_cached_config_modules import evict_cached_config_modules
+
+evict_cached_config_modules()
+
+from config.pr_converge_constants import (
+    BUGBOT_DIRTY_BODY_REGEX,
+    CURSOR_BOT_LOGIN,
+    GH_REVIEWS_PATH_TEMPLATE,
+)
+from review_field_helpers import body_of, login_of, submitted_at_of
+
+
+def fetch_bugbot_reviews(
+    *,
+    owner: str,
+    repo: str,
+    number: int,
+) -> list[dict[str, object]]:
+    """Return Cursor Bugbot reviews newest-first, each with a clean/dirty classification.
+
+    Each entry contains review_id, commit_id, submitted_at, body, and classification.
+    """
+    reviews_endpoint = GH_REVIEWS_PATH_TEMPLATE.format(
+        owner=owner, repo=repo, number=number
+    )
+    gh_command: list[str] = [
+        "gh",
+        "api",
+        reviews_endpoint,
+        "--paginate",
+        "--slurp",
+    ]
+    completed = subprocess.run(
+        gh_command,
+        capture_output=True,
+        check=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+    pages: list[list[dict[str, object]]] = json.loads(completed.stdout)
+    all_flat_reviews = [each_review for each_page in pages for each_review in each_page]
+    all_bugbot_reviews = [
+        each_review
+        for each_review in all_flat_reviews
+        if login_of(each_review) == CURSOR_BOT_LOGIN
+        and each_review.get("submitted_at") is not None
+        and each_review.get("id") is not None
+    ]
+    all_bugbot_reviews.sort(
+        key=lambda each_review: submitted_at_of(each_review), reverse=True
+    )
+    dirty_pattern = re.compile(BUGBOT_DIRTY_BODY_REGEX)
+    return [
+        {
+            "review_id": each_review["id"],
+            "commit_id": each_review.get("commit_id"),
+            "submitted_at": each_review["submitted_at"],
+            "body": body_of(each_review),
+            "classification": (
+                "dirty"
+                if dirty_pattern.search(body_of(each_review))
+                else "clean"
+            ),
+        }
+        for each_review in all_bugbot_reviews
+    ]
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--owner", required=True)
+    parser.add_argument("--repo", required=True)
+    parser.add_argument("--number", required=True, type=int)
+    parsed_arguments = parser.parse_args()
+    all_reviews = fetch_bugbot_reviews(
+        owner=parsed_arguments.owner, repo=parsed_arguments.repo, number=parsed_arguments.number
+    )
+    json.dump(all_reviews, sys.stdout)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -0,0 +1,112 @@
+"""Fetch unaddressed Copilot inline comments for the latest Copilot review on a commit.
+
+Uses ``fetch_copilot_reviews`` to find the newest submitted Copilot review whose ``commit_id`` matches the caller
+``current_head``, then returns only ``copilot-pull-request-reviewer[bot]`` inline comments whose
+``pull_request_review_id`` matches that review. This avoids misclassifying a PR when Copilot posts more than one review
+on the same SHA: older inline threads stay anchored to the earlier review id even when they share the same commit id.
+
+Wraps the gh CLI invocation required by the gh-paginate rule for the comments list:
+``gh api`` on ``repos/{owner}/{repo}/pulls/{number}/comments`` with ``--paginate --slurp`` and external JSON handling.
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+if str(Path(__file__).resolve().parent) not in sys.path:
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from evict_cached_config_modules import evict_cached_config_modules
+
+evict_cached_config_modules()
+
+from config.pr_converge_constants import (
+    COPILOT_REVIEWER_LOGIN,
+    GH_INLINE_COMMENTS_PATH_TEMPLATE,
+)
+from fetch_copilot_reviews import fetch_copilot_reviews
+from review_field_helpers import body_of, login_of
+
+
+def fetch_copilot_inline_comments(
+    *,
+    owner: str,
+    repo: str,
+    number: int,
+    current_head: str,
+) -> list[dict[str, object]]:
+    """Return Copilot inline comments for the latest Copilot review on ``current_head``.
+
+    Each entry contains comment_id, commit_id, path, line, and body.
+    """
+    all_copilot_reviews = fetch_copilot_reviews(owner=owner, repo=repo, number=number)
+    latest_copilot_review_for_head = next(
+        (
+            each_review
+            for each_review in all_copilot_reviews
+            if each_review.get("commit_id") == current_head
+        ),
+        None,
+    )
+    if latest_copilot_review_for_head is None:
+        return []
+    target_pull_request_review_id = latest_copilot_review_for_head["review_id"]
+    comments_endpoint = GH_INLINE_COMMENTS_PATH_TEMPLATE.format(
+        owner=owner, repo=repo, number=number
+    )
+    gh_command: list[str] = [
+        "gh",
+        "api",
+        comments_endpoint,
+        "--paginate",
+        "--slurp",
+    ]
+    completed = subprocess.run(
+        gh_command,
+        capture_output=True,
+        check=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+    pages: list[list[dict[str, object]]] = json.loads(completed.stdout)
+    all_flat_comments = [
+        each_comment for each_page in pages for each_comment in each_page
+    ]
+    return [
+        {
+            "comment_id": each_comment["id"],
+            "commit_id": each_comment.get("commit_id"),
+            "path": each_comment.get("path"),
+            "line": each_comment.get("line"),
+            "body": body_of(each_comment),
+        }
+        for each_comment in all_flat_comments
+        if login_of(each_comment) == COPILOT_REVIEWER_LOGIN
+        and each_comment.get("commit_id") == current_head
+        and each_comment.get("pull_request_review_id") == target_pull_request_review_id
+    ]
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--owner", required=True)
+    parser.add_argument("--repo", required=True)
+    parser.add_argument("--number", required=True, type=int)
+    parser.add_argument("--commit", required=True, dest="current_head")
+    parsed_arguments = parser.parse_args()
+    all_comments = fetch_copilot_inline_comments(
+        owner=parsed_arguments.owner,
+        repo=parsed_arguments.repo,
+        number=parsed_arguments.number,
+        current_head=parsed_arguments.current_head,
+    )
+    json.dump(all_comments, sys.stdout)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -0,0 +1,121 @@
+"""Fetch GitHub Copilot reviewer reviews newest-first, classified as dirty or clean.
+
+Wraps the gh CLI invocation required by the gh-paginate rule:
+``gh api '...?per_page=100' --paginate --slurp`` piped through external Python
+JSON handling (instead of ``gh --jq``, which runs per-page and breaks cross-page
+operations like sort/reverse - see GitHub CLI #10459).
+
+Classification follows the review's ``state`` field:
+- ``APPROVED``                 -> ``"clean"``
+- ``CHANGES_REQUESTED``        -> ``"dirty"``
+- ``COMMENTED`` with non-empty body -> ``"dirty"`` (Copilot uses COMMENTED + body
+  to flag findings without a hard block)
+- everything else              -> ``"clean"`` (no actionable findings on PR)
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+if str(Path(__file__).resolve().parent) not in sys.path:
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from evict_cached_config_modules import evict_cached_config_modules
+
+evict_cached_config_modules()
+
+from config.pr_converge_constants import (
+    ALL_COPILOT_DIRTY_REVIEW_STATES,
+    COPILOT_CLEAN_REVIEW_STATE,
+    COPILOT_REVIEWER_LOGIN,
+    COPILOT_SOFT_DIRTY_REVIEW_STATE,
+    GH_REVIEWS_PATH_TEMPLATE,
+)
+from review_field_helpers import body_of, login_of, state_of, submitted_at_of
+
+
+def fetch_copilot_reviews(
+    *,
+    owner: str,
+    repo: str,
+    number: int,
+) -> list[dict[str, object]]:
+    """Return Copilot reviews newest-first, each with a clean/dirty classification.
+
+    Each entry contains review_id, commit_id, submitted_at, state, body, and classification.
+    """
+    reviews_endpoint = GH_REVIEWS_PATH_TEMPLATE.format(
+        owner=owner, repo=repo, number=number
+    )
+    gh_command: list[str] = [
+        "gh",
+        "api",
+        reviews_endpoint,
+        "--paginate",
+        "--slurp",
+    ]
+    completed = subprocess.run(
+        gh_command,
+        capture_output=True,
+        check=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+    pages: list[list[dict[str, object]]] = json.loads(completed.stdout)
+    all_flat_reviews = [each_review for each_page in pages for each_review in each_page]
+    all_copilot_reviews = [
+        each_review
+        for each_review in all_flat_reviews
+        if login_of(each_review) == COPILOT_REVIEWER_LOGIN
+        and each_review.get("submitted_at") is not None
+        and each_review.get("id") is not None
+    ]
+    all_copilot_reviews.sort(
+        key=lambda each_review: submitted_at_of(each_review), reverse=True
+    )
+    return [
+        {
+            "review_id": each_review["id"],
+            "commit_id": each_review.get("commit_id"),
+            "submitted_at": each_review["submitted_at"],
+            "state": state_of(each_review),
+            "body": body_of(each_review),
+            "classification": _classify_review(each_review),
+        }
+        for each_review in all_copilot_reviews
+    ]
+
+
+def _classify_review(field_by_key: dict[str, object]) -> str:
+    review_state = state_of(field_by_key)
+    if review_state == COPILOT_CLEAN_REVIEW_STATE:
+        return "clean"
+    if review_state not in ALL_COPILOT_DIRTY_REVIEW_STATES:
+        return "clean"
+    state_requires_body = review_state == COPILOT_SOFT_DIRTY_REVIEW_STATE
+    if state_requires_body and not body_of(field_by_key):
+        return "clean"
+    return "dirty"
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--owner", required=True)
+    parser.add_argument("--repo", required=True)
+    parser.add_argument("--number", required=True, type=int)
+    parsed_arguments = parser.parse_args()
+    all_reviews = fetch_copilot_reviews(
+        owner=parsed_arguments.owner,
+        repo=parsed_arguments.repo,
+        number=parsed_arguments.number,
+    )
+    json.dump(all_reviews, sys.stdout)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -0,0 +1,54 @@
+"""Mark a draft PR as ready for review.
+
+Convergence action invoked by pr-converge when both bugbot and bugteam are
+clean against the same HEAD.
+"""
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+if str(Path(__file__).resolve().parent) not in sys.path:
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from evict_cached_config_modules import evict_cached_config_modules
+
+evict_cached_config_modules()
+
+from config.pr_converge_constants import GH_REPO_ARG_TEMPLATE
+
+
+def mark_pr_ready(*, owner: str, repo: str, number: int) -> None:
+    """Run `gh pr ready <number> --repo <owner>/<repo>`."""
+    repo_arg = GH_REPO_ARG_TEMPLATE.format(owner=owner, repo=repo)
+    gh_command: list[str] = [
+        "gh",
+        "pr",
+        "ready",
+        str(number),
+        "--repo",
+        repo_arg,
+    ]
+    subprocess.run(
+        gh_command,
+        capture_output=True,
+        check=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--owner", required=True)
+    parser.add_argument("--repo", required=True)
+    parser.add_argument("--number", required=True, type=int)
+    parsed_arguments = parser.parse_args()
+    mark_pr_ready(owner=parsed_arguments.owner, repo=parsed_arguments.repo, number=parsed_arguments.number)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())