Make /address-pr-comment skill use the URL of the PR context

.claude/settings/permissions/bash.jsonc

@@ -41,18 +41,8 @@
       "Bash(tar *)",
       "Bash(touch *)",
       "Bash(tree *)",
-      // Git & Version Control
-      "Bash(git add *)",
-      "Bash(git branch *)",
-      "Bash(git checkout *)",
-      "Bash(git commit *)",
-      "Bash(git diff *)",
-      "Bash(git log *)",
-      "Bash(git mv *)",
-      "Bash(git push)",
-      "Bash(git remote get-url origin)",
-      "Bash(git rev-parse *)",
-      "Bash(git status *)",
+      // Git & Version Control - anything not explicitly denied
+      "Bash(git *)",
       // Github
       "Bash(gh issue list *)",
       "Bash(gh issue view *)",

.claude/skills/address-pr-comments/SKILL.md

@@ -23,28 +23,28 @@ Read PR review comments and address them by making code changes, answering quest
 
 **Always show file paths to the user as absolute paths.** This applies to every file path that appears in a user-facing message — reply files this skill drafts, source files a comment is attached to (e.g. when announcing "Comment 2 of 4 — <path> line 33"), or any other file reference. VS Code only Ctrl+click-opens a path when it is fully qualified (e.g. `/workspaces/my-app/src/foo.py`), not when it is relative (`src/foo.py`). The `path` field returned by `fetch-pr-comments.py` is relative to the repo root — prepend the repo root before showing it.
 
