claude-dev-env 1.35.0 → 1.36.0

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

@@ -0,0 +1,136 @@
+"""Open a follow-up draft PR addressing Copilot findings from the parent PR.
+
+Subprocess sequence:
+
+1. ``gh pr view <parent_number> --json baseRefName`` to resolve the parent's base ref.
+2. ``git fetch origin <head_sha>`` to make the SHA available locally.
+3. ``git switch -c <new_branch> <head_sha>`` to create the follow-up branch off ``head_sha``.
+4. ``git push -u origin <new_branch>`` to publish it.
+5. ``gh pr create --draft --base <base_ref> --head <new_branch> --title <...> --body-file <findings_file>``
+   per the gh-body-file rule.
+
+Returns the trimmed PR URL emitted by ``gh pr create`` on stdout.
+"""
+
+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_FOLLOWUP_BRANCH_TEMPLATE,
+    COPILOT_FOLLOWUP_PR_TITLE_TEMPLATE,
+    COPILOT_FOLLOWUP_SHORT_SHA_LENGTH,
+    GH_REPO_ARG_TEMPLATE,
+    PR_BASE_REF_FIELDS,
+)
+
+
+def open_followup_copilot_pr(
+    *,
+    owner: str,
+    repo: str,
+    parent_number: int,
+    head: str,
+    findings_file: Path,
+) -> str:
+    """Create the follow-up branch + draft PR; return the new PR URL."""
+    repo_arg = GH_REPO_ARG_TEMPLATE.format(owner=owner, repo=repo)
+    parent_base_ref = _resolve_parent_base_ref(
+        parent_number=parent_number, repo_arg=repo_arg
+    )
+    short_sha = head[:COPILOT_FOLLOWUP_SHORT_SHA_LENGTH]
+    new_branch_name = COPILOT_FOLLOWUP_BRANCH_TEMPLATE.format(
+        parent_number=parent_number, short_sha=short_sha
+    )
+    _run_checked(["git", "fetch", "origin", head])
+    _run_checked(["git", "switch", "-c", new_branch_name, head])
+    _run_checked(["git", "push", "-u", "origin", new_branch_name])
+    pr_title = COPILOT_FOLLOWUP_PR_TITLE_TEMPLATE.format(parent_number=parent_number)
+    completed = _run_checked(
+        [
+            "gh",
+            "pr",
+            "create",
+            "--repo",
+            repo_arg,
+            "--draft",
+            "--base",
+            parent_base_ref,
+            "--head",
+            new_branch_name,
+            "--title",
+            pr_title,
+            "--body-file",
+            str(findings_file),
+        ]
+    )
+    return completed.stdout.strip()
+
+
+def _resolve_parent_base_ref(*, parent_number: int, repo_arg: str) -> str:
+    completed = _run_checked(
+        [
+            "gh",
+            "pr",
+            "view",
+            str(parent_number),
+            "--repo",
+            repo_arg,
+            "--json",
+            PR_BASE_REF_FIELDS,
+        ]
+    )
+    parent_pr_metadata = json.loads(completed.stdout)
+    base_ref_name_field = parent_pr_metadata.get("baseRefName")
+    if not isinstance(base_ref_name_field, str):
+        raise TypeError(
+            f"gh pr view baseRefName field is not str: {type(base_ref_name_field).__name__}"
+        )
+    return base_ref_name_field
+
+
+def _run_checked(all_command_arguments: list[str]) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        all_command_arguments,
+        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(
+        "--parent-number", required=True, type=int, dest="parent_number"
+    )
+    parser.add_argument("--head", required=True)
+    parser.add_argument(
+        "--findings-file", required=True, type=Path, dest="findings_file"
+    )
+    parsed_arguments = parser.parse_args()
+    new_pr_url = open_followup_copilot_pr(
+        owner=parsed_arguments.owner,
+        repo=parsed_arguments.repo,
+        parent_number=parsed_arguments.parent_number,
+        head=parsed_arguments.head,
+        findings_file=parsed_arguments.findings_file,
+    )
+    sys.stdout.write(f"{new_pr_url}\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,33 @@
+[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

@@ -0,0 +1,84 @@
+"""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

@@ -0,0 +1,71 @@
+"""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

@@ -0,0 +1,58 @@
+"""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

@@ -0,0 +1,43 @@
+"""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/test_check_pr_mergeability.py

@@ -0,0 +1,126 @@
+"""Tests for check_pr_mergeability.
+
+Covers:
+- gh pr view is invoked with the documented mergeability --json field list
+- the parsed JSON object is returned with mergeable/mergeStateStatus/headRefOid keys
+- subprocess errors propagate
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import subprocess
+from pathlib import Path
+from types import ModuleType
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+def _load_module() -> ModuleType:
+    module_path = Path(__file__).parent / "check_pr_mergeability.py"
+    spec = importlib.util.spec_from_file_location("check_pr_mergeability", 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
+
+
+check_pr_mergeability_module = _load_module()
+
+
+def _completed(stdout: str) -> subprocess.CompletedProcess:
+    process = MagicMock(spec=subprocess.CompletedProcess)
+    process.stdout = stdout
+    process.returncode = 0
+    return process
+
+
+def test_should_invoke_gh_pr_view_with_mergeability_field_list() -> None:
+    payload = json.dumps(
+        {
+            "mergeable": "MERGEABLE",
+            "mergeStateStatus": "CLEAN",
+            "headRefOid": "abc123",
+        }
+    )
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(payload)
+        check_pr_mergeability_module.check_pr_mergeability(
+            owner="acme", repo="widget", number=42
+        )
+    invoked_argv = mock_run.call_args[0][0]
+    assert invoked_argv[0:3] == ["gh", "pr", "view"]
+    assert "--json" in invoked_argv
+    fields_arg = invoked_argv[invoked_argv.index("--json") + 1]
+    for required_field in ("mergeable", "mergeStateStatus", "headRefOid"):
+        assert required_field in fields_arg
+
+
+def test_should_pass_pr_number_and_repo_arg_for_explicit_targeting() -> None:
+    payload = json.dumps(
+        {
+            "mergeable": "MERGEABLE",
+            "mergeStateStatus": "CLEAN",
+            "headRefOid": "abc123",
+        }
+    )
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(payload)
+        check_pr_mergeability_module.check_pr_mergeability(
+            owner="acme", repo="widget", number=42
+        )
+    invoked_argv = mock_run.call_args[0][0]
+    assert invoked_argv[3] == "42"
+    assert "--repo" in invoked_argv
+    repo_arg_value = invoked_argv[invoked_argv.index("--repo") + 1]
+    assert repo_arg_value == "acme/widget"
+
+
+def test_should_return_parsed_json_object_with_mergeability_keys() -> None:
+    payload = {
+        "mergeable": "CONFLICTING",
+        "mergeStateStatus": "DIRTY",
+        "headRefOid": "deadbeef",
+    }
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(json.dumps(payload))
+        mergeability_state = check_pr_mergeability_module.check_pr_mergeability(
+            owner="acme", repo="widget", number=42
+        )
+    assert mergeability_state == payload
+    assert mergeability_state["mergeable"] == "CONFLICTING"
+    assert mergeability_state["mergeStateStatus"] == "DIRTY"
+    assert mergeability_state["headRefOid"] == "deadbeef"
+
+
+def test_should_raise_when_gh_subprocess_fails() -> None:
+    failure = subprocess.CalledProcessError(
+        returncode=1, cmd=["gh"], stderr="auth failure"
+    )
+    with patch("subprocess.run", side_effect=failure):
+        with pytest.raises(subprocess.CalledProcessError):
+            check_pr_mergeability_module.check_pr_mergeability(
+                owner="acme", repo="widget", number=42
+            )
+
+
+def test_should_pass_imported_constant_directly_without_local_alias() -> None:
+    payload = json.dumps(
+        {
+            "mergeable": "MERGEABLE",
+            "mergeStateStatus": "CLEAN",
+            "headRefOid": "abc",
+        }
+    )
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = _completed(payload)
+        check_pr_mergeability_module.check_pr_mergeability(
+            owner="acme", repo="widget", number=42
+        )
+    invoked_argv = mock_run.call_args[0][0]
+    fields_arg = invoked_argv[invoked_argv.index("--json") + 1]
+    expected_fields = check_pr_mergeability_module.MERGEABILITY_FIELDS
+    assert fields_arg is expected_fields

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

@@ -0,0 +1,22 @@
+"""Tests for evict_cached_config_modules."""
+
+from __future__ import annotations
+
+import sys
+import types
+from pathlib import Path
+
+_scripts_directory = Path(__file__).resolve().parent
+if str(_scripts_directory) not in sys.path:
+    sys.path.insert(0, str(_scripts_directory))
+
+from evict_cached_config_modules import evict_cached_config_modules
+
+
+def test_should_remove_root_config_and_submodules() -> None:
+    fake = types.ModuleType("config")
+    sys.modules["config"] = fake
+    sys.modules["config.stale_submodule"] = types.ModuleType("config.stale_submodule")
+    evict_cached_config_modules()
+    assert "config" not in sys.modules
+    assert "config.stale_submodule" not in sys.modules