claude-dev-env 1.37.1 → 1.38.0

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

@@ -1,54 +0,0 @@
-"""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())

package/skills/pr-converge/scripts/post-bugbot-run.helpers.ps1

@@ -1,49 +0,0 @@
-function Resolve-InvocationMode {
-    param([string] $PullRequestInput, [string] $RepositoryInput, [int] $NumberInput)
-
-    if ($NumberInput -gt 0) {
-        if ([string]::IsNullOrWhiteSpace($RepositoryInput)) {
-            throw 'When -Number is set, -Repository must be owner/repo (for example jl-cmd/claude-code-config).'
-        }
-        return @{ Mode = 'RepoNumber'; Repository = $RepositoryInput; Number = $NumberInput }
-    }
-
-    $trimmed = $PullRequestInput.Trim()
-    if (-not [string]::IsNullOrWhiteSpace($trimmed)) {
-        return @{ Mode = 'Uri'; PullRequest = $trimmed }
-    }
-
-    throw 'Provide a pull request URL, owner/repo#number as the first argument, or -Repository with -Number.'
-}
-
-function Build-GhArgumentList {
-    param([hashtable] $Invocation, [string] $BodyFilePath)
-
-    if ($Invocation.Mode -eq 'RepoNumber') {
-        return @(
-            'pr', 'comment',
-            $Invocation.Number.ToString(),
-            '-R', $Invocation.Repository,
-            '--body-file', $BodyFilePath
-        )
-    }
-
-    $trimmed = $Invocation.PullRequest
-    if ($trimmed -match '^https://github\.com/[^/]+/[^/]+/pull/\d+$') {
-        return @('pr', 'comment', $trimmed, '--body-file', $BodyFilePath)
-    }
-
-    if ($trimmed -match '^([^/]+)/([^/#]+)#(\d+)$') {
-        $owner = $Matches[1]
-        $repository_name = $Matches[2]
-        $pull_number = $Matches[3]
-        return @(
-            'pr', 'comment',
-            $pull_number,
-            '-R', ('{0}/{1}' -f $owner, $repository_name),
-            '--body-file', $BodyFilePath
-        )
-    }
-
-    throw ('Unrecognized PullRequest "{0}". Use a https://github.com/owner/repo/pull/NN URL or owner/repo#NN.' -f $trimmed)
-}

package/skills/pr-converge/scripts/post-bugbot-run.ps1

@@ -1,33 +0,0 @@
-[CmdletBinding()]
-param(
-    [Parameter(Position = 0, HelpMessage = 'GitHub pull request URL or owner/repo#number.')]
-    [string] $PullRequest = '',
-    [Parameter(HelpMessage = 'owner/repo when using -Number instead of a URL or owner/repo#number.')]
-    [string] $Repository = '',
-    [Parameter(HelpMessage = 'Pull request number; requires -Repository.')]
-    [int] $Number = 0
-)
-
-$helpers_path = Join-Path $PSScriptRoot 'post-bugbot-run.helpers.ps1'
-. $helpers_path
-
-$LiteralBugbotRunBody = "bugbot run`n"
-
-$invocation = Resolve-InvocationMode -PullRequestInput $PullRequest -RepositoryInput $Repository -NumberInput $Number
-$scratch_temp_path = [System.IO.Path]::GetTempFileName()
-$body_file_path = [System.IO.Path]::ChangeExtension($scratch_temp_path, '.md')
-
-try {
-    $utf8_without_byte_order_mark = New-Object System.Text.UTF8Encoding $false
-    [System.IO.File]::WriteAllText($body_file_path, $LiteralBugbotRunBody, $utf8_without_byte_order_mark)
-
-    $null = Get-Command gh -ErrorAction Stop
-    $argument_list = Build-GhArgumentList -Invocation $invocation -BodyFilePath $body_file_path
-    & gh @argument_list
-    if ($LASTEXITCODE -ne 0) {
-        throw ('gh exited with code {0}.' -f $LASTEXITCODE)
-    }
-} finally {
-    Remove-Item -LiteralPath $body_file_path -Force -ErrorAction SilentlyContinue
-    Remove-Item -LiteralPath $scratch_temp_path -Force -ErrorAction SilentlyContinue
-}

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

@@ -1,84 +0,0 @@
-"""Post an inline reply to a PR review comment.
-
-Reply body is sourced from a file via `gh api ... -F body=@<path>` (per the
-gh-body-file rule — passing a string body to gh can corrupt backticks).
-"""
-
-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 (
-    GH_FIELD_BODY_AT_PREFIX,
-    GH_INLINE_COMMENT_REPLY_PATH_TEMPLATE,
-)
-
-
-def reply_to_inline_comment(
-    *,
-    owner: str,
-    repo: str,
-    number: int,
-    comment_id: int,
-    body_file: Path,
-) -> int:
-    """POST an inline reply to a PR review comment, return gh's reply id."""
-    replies_endpoint = GH_INLINE_COMMENT_REPLY_PATH_TEMPLATE.format(
-        owner=owner, repo=repo, number=number, comment_id=comment_id
-    )
-    gh_command: list[str] = [
-        "gh",
-        "api",
-        "-X",
-        "POST",
-        replies_endpoint,
-        "-F",
-        f"{GH_FIELD_BODY_AT_PREFIX}{body_file}",
-    ]
-    completed = subprocess.run(
-        gh_command,
-        capture_output=True,
-        check=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-    )
-    response_payload: dict[str, object] = json.loads(completed.stdout)
-    raw_reply_id = response_payload["id"]
-    if not isinstance(raw_reply_id, (int, str)):
-        raise TypeError(
-            f"gh response id field is not int|str: {type(raw_reply_id).__name__}"
-        )
-    return int(raw_reply_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("--comment-id", required=True, type=int, dest="comment_id")
-    parser.add_argument("--body-file", required=True, type=Path, dest="body_file")
-    parsed_arguments = parser.parse_args()
-    reply_id = reply_to_inline_comment(
-        owner=parsed_arguments.owner,
-        repo=parsed_arguments.repo,
-        number=parsed_arguments.number,
-        comment_id=parsed_arguments.comment_id,
-        body_file=parsed_arguments.body_file,
-    )
-    sys.stdout.write(f"{reply_id}\n")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

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

@@ -1,71 +0,0 @@
-"""Request a Copilot review on the current PR via the requested_reviewers API.
-
-The reviewer ID literal is ``copilot-pull-request-reviewer[bot]`` - the
-``[bot]`` suffix is load-bearing per ``skills/copilot-review/SKILL.md``;
-``Copilot``, ``copilot``, and ``github-copilot`` all silently no-op on this
-endpoint. After this POST returns, GitHub schedules Copilot to render a review
-on the current HEAD; the caller polls ``fetch_copilot_reviews.py`` to converge.
-"""
-
-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 (
-    COPILOT_REVIEWER_REQUEST_ID,
-    GH_REQUESTED_REVIEWERS_FIELD_TEMPLATE,
-    GH_REQUESTED_REVIEWERS_PATH_TEMPLATE,
-)
-
-
-def request_copilot_review(*, owner: str, repo: str, number: int) -> None:
-    """POST a Copilot review request to the PR's requested_reviewers endpoint."""
-    requested_reviewers_endpoint = GH_REQUESTED_REVIEWERS_PATH_TEMPLATE.format(
-        owner=owner, repo=repo, number=number
-    )
-    reviewer_field_value = GH_REQUESTED_REVIEWERS_FIELD_TEMPLATE.format(
-        reviewer_id=COPILOT_REVIEWER_REQUEST_ID
-    )
-    gh_command: list[str] = [
-        "gh",
-        "api",
-        "-X",
-        "POST",
-        requested_reviewers_endpoint,
-        "-f",
-        reviewer_field_value,
-    ]
-    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()
-    request_copilot_review(
-        owner=parsed_arguments.owner,
-        repo=parsed_arguments.repo,
-        number=parsed_arguments.number,
-    )
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

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

@@ -1,58 +0,0 @@
-"""Resolve the current HEAD SHA of a pull request.
-
-Calls the single-object PR endpoint (`repos/{owner}/{repo}/pulls/{number}`) which
-is NOT paginated, so `--paginate` / `--slurp` are unnecessary and `gh`'s
-built-in `--jq` is safe to use here.
-"""
-
-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_PR_OBJECT_PATH_TEMPLATE
-
-
-def resolve_pr_head(*, owner: str, repo: str, number: int) -> str:
-    """Return the head_sha for the given PR."""
-    pr_endpoint = GH_PR_OBJECT_PATH_TEMPLATE.format(
-        owner=owner, repo=repo, number=number
-    )
-    gh_command: list[str] = [
-        "gh",
-        "api",
-        pr_endpoint,
-        "--jq",
-        ".head.sha",
-    ]
-    completed = subprocess.run(
-        gh_command,
-        capture_output=True,
-        check=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-    )
-    return completed.stdout.strip()
-
-
-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()
-    head_sha = resolve_pr_head(owner=parsed_arguments.owner, repo=parsed_arguments.repo, number=parsed_arguments.number)
-    sys.stdout.write(f"{head_sha}\n")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

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

@@ -1,43 +0,0 @@
-"""Shared field-extraction helpers for GitHub PR review and inline-comment payloads.
-
-The four ``fetch_*_reviews.py`` and ``fetch_*_inline_comments.py`` scripts in
-this directory each parse the same JSON shapes and need the same defensive
-field-coercion logic for ``user.login``, ``body``, ``submitted_at``, and
-``state``. Centralizing the helpers here keeps a single source of truth and
-prevents the bug-fix-in-one-copy-only failure mode flagged on PR #337.
-"""
-
-
-def login_of(field_by_key: dict[str, object]) -> str | None:
-    """Return the ``user.login`` string from a review/comment payload, or ``None``."""
-    user_field = field_by_key.get("user")
-    if not isinstance(user_field, dict):
-        return None
-    login_field = user_field.get("login")
-    if not isinstance(login_field, str):
-        return None
-    return login_field
-
-
-def body_of(field_by_key: dict[str, object]) -> str:
-    """Return the ``body`` string from a review/comment payload, or ``""`` when missing."""
-    body_field = field_by_key.get("body")
-    if not isinstance(body_field, str):
-        return ""
-    return body_field
-
-
-def submitted_at_of(field_by_key: dict[str, object]) -> str:
-    """Return the ``submitted_at`` string from a review payload, or ``""`` when missing."""
-    submitted_at_field = field_by_key.get("submitted_at")
-    if not isinstance(submitted_at_field, str):
-        return ""
-    return submitted_at_field
-
-
-def state_of(field_by_key: dict[str, object]) -> str:
-    """Return the ``state`` string from a review payload, or ``""`` when missing."""
-    state_field = field_by_key.get("state")
-    if not isinstance(state_field, str):
-        return ""
-    return state_field

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

@@ -1,153 +0,0 @@
-"""Shared fetch primitives for PR reviewer bots (Bugbot, Copilot, Claude).
-
-The reviewer-specific scripts (``fetch_bugbot_reviews.py``,
-``fetch_copilot_reviews.py``, ``fetch_claude_reviews.py`` and their
-inline-comment counterparts) are thin entry points that pass a ``ReviewerSpec``
-to these functions. The spec carries the substring used to recognise the
-reviewer's GitHub login (case-insensitive substring match - required because
-some bots emit different login strings at the review-level vs inline-comment
-endpoints) and the per-reviewer classify callable.
-
-Wraps the gh CLI invocations 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 issue 10459).
-"""
-
-from __future__ import annotations
-
-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 (
-    GH_INLINE_COMMENTS_PATH_TEMPLATE,
-    GH_REVIEWS_PATH_TEMPLATE,
-)
-from review_field_helpers import body_of, login_of, state_of, submitted_at_of
-from reviewer_specs import ReviewerSpec
-
-
-def _login_matches_substring(
-    field_by_key: dict[str, object], login_filter_substring: str
-) -> bool:
-    author_login = login_of(field_by_key) or ""
-    return login_filter_substring.lower() in author_login.lower()
-
-
-def _run_gh_paginated(*, endpoint_path: str) -> list[dict[str, object]]:
-    gh_command: list[str] = [
-        "gh",
-        "api",
-        endpoint_path,
-        "--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)
-    return [each_entry for each_page in pages for each_entry in each_page]
-
-
-def fetch_reviewer_reviews(
-    spec: ReviewerSpec,
-    *,
-    owner: str,
-    repo: str,
-    number: int,
-) -> list[dict[str, object]]:
-    """Return reviews from the matching reviewer newest-first, with classification.
-
-    Each entry contains ``review_id``, ``commit_id``, ``submitted_at``,
-    ``state``, ``body``, and ``classification`` (``"clean"`` or ``"dirty"``).
-    Entries whose payload is missing ``submitted_at`` or ``id`` are dropped.
-    """
-    reviews_endpoint = GH_REVIEWS_PATH_TEMPLATE.format(
-        owner=owner, repo=repo, number=number
-    )
-    all_flat_reviews = _run_gh_paginated(endpoint_path=reviews_endpoint)
-    all_matching_reviews = [
-        each_review
-        for each_review in all_flat_reviews
-        if _login_matches_substring(each_review, spec.login_filter_substring)
-        and each_review.get("submitted_at") is not None
-        and each_review.get("id") is not None
-    ]
-    all_matching_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": spec.classify_review(each_review),
-        }
-        for each_review in all_matching_reviews
-    ]
-
-
-def fetch_reviewer_inline_comments(
-    spec: ReviewerSpec,
-    *,
-    owner: str,
-    repo: str,
-    number: int,
-    current_head: str,
-    all_reviews: list[dict[str, object]],
-) -> list[dict[str, object]]:
-    """Return inline comments anchored to the latest matching review on ``current_head``.
-
-    The ``all_reviews`` list is supplied by the caller (not fetched internally)
-    so the entry-point scripts retain a patchable seam: tests that patch
-    ``fetch_X_reviews`` on the entry-point module continue to work because the
-    entry-point is what calls the reviews fetch.
-
-    Each entry contains ``comment_id``, ``commit_id``, ``path``, ``line``, and
-    ``body``. Returns an empty list when no review in ``all_reviews`` is
-    anchored to ``current_head``.
-    """
-    latest_review_for_head = next(
-        (
-            each_review
-            for each_review in all_reviews
-            if each_review.get("commit_id") == current_head
-        ),
-        None,
-    )
-    if latest_review_for_head is None:
-        return []
-    target_pull_request_review_id = latest_review_for_head["review_id"]
-    comments_endpoint = GH_INLINE_COMMENTS_PATH_TEMPLATE.format(
-        owner=owner, repo=repo, number=number
-    )
-    all_flat_comments = _run_gh_paginated(endpoint_path=comments_endpoint)
-    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_matches_substring(each_comment, spec.login_filter_substring)
-        and each_comment.get("commit_id") == current_head
-        and each_comment.get("pull_request_review_id") == target_pull_request_review_id
-    ]

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