-Capture the repo root once at the start of the skill (it does not change mid-session) and reuse it:
-
-```bash
-git rev-parse --show-toplevel
-```
+Capture the repo root once at the start of the skill (it does not change mid-session) and reuse it. It is the `repo_root` field of the [Step 1](#step-1-verify-environment-and-identify-the-pr) `verify-env.py` verdict.
 
 **Reply file path.** Throughout this document, `<reply_file>` refers to the absolute path: `<repo_root>/tmp/pr-reply-<comment_id>.txt`. Use this form everywhere — shell commands, Write/Read tool calls, and user-facing messages.
 
-### Step 1: Verify Environment
+### Step 1: Verify Environment and Identify the PR
 
-Check we have a GitHub remote and are on a feature branch:
+Run the gate script once. Pass `--pr <number>` if the user supplied one; otherwise it auto-detects the PR from the current branch:
 
 ```bash
-git remote -v
-git status
-git rev-parse --abbrev-ref HEAD
+.claude/skills/address-pr-comments/verify-env.py [--pr <number>]
 ```
 
+It emits a JSON verdict: `repo_root`, `has_remote`, `branch`, `on_protected_branch`, `dirty`, and `pr` (`{number, state, title}` or `null`). This is the source for both the repo root (see [Conventions](#conventions)) and the PR
+
 **STOP if:**
-- No remote exists → "This skill requires a GitHub remote. Please add one with `git remote add origin <url>` first."
-- On main/master → "Please switch to the PR's branch first. You can find it with `gh pr view <number> --json headRefName`"
-- Uncommitted changes → "Please commit or stash your changes first." *(skipped when `--resume` is passed — see [Resume Mode](#resume-mode))*
+- `has_remote` is `false` → "This skill requires a GitHub remote. Please add one with `git remote add origin <url>` first."
+- `on_protected_branch` is `true` → "Please switch to the PR's branch first. You can find it with `gh pr view <number> --json headRefName`"
+- `dirty` is `true` → "Please commit or stash your changes first." *(skipped when `--resume` is passed — see [Resume Mode](#resume-mode))*
+
+**PR resolution:**
+- `pr` is `null` → ask the user for a PR number, then re-run with `--pr <number>`.
+- `pr.state` is not `OPEN` → inform the user the PR must be open and stop.
 
 ### Resume Mode
 
@@ -90,19 +90,7 @@ Options:
 - If remote has diverged (force-push, rebase): stop, surface diff, do nothing.
 - Reply files with placeholder still present block the single-push step — they must be re-entered into Phase 2 (commit produced) before the batch push fires.
 
-### Step 2: Identify the PR
-
-User will provide a PR number (e.g., `#12` or `12`), or auto-detect from current branch:
-
-```bash
-gh pr view --json number,state,title
-```
-
-If no PR exists for the current branch, ask the user for a PR number.
-
-Validate the PR is open. If closed/merged, inform the user and stop.
-
-### Step 3: Fetch PR Comments
+### Step 2: Fetch PR Comments
 
 Run the fetch script to get all actionable comments, pre-grouped into threads:
 
@@ -124,7 +112,7 @@ For `issues/comments` type: no threading — replying posts a new top-level PR c
 
 Empty array → inform user, stop.
 
-### Step 4: Phase 1 — Collect Decisions
+### Step 3: Phase 1 — Collect Decisions
 
 Collect all decisions before executing — exception: immediate replies (see below).
 
@@ -188,9 +176,9 @@ For each comment:
 
 5. **Loop** until all comments are processed or user wants to stop
 
-### Step 5: Phase 2 — Execute (Batch Executor)
+### Step 4: Phase 2 — Execute (Batch Executor)
 
-Phase 2 is a **batch executor** that drains the current queue. Run it once at the end of Phase 1, or multiple times via the "Flush queue now" option — each invocation processes whatever is queued at that moment, then control returns to Phase 1 (if comments remain) or to Step 6.
+Phase 2 is a **batch executor** that drains the current queue. Run it once at the end of Phase 1, or multiple times via the "Flush queue now" option — each invocation processes whatever is queued at that moment, then control returns to Phase 1 (if comments remain) or to Step 5.
 
 Within a single Phase 2 invocation, the order below is strict. The invariants apply per-batch, not per-session.
 
@@ -215,7 +203,10 @@ Within a single Phase 2 invocation, the order below is strict. The invariants ap
 
      On `Edit first`: after user confirms edits done, run the footer check, Read the file, share opinion, then ask again: `Approve or edit again?` with options `Approve` / `Edit again`. Loop until approved.
    - **Commit** — one commit per comment, no batching, no exceptions. This applies to all changes including docs and markdown.
-   - Capture commit hash (`git rev-parse HEAD`) and repo URL (`git remote get-url origin`). Replace the `[COMMIT LINK]` placeholder in `<reply_file>` with the real link.
+   - Fill in the `[COMMIT LINK]` placeholder in `<reply_file>`:
+     ```bash
+     .claude/skills/address-pr-comments/commit-link.py <reply_file> --pr <pr_number>
+     ```
    - Run footer check: `.claude/skills/address-pr-comments/check-footer.py <reply_file>`
    - Update bd issue description to store commit hash and reply: `bd update <id> --description="<existing description>\n\ncommit: <hash>\nreply: <intended reply text>" --json`
    - Close the bd issue (`bd close <id> --reason "Addressed in PR review" --json`)
@@ -237,7 +228,7 @@ Within a single Phase 2 invocation, the order below is strict. The invariants ap
    .claude/skills/address-pr-comments/post-reply.py --comment-id <id> --comment-type issues/comments --body-file <reply_file> --pr <pr_number>
    ```
 
-### Step 6: Report Completion
+### Step 5: Report Completion
 
 Summarise what was done:
 - Number of comments addressed
@@ -278,10 +269,8 @@ Discuss with user, then post a reply explaining the reasoning if they want to pu
 
 ## Checklist
 
-- [ ] Verify on feature branch (not main/master)
+- [ ] Run `verify-env.py`: feature branch (not main/master), remote exists, tree clean, PR identified and open
 - [ ] If `--resume`: build inventory, classify reply drafts (placeholder vs finalized vs orphan), prompt user for resume strategy
-- [ ] Identify PR (from argument or auto-detect)
-- [ ] Verify PR is open
 - [ ] Fetch and display comments
 - [ ] Phase 1: collect decisions for all comments (reply-only comments posted in Phase 1)
 - [ ] Phase 2: implement code changes, one commit per comment

.claude/skills/address-pr-comments/commit-link.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""Replace the [COMMIT LINK] placeholder in a reply file with the PR-scoped commit link.
+
+Usage: commit-link.py <reply-file> [--pr <number>] [--commit <hash>]
+
+Everything is self-derived when the optional flags are omitted:
+  --pr     auto-detected from the current branch via `gh pr view`
+  --commit defaults to HEAD
+
+The link points at the commit *within the PR* (GitHub redirects
+/pull/<pr>/changes/<hash> to the PR-scoped changes view) rather than the
+repo-wide commit view (/commit/<hash>), so replies posted against it are
+associated with the PR. Owner and repo are derived from the git remote
+automatically.
+
+Prints "replaced" on success. Exits non-zero if the placeholder is absent.
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+from utils import owner_repo_from_remote
+from utils import run_cmd
+
+PLACEHOLDER = "[COMMIT LINK]"
+
+
+def resolve_commit(ref: str) -> str:
+    try:
+        result = run_cmd(
+            ["git", "rev-parse", ref],
+            timeout=15,
+            timeout_msg=f"Timed out resolving commit ref '{ref}'.",
+        )
+    except subprocess.CalledProcessError as e:
+        _ = sys.stderr.write(f"Cannot resolve commit ref '{ref}': {e.stderr}\n")
+        sys.exit(1)
+    return result.stdout.strip()
+
+
+def detect_pr() -> int:
+    try:
+        result = run_cmd(
+            ["gh", "pr", "view", "--json", "number"],
+            timeout=30,
+            timeout_msg="Timed out detecting the PR for the current branch.",
+        )
+    except subprocess.CalledProcessError as e:
+        _ = sys.stderr.write(f"Cannot detect a PR for the current branch: {e.stderr}\nPass --pr explicitly.\n")
+        sys.exit(1)
+    return int(json.loads(result.stdout)["number"])
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    _ = parser.add_argument("reply_file", type=Path, help="Reply file containing the [COMMIT LINK] placeholder")
+    _ = parser.add_argument("--pr", type=int, default=None, help="PR number (default: auto-detect from current branch)")
+    _ = parser.add_argument("--commit", default="HEAD", help="Commit ref to link (default: HEAD)")
+    args = parser.parse_args()
+
+    try:
+        content = args.reply_file.read_text(encoding="utf-8")
+    except OSError as e:
+        _ = sys.stderr.write(f"File error for {args.reply_file}: {e}\n")
+        sys.exit(1)
+
+    if PLACEHOLDER not in content:
+        _ = sys.stderr.write(f"Placeholder {PLACEHOLDER} not found in {args.reply_file}.\n")
+        sys.exit(1)
+
+    owner, repo = owner_repo_from_remote()
+    pr = args.pr if args.pr is not None else detect_pr()
+    commit = resolve_commit(args.commit)
+    url = f"https://github.com/{owner}/{repo}/pull/{pr}/changes/{commit}"
+    # Markdown format required: GitHub auto-canonicalises bare PR-scoped URLs to
+    # the standalone /commit/<hash> view, where comments are not PR-associated.
+    link = f"[{commit[:7]}]({url})"
+
+    try:
+        _ = args.reply_file.write_text(content.replace(PLACEHOLDER, link), encoding="utf-8")
+    except OSError as e:
+        _ = sys.stderr.write(f"File error for {args.reply_file}: {e}\n")
+        sys.exit(1)
+    _ = sys.stdout.write("replaced\n")
+
+
+if __name__ == "__main__":
+    main()

.claude/skills/address-pr-comments/post-reply.py

@@ -22,6 +22,7 @@
 
 sys.path.insert(0, str(Path(__file__).parent))
 from utils import owner_repo_from_remote
+from utils import run_cmd
 
 
 def main() -> None:
@@ -51,8 +52,8 @@ def main() -> None:
         endpoint = f"repos/{owner}/{repo}/issues/{args.pr}/comments"
 
     try:
-        result = subprocess.run(  # noqa: S603 — endpoint and body are constructed from validated inputs
-            [  # noqa: S607 — gh is expected on PATH
+        result = run_cmd(
+            [
                 "gh",
                 "api",
                 endpoint,
@@ -61,14 +62,9 @@ def main() -> None:
                 "--raw-field",
                 f"body={body}",
             ],
-            capture_output=True,
-            text=True,
-            check=True,
             timeout=30,
+            timeout_msg="gh api timed out while posting reply.",
         )
-    except subprocess.TimeoutExpired:
-        _ = sys.stderr.write("gh api timed out while posting reply.\n")
-        sys.exit(1)
     except subprocess.CalledProcessError as e:
         _ = sys.stderr.write(f"gh api error: {e.stderr}\n")
         sys.exit(1)

.claude/skills/address-pr-comments/utils.py

@@ -3,18 +3,32 @@
 import sys
 
 
-def owner_repo_from_remote() -> tuple[str, str]:
+def run_cmd(
+    cmd: list[str],
+    *,
+    timeout: int,
+    timeout_msg: str,
+) -> subprocess.CompletedProcess[str]:
     try:
-        result = subprocess.run(
-            ["git", "remote", "get-url", "origin"],  # noqa: S607 — git is expected on PATH
+        return subprocess.run(  # noqa: S603 — callers are responsible for only passing safe commands
+            cmd,
             capture_output=True,
             text=True,
             check=True,
-            timeout=15,
+            timeout=timeout,
         )
     except subprocess.TimeoutExpired:
-        _ = sys.stderr.write("Timed out reading git remote 'origin'.\n")
+        _ = sys.stderr.write(f"{timeout_msg}\n")
         sys.exit(1)
+
+
+def owner_repo_from_remote() -> tuple[str, str]:
+    try:
+        result = run_cmd(
+            ["git", "remote", "get-url", "origin"],
+            timeout=15,
+            timeout_msg="Timed out reading git remote 'origin'.",
+        )
     except subprocess.CalledProcessError:
         _ = sys.stderr.write("Cannot read git remote 'origin'. Ensure it exists and points to GitHub.\n")
         sys.exit(1)