claude-dev-env 1.35.0 → 1.36.1

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/reflow_skill_md.py

@@ -0,0 +1,288 @@
+"""Reflow packages/claude-dev-env/skills/pr-converge/SKILL.md to 80 columns.
+
+Merge soft line breaks outside fenced blocks (space join; URL path fragments
+joined without a space only inside unfinished markdown link targets), then
+wrap with textwrap. Preserves fenced blocks verbatim.
+
+Run: python3 packages/claude-dev-env/skills/pr-converge/scripts/reflow_skill_md.py
+"""
+
+from __future__ import annotations
+
+import re
+import textwrap
+from pathlib import Path
+
+MAX_WIDTH = 80
+SKILL_PATH = Path(__file__).resolve().parent.parent / "SKILL.md"
+
+ORDERED_RE = re.compile(r"^(\s*)(\d+\.\s)(.*)$")
+BULLET_RE = re.compile(r"^(\s*)([-*]\s)(.*)$")
+UNFINISHED_MD_LINK_TARGET = re.compile(r"\]\([^)]*$")
+
+
+def wrap_paragraph_plain(text: str) -> list[str]:
+    collapsed = " ".join(text.split())
+    if not collapsed:
+        return []
+    return textwrap.fill(
+        collapsed,
+        width=MAX_WIDTH,
+        break_long_words=False,
+        break_on_hyphens=False,
+    ).splitlines()
+
+
+def wrap_list_item(lead_ws: str, marker: str, body: str) -> list[str]:
+    collapsed = " ".join(body.split())
+    if not collapsed:
+        return [lead_ws + marker.rstrip()]
+    prefix = lead_ws + marker
+    subsequent = lead_ws + (" " * len(marker))
+    return textwrap.fill(
+        collapsed,
+        width=MAX_WIDTH,
+        initial_indent=prefix,
+        subsequent_indent=subsequent,
+        break_long_words=False,
+        break_on_hyphens=False,
+    ).splitlines()
+
+
+def reflow_yaml_description_block(lines: list[str], body_start: int) -> tuple[list[str], int]:
+    body_parts: list[str] = []
+    index = body_start
+    while index < len(lines):
+        line = lines[index]
+        if line.strip() == "---":
+            index += 1
+            break
+        stripped = line.lstrip()
+        if stripped:
+            body_parts.append(stripped)
+        index += 1
+    merged = " ".join(body_parts)
+    merged = merged.replace(
+        "`<TMPDIR>/pr-converge-<session_id>/state.json` per",
+        "`<TMPDIR>/pr-converge-<session_id>/state.json>` per",
+    )
+    wrapped = textwrap.fill(
+        merged,
+        width=MAX_WIDTH,
+        initial_indent="  ",
+        subsequent_indent="  ",
+        break_long_words=False,
+        break_on_hyphens=False,
+    )
+    return wrapped.splitlines(), index
+
+
+def is_table_line(line: str) -> bool:
+    return line.lstrip().startswith("|")
+
+
+def is_new_logical_line(stripped: str) -> bool:
+    if not stripped:
+        return False
+    if stripped.startswith("```"):
+        return True
+    if stripped.startswith("#"):
+        return True
+    if stripped == "---":
+        return True
+    if is_table_line(stripped):
+        return True
+    if stripped.startswith("<example>") or stripped.startswith("</example>"):
+        return True
+    if ORDERED_RE.match(stripped) or BULLET_RE.match(stripped):
+        return True
+    return False
+
+
+def merge_without_space(buffer: str, continuation: str) -> bool:
+    """Join without space only for split markdown link URL paths."""
+    base = buffer.rstrip()
+    stripped = continuation.lstrip()
+    if not base or not stripped:
+        return False
+    if stripped.startswith("/") and UNFINISHED_MD_LINK_TARGET.search(base):
+        return True
+    return False
+
+
+def merge_soft_breaks(lines: list[str]) -> list[str]:
+    output: list[str] = []
+    index = 0
+    in_fence = False
+    while index < len(lines):
+        raw = lines[index]
+        line = raw.rstrip("\n")
+        if line.lstrip().startswith("```"):
+            in_fence = not in_fence
+            output.append(line)
+            index += 1
+            continue
+        if in_fence:
+            output.append(line)
+            index += 1
+            continue
+        if line.strip() == "":
+            output.append(line)
+            index += 1
+            continue
+        buffer_line = line
+        index += 1
+        while index < len(lines):
+            next_raw = lines[index].rstrip("\n")
+            if next_raw.strip() == "":
+                break
+            if next_raw.lstrip().startswith("```"):
+                break
+            stripped_next = next_raw.lstrip()
+            if is_new_logical_line(stripped_next):
+                break
+            if merge_without_space(buffer_line, stripped_next):
+                buffer_line = buffer_line.rstrip() + stripped_next
+            else:
+                buffer_line = f"{buffer_line.rstrip()} {stripped_next}"
+            index += 1
+        output.append(buffer_line)
+    return output
+
+
+def reflow_merged_line(line: str) -> list[str]:
+    stripped = line.strip()
+    if stripped == "":
+        return [""]
+    if stripped.startswith("```"):
+        return [line]
+    if stripped.startswith("#"):
+        if len(stripped) <= MAX_WIDTH:
+            return [stripped]
+        title = stripped.lstrip("#").strip()
+        level = len(stripped) - len(stripped.lstrip("#"))
+        prefix = "#" * level + " "
+        return textwrap.fill(
+            title,
+            width=MAX_WIDTH,
+            initial_indent=prefix,
+            subsequent_indent=prefix,
+            break_long_words=False,
+            break_on_hyphens=False,
+        ).splitlines()
+    if stripped == "---":
+        return ["---"]
+    if is_table_line(stripped):
+        return [stripped]
+    if stripped.startswith("</example>"):
+        return [stripped]
+    if stripped.startswith("<example>"):
+        inner = stripped[len("<example>") :].strip()
+        if not inner:
+            return ["<example>"]
+        tag = "<example> "
+        subsequent = " " * len(tag)
+        return textwrap.fill(
+            " ".join(inner.split()),
+            width=MAX_WIDTH,
+            initial_indent=tag,
+            subsequent_indent=subsequent,
+            break_long_words=False,
+            break_on_hyphens=False,
+        ).splitlines()
+
+    ordered = ORDERED_RE.match(line)
+    if ordered:
+        return wrap_list_item(ordered.group(1), ordered.group(2), ordered.group(3))
+
+    bullet = BULLET_RE.match(line)
+    if bullet:
+        return wrap_list_item(bullet.group(1), bullet.group(2), bullet.group(3))
+
+    return wrap_paragraph_plain(stripped)
+
+
+def reflow_markdown_body(lines: list[str]) -> list[str]:
+    merged = merge_soft_breaks(lines)
+    output: list[str] = []
+    for each_line in merged:
+        if each_line.strip() == "":
+            output.append("")
+            continue
+        output.extend(reflow_merged_line(each_line))
+    return output
+
+
+def wrap_long_bash_fence_lines(lines: list[str]) -> list[str]:
+    """Hard-wrap only ```bash fence bodies that still exceed MAX_WIDTH."""
+    output: list[str] = []
+    in_bash_fence = False
+    for line in lines:
+        stripped = line.lstrip()
+        if stripped.startswith("```"):
+            if not in_bash_fence:
+                lang = stripped[3:].strip().lower()
+                in_bash_fence = lang == "bash"
+            else:
+                in_bash_fence = False
+            output.append(line)
+            continue
+        if in_bash_fence and len(line) > MAX_WIDTH:
+            indent_len = len(line) - len(line.lstrip())
+            indent = line[:indent_len]
+            content = line.lstrip()
+            wrapped_segments: list[str] = []
+            rest = content
+            while len(rest) > MAX_WIDTH - len(indent):
+                room = MAX_WIDTH - len(indent) - 2
+                window = rest[:room]
+                break_at = window.rfind(" ")
+                if break_at <= 0:
+                    break_at = room
+                piece = rest[:break_at].rstrip()
+                rest = rest[break_at:].lstrip()
+                wrapped_segments.append(indent + piece + " \\")
+            if rest:
+                wrapped_segments.append(indent + ("  " if wrapped_segments else "") + rest)
+            output.extend(wrapped_segments)
+        else:
+            output.append(line)
+    return output
+
+
+def main() -> None:
+    raw = SKILL_PATH.read_text(encoding="utf-8")
+    lines = raw.splitlines()
+    if not lines or lines[0].strip() != "---":
+        raise SystemExit("expected YAML front matter starting with ---")
+
+    out: list[str] = ["---"]
+    index = 1
+    while index < len(lines):
+        line = lines[index]
+        if line.startswith("description: >-"):
+            out.append(line)
+            index += 1
+            desc_lines, index = reflow_yaml_description_block(lines, index)
+            out.extend(desc_lines)
+            out.append("---")
+            break
+        out.append(line)
+        index += 1
+
+    body = reflow_markdown_body(lines[index:])
+    body = wrap_long_bash_fence_lines(body)
+
+    text = "\n".join(out + body) + "\n"
+    SKILL_PATH.write_text(text, encoding="utf-8", newline="\n")
+
+    all_lines = text.splitlines()
+    long_rows = [(i, len(ln)) for i, ln in enumerate(all_lines, 1) if len(ln) > MAX_WIDTH]
+    print("SKILL.md reflowed; lines:", len(all_lines))
+    print("lines longer than %d: %d" % (MAX_WIDTH, len(long_rows)))
+    if long_rows[:20]:
+        print("first long:", long_rows[:20])
+
+
+if __name__ == "__main__":
+    main()

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())