@@ -1,98 +0,0 @@
-"""Reviewer specifications shared by the per-reviewer fetch entry-point scripts.
-
-A ReviewerSpec carries the two knobs that vary across the bugbot, copilot, and
-claude reviewers: the case-insensitive substring used to match the reviewer's
-GitHub login, and the callable that classifies a single review payload as
-``"clean"`` or ``"dirty"``. The spec instances declared at module scope are
-imported by the thin entry-point wrappers (``fetch_bugbot_reviews.py`` etc.)
-and by ``reviewer_fetch_core``.
-"""
-
-from __future__ import annotations
-
-import re
-import sys
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Callable
-
-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_CLAUDE_DIRTY_REVIEW_STATES,
-    ALL_COPILOT_DIRTY_REVIEW_STATES,
-    BUGBOT_DIRTY_BODY_REGEX,
-    CLAUDE_CLEAN_REVIEW_STATE,
-    CLAUDE_LOGIN_FILTER_SUBSTRING,
-    CLAUDE_SOFT_DIRTY_REVIEW_STATE,
-    COPILOT_CLEAN_REVIEW_STATE,
-    COPILOT_LOGIN_FILTER_SUBSTRING,
-    COPILOT_SOFT_DIRTY_REVIEW_STATE,
-    CURSOR_LOGIN_FILTER_SUBSTRING,
-)
-from review_field_helpers import body_of, state_of
-
-
-@dataclass(frozen=True)
-class ReviewerSpec:
-    """Per-reviewer configuration: login substring filter plus classify callable."""
-
-    login_filter_substring: str
-    classify_review: Callable[[dict[str, object]], str]
-
-
-def _classify_bugbot_review(field_by_key: dict[str, object]) -> str:
-    review_body = body_of(field_by_key)
-    if re.search(BUGBOT_DIRTY_BODY_REGEX, review_body):
-        return "dirty"
-    return "clean"
-
-
-def _make_state_based_classifier(
-    *,
-    clean_state: str,
-    all_dirty_states: tuple[str, ...],
-    soft_dirty_state: str,
-) -> Callable[[dict[str, object]], str]:
-    def classify_review(field_by_key: dict[str, object]) -> str:
-        review_state = state_of(field_by_key)
-        if review_state == clean_state:
-            return "clean"
-        if review_state not in all_dirty_states:
-            return "clean"
-        if review_state == soft_dirty_state and not body_of(field_by_key):
-            return "clean"
-        return "dirty"
-
-    return classify_review
-
-
-bugbot_spec = ReviewerSpec(
-    login_filter_substring=CURSOR_LOGIN_FILTER_SUBSTRING,
-    classify_review=_classify_bugbot_review,
-)
-
-
-copilot_spec = ReviewerSpec(
-    login_filter_substring=COPILOT_LOGIN_FILTER_SUBSTRING,
-    classify_review=_make_state_based_classifier(
-        clean_state=COPILOT_CLEAN_REVIEW_STATE,
-        all_dirty_states=ALL_COPILOT_DIRTY_REVIEW_STATES,
-        soft_dirty_state=COPILOT_SOFT_DIRTY_REVIEW_STATE,
-    ),
-)
-
-
-claude_spec = ReviewerSpec(
-    login_filter_substring=CLAUDE_LOGIN_FILTER_SUBSTRING,
-    classify_review=_make_state_based_classifier(
-        clean_state=CLAUDE_CLEAN_REVIEW_STATE,
-        all_dirty_states=ALL_CLAUDE_DIRTY_REVIEW_STATES,
-        soft_dirty_state=CLAUDE_SOFT_DIRTY_REVIEW_STATE,
-    ),
-)