@minakoto00/skills 0.1.0

package/skills/review-pr/docs/examples.md

@@ -0,0 +1,106 @@
+# Review PR Examples
+
+## Latest Open GitLab MR
+
+```bash
+bash scripts/resolve_review_target.sh --repo /path/to/repo --latest
+```
+
+Expected shape:
+
+```text
+platform=gitlab
+number=42
+source_branch=feat/example
+head_sha=<sha>
+```
+
+## Specific GitHub PR
+
+```bash
+bash scripts/resolve_review_target.sh --repo /path/to/repo --number 128
+```
+
+## Fetch Review Comments
+
+```bash
+bash scripts/fetch_review_comments.sh --repo /path/to/repo --number 128 --platform github --json
+```
+
+If `code-review comments` are present, ask the user whether to include code-review comments in scope.
+
+If `discussion comments` are present, ask the user whether to include discussion comments in scope.
+
+Only the approved comment categories move forward.
+
+Resolved code-review feedback is excluded by default.
+
+Outdated threads are validated separately from unresolved threads.
+
+Group approved unresolved and outdated code-review feedback into issue clusters before validation.
+
+For approved comments, dispatch several subagents in parallel to validate whether the comments still make sense.
+
+During that validation, subagents search only within changed files for same-pattern candidates.
+
+Those same-pattern candidates are reported separately from the original issues.
+
+Then confirm the verification report with the user before planning fixes.
+
+## Inspect Repo Policy
+
+```bash
+bash scripts/repo_policy.sh --repo /path/to/repo
+```
+
+This inspects both `AGENTS.md` and `CLAUDE.md` if they exist. If neither file defines a worktree rule, the fallback is `<repo>/.worktrees`.
+
+## Reuse Existing Worktree
+
+```bash
+bash scripts/worktree_sync.sh \
+  --repo /path/to/repo \
+  --source-branch feat/example \
+  --head-sha abcdef1234567890
+```
+
+If the worktree already exists and is clean, the script fetches and fast-forwards the source branch, then aligns it to the requested MR/PR head SHA.
+
+## Create Missing Worktree
+
+```bash
+bash scripts/worktree_sync.sh \
+  --repo /path/to/repo \
+  --source-branch feat/example \
+  --head-sha abcdef1234567890
+```
+
+If the worktree does not exist, the script creates it under the repo-approved worktree root and checks out the remote source branch.
+
+## Comment-Only Proposal
+
+```bash
+bash scripts/post_review_comment.sh \
+  --repo /path/to/repo \
+  --number 42 \
+  --body-file /tmp/review-plan.md
+```
+
+Suggested comment body structure:
+
+```md
+## Change Plan
+
+- Summary of review findings
+- Files or subsystems likely to change
+- Patch outline
+- Verification steps
+```
+
+## Installer Dry Run
+
+Advanced manual installer:
+
+```bash
+bash install-skill.sh --agent codex --scope user-global --method symlink --dry-run
+```

package/skills/review-pr/scripts/cluster_review_issues.sh

@@ -0,0 +1,110 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+# shellcheck source=./common.sh
+source "$SCRIPT_DIR/common.sh"
+
+input_path=
+
+usage() {
+  cat <<'USAGE'
+Usage: cluster_review_issues.sh [--input <path>]
+
+Read normalized review-comment JSON and group unresolved or outdated code-review comments into issue clusters.
+USAGE
+}
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --input)
+      input_path=$2
+      shift 2
+      ;;
+    --help|-h)
+      usage
+      exit 0
+      ;;
+    *)
+      die "unknown argument: $1"
+      ;;
+  esac
+done
+
+require_cmd jq
+
+if [[ -n "$input_path" ]]; then
+  input_json=$(cat "$input_path")
+else
+  input_json=$(cat)
+fi
+
+jq -cn --argjson payload "$input_json" '
+  def review_comments:
+    $payload.code_review_comments.items // [];
+
+  def comment_state($comment):
+    $comment.thread_state
+    // (if ($comment.thread_resolved // false) then "resolved" else "unresolved" end);
+
+  def cluster_key($comment):
+    $comment.cluster_key
+    // $comment.issue_key
+    // (
+      (($comment.path // "") + "::" + ($comment.body // ""))
+      | gsub("[[:space:]]+"; " ")
+    );
+
+  def resolved_comments:
+    review_comments
+    | map(select(comment_state(.) == "resolved"));
+
+  def active_comments:
+    review_comments
+    | map(select(comment_state(.) != "resolved"));
+
+  def issue_clusters:
+    active_comments
+    | sort_by(cluster_key(.))
+    | group_by(cluster_key(.))
+    | map(
+        . as $cluster_comments
+        | {
+            cluster_id: cluster_key($cluster_comments[0]),
+            comment_count: ($cluster_comments | length),
+            comment_ids: ($cluster_comments | map(.id | tostring)),
+            thread_ids: ($cluster_comments | map(.thread_id // null) | unique),
+            thread_states: ($cluster_comments | map(comment_state(.)) | unique | sort),
+            paths: ($cluster_comments | map(.path // "") | unique | sort),
+            comments: (
+              $cluster_comments
+              | map({
+                  id: (.id | tostring),
+                  thread_id: (.thread_id // null),
+                  thread_state: comment_state(.),
+                  path: (.path // ""),
+                  body: (.body // "")
+                })
+            )
+          }
+      );
+
+  {
+    excluded_resolved_threads: {
+      count: (resolved_comments | map(.thread_id // .id) | unique | length),
+      comment_count: (resolved_comments | length),
+      thread_ids: (resolved_comments | map(.thread_id // .id) | unique | sort)
+    },
+    active_review_comments: {
+      count: (active_comments | length),
+      state_counts: {
+        unresolved: (active_comments | map(select(comment_state(.) == "unresolved")) | length),
+        outdated: (active_comments | map(select(comment_state(.) == "outdated")) | length)
+      }
+    },
+    issue_clusters: {
+      count: (issue_clusters | length),
+      items: issue_clusters
+    }
+  }
+'

package/skills/review-pr/scripts/common.sh

@@ -0,0 +1,101 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+script_dir() {
+  cd "$(dirname "${BASH_SOURCE[0]}")" && pwd
+}
+
+die() {
+  printf 'error: %s\n' "$*" >&2
+  exit 1
+}
+
+warn() {
+  printf 'warn: %s\n' "$*" >&2
+}
+
+require_cmd() {
+  command -v "$1" >/dev/null 2>&1 || die "missing required command: $1"
+}
+
+resolve_repo_root() {
+  local repo_arg="${1:-.}"
+  git -C "$repo_arg" rev-parse --show-toplevel 2>/dev/null || die "not a git repository: $repo_arg"
+}
+
+origin_url() {
+  local repo_root=$1
+  git -C "$repo_root" remote get-url origin 2>/dev/null || die "repository has no origin remote: $repo_root"
+}
+
+trim() {
+  local value=$1
+  value=${value#"${value%%[![:space:]]*}"}
+  value=${value%"${value##*[![:space:]]}"}
+  printf '%s' "$value"
+}
+
+print_kv() {
+  local key=$1
+  local value=${2-}
+  printf '%s=%q\n' "$key" "$value"
+}
+
+normalize_path() {
+  local raw=$1
+  python3 - "$raw" <<'PY'
+import os
+import sys
+print(os.path.abspath(os.path.expanduser(sys.argv[1])))
+PY
+}
+
+expand_path() {
+  local raw=$1
+  local repo_root=$2
+
+  if [[ -z "$raw" ]]; then
+    die "cannot expand empty path"
+  fi
+
+  if [[ "$raw" == ~* ]]; then
+    raw="${raw/#\~/$HOME}"
+  fi
+
+  case "$raw" in
+    /*)
+      normalize_path "$raw"
+      ;;
+    ./*|../*)
+      normalize_path "$repo_root/$raw"
+      ;;
+    *)
+      normalize_path "$raw"
+      ;;
+  esac
+}
+
+sanitize_branch_name() {
+  local branch=$1
+  branch=${branch//\//-}
+  branch=${branch//:/-}
+  branch=${branch// /-}
+  printf '%s' "$branch"
+}
+
+repository_slug_from_remote() {
+  local remote_url=$1
+  local slug
+
+  slug=$(printf '%s' "$remote_url" | sed -E 's#^[a-z]+://[^/]+/##; s#^git@[^:]+:##; s#\.git$##')
+  if [[ -z "$slug" || "$slug" == "$remote_url" ]]; then
+    die "unable to derive repository slug from remote: $remote_url"
+  fi
+
+  printf '%s' "$slug"
+}
+
+load_kv_output() {
+  local output=$1
+  eval "$output"
+}

package/skills/review-pr/scripts/detect_platform.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+# shellcheck source=./common.sh
+source "$SCRIPT_DIR/common.sh"
+
+repo=.
+remote_url=
+
+usage() {
+  cat <<'USAGE'
+Usage: detect_platform.sh [--repo <path>] [--remote-url <url>]
+
+Detect the remote VCS platform from a repository or explicit remote URL.
+Prints one of: github, gitlab
+USAGE
+}
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --repo)
+      repo=$2
+      shift 2
+      ;;
+    --remote-url)
+      remote_url=$2
+      shift 2
+      ;;
+    --help|-h)
+      usage
+      exit 0
+      ;;
+    *)
+      die "unknown argument: $1"
+      ;;
+  esac
+done
+
+if [[ -z "$remote_url" ]]; then
+  repo=$(resolve_repo_root "$repo")
+  remote_url=$(origin_url "$repo")
+fi
+
+case "$remote_url" in
+  *github.com* )
+    printf 'github\n'
+    ;;
+  *gitlab* )
+    printf 'gitlab\n'
+    ;;
+  * )
+    die "unsupported remote platform: $remote_url"
+    ;;
+esac

package/skills/review-pr/scripts/fetch_review_comments.sh

@@ -0,0 +1,301 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+# shellcheck source=./common.sh
+source "$SCRIPT_DIR/common.sh"
+
+repo=.
+platform=
+number=
+json_output=false
+
+usage() {
+  cat <<'USAGE'
+Usage: fetch_review_comments.sh --repo <path> --number <id> [--platform <github|gitlab>] [--json]
+
+Fetch MR/PR comments and normalize them into code-review comments and discussion comments.
+USAGE
+}
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --repo)
+      repo=$2
+      shift 2
+      ;;
+    --platform)
+      platform=$2
+      shift 2
+      ;;
+    --number)
+      number=$2
+      shift 2
+      ;;
+    --json)
+      json_output=true
+      shift
+      ;;
+    --help|-h)
+      usage
+      exit 0
+      ;;
+    *)
+      die "unknown argument: $1"
+      ;;
+  esac
+done
+
+[[ -n "$number" ]] || die "--number is required"
+
+repo=$(resolve_repo_root "$repo")
+require_cmd jq
+
+if [[ -z "$platform" ]]; then
+  platform=$("$SCRIPT_DIR/detect_platform.sh" --repo "$repo")
+fi
+
+remote_url=$(origin_url "$repo")
+repository=$(repository_slug_from_remote "$remote_url")
+
+normalize_github_comments() {
+  local review_comments=$1
+  local discussion_comments=$2
+  local review_threads=$3
+
+  jq -cn \
+    --arg platform "$platform" \
+    --arg repository "$repository" \
+    --arg number "$number" \
+    --argjson review_comments "$review_comments" \
+    --argjson discussion_comments "$discussion_comments" \
+    --argjson review_threads "$review_threads" \
+    '
+      def github_thread_lookup:
+        (
+          $review_threads.data.repository.pullRequest.reviewThreads.nodes // []
+        )
+        | map(
+            . as $thread
+            | ($thread.comments.nodes // [])[]
+            | {
+                key: (.databaseId | tostring),
+                value: {
+                  thread_id: ($thread.id // null),
+                  thread_state: (
+                    if ($thread.isResolved // false) then "resolved"
+                    elif ($thread.isOutdated // false) then "outdated"
+                    else "unresolved"
+                    end
+                  ),
+                  thread_resolved: ($thread.isResolved // false),
+                  thread_outdated: ($thread.isOutdated // false)
+                }
+              }
+          )
+        | from_entries;
+
+      {
+        platform: $platform,
+        repository: $repository,
+        number: $number,
+        code_review_comments: {
+          count: ($review_comments | length),
+          items: (
+            github_thread_lookup as $thread_lookup
+            | $review_comments
+            | map(
+                (.id | tostring) as $comment_id
+                | {
+                    id: $comment_id,
+                    author: (.user.login // .user.name // "unknown"),
+                    body: (.body // ""),
+                    path: (.path // ""),
+                    start_line: (if .start_line == null then null else (.start_line | tostring) end),
+                    line: (if .line == null then "" else (.line | tostring) end),
+                    side: (.side // null),
+                    start_side: (.start_side // null),
+                    subject_type: (.subject_type // null),
+                    original_line: (if .original_line == null then null else (.original_line | tostring) end),
+                    original_start_line: (if .original_start_line == null then null else (.original_start_line | tostring) end),
+                    original_position: (if .original_position == null then null else (.original_position | tostring) end),
+                    commit_id: (.commit_id // null),
+                    original_commit_id: (.original_commit_id // null),
+                    diff_hunk: (.diff_hunk // null),
+                    url: (.html_url // ""),
+                    created_at: (.created_at // "")
+                  }
+                + ($thread_lookup[$comment_id] // {})
+              )
+          )
+        },
+        discussion_comments: {
+          count: ($discussion_comments | length),
+          items: ($discussion_comments | map({
+            id: (.id | tostring),
+            author: (.user.login // .user.name // "unknown"),
+            body: (.body // ""),
+            url: (.html_url // ""),
+            created_at: (.created_at // "")
+          }))
+        }
+      }
+    '
+}
+
+normalize_gitlab_comments() {
+  local discussions=$1
+
+  jq -cn \
+    --arg platform "$platform" \
+    --arg repository "$repository" \
+    --arg number "$number" \
+    --argjson discussions "$discussions" \
+    '
+      def active_notes:
+        [
+          $discussions[]
+          | .notes[]?
+          | select((.system // false) | not)
+        ];
+
+      def review_notes:
+        [
+          active_notes[]
+          | . as $note
+          | $discussions[]
+          | select(any(.notes[]?; (.id // null) == ($note.id // null)))
+          | . as $discussion
+          | $note
+          | select(
+              (.position // null) != null
+              or (.line_code // null) != null
+            )
+          | . + {
+              thread_id: ($discussion.id // null),
+              thread_resolved: ($discussion.resolved // false),
+              thread_state: (
+                if ($discussion.resolved // false) then "resolved"
+                else "unresolved"
+                end
+              ),
+              resolved_by: ($discussion.resolved_by // null),
+              resolved_at: ($discussion.resolved_at // null)
+            }
+        ];
+
+      def discussion_notes:
+        [
+          active_notes[]
+          | select(
+              (.position // null) == null
+              and (.line_code // null) == null
+            )
+        ];
+
+      {
+        platform: $platform,
+        repository: $repository,
+        number: $number,
+        code_review_comments: {
+          count: (review_notes | length),
+          items: (review_notes | map({
+            id: (.id | tostring),
+            author: (.author.username // .author.name // "unknown"),
+            body: (.body // ""),
+            path: (.position.new_path // .position.old_path // ""),
+            line: (
+              if (.position.new_line // null) != null then (.position.new_line | tostring)
+              elif (.position.old_line // null) != null then (.position.old_line | tostring)
+              else ""
+              end
+            ),
+            new_path: (.position.new_path // null),
+            old_path: (.position.old_path // null),
+            new_line: (if (.position.new_line // null) != null then (.position.new_line | tostring) else null end),
+            old_line: (if (.position.old_line // null) != null then (.position.old_line | tostring) else null end),
+            base_sha: (.position.base_sha // null),
+            start_sha: (.position.start_sha // null),
+            head_sha: (.position.head_sha // null),
+            position_type: (.position.position_type // null),
+            line_range: (.position.line_range // null),
+            position: (.position // null),
+            thread_id: (.thread_id // null),
+            thread_state: (.thread_state // "unresolved"),
+            thread_resolved: (.thread_resolved // false),
+            resolved_by: (.resolved_by // null),
+            resolved_at: (.resolved_at // null),
+            url: (.url // .web_url // ""),
+            created_at: (.created_at // "")
+          }))
+        },
+        discussion_comments: {
+          count: (discussion_notes | length),
+          items: (discussion_notes | map({
+            id: (.id | tostring),
+            author: (.author.username // .author.name // "unknown"),
+            body: (.body // ""),
+            url: (.url // .web_url // ""),
+            created_at: (.created_at // "")
+          }))
+        }
+      }
+    '
+}
+
+emit_kv() {
+  local json=$1
+  print_kv platform "$(printf '%s' "$json" | jq -r '.platform')"
+  print_kv repository "$(printf '%s' "$json" | jq -r '.repository')"
+  print_kv number "$(printf '%s' "$json" | jq -r '.number')"
+  print_kv code_review_comment_count "$(printf '%s' "$json" | jq -r '.code_review_comments.count')"
+  print_kv discussion_comment_count "$(printf '%s' "$json" | jq -r '.discussion_comments.count')"
+}
+
+cd "$repo"
+
+case "$platform" in
+  github)
+    require_cmd gh
+    review_comments=$(gh api "repos/$repository/pulls/$number/comments")
+    discussion_comments=$(gh api "repos/$repository/issues/$number/comments")
+    owner=${repository%%/*}
+    repo_name=${repository#*/}
+    review_threads=$(gh api graphql -f query='
+      query($owner: String!, $repo: String!, $number: Int!) {
+        repository(owner: $owner, name: $repo) {
+          pullRequest(number: $number) {
+            reviewThreads(first: 100) {
+              nodes {
+                id
+                isResolved
+                isOutdated
+                comments(first: 100) {
+                  nodes {
+                    databaseId
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    ' -F owner="$owner" -F repo="$repo_name" -F number="$number")
+    normalized=$(normalize_github_comments "$review_comments" "$discussion_comments" "$review_threads")
+    ;;
+  gitlab)
+    require_cmd glab
+    encoded_repository=$(jq -nr --arg value "$repository" '$value | @uri')
+    discussions=$(glab api "projects/$encoded_repository/merge_requests/$number/discussions" --paginate)
+    normalized=$(normalize_gitlab_comments "$discussions")
+    ;;
+  *)
+    die "unsupported platform: $platform"
+    ;;
+esac
+
+if [[ "$json_output" == true ]]; then
+  printf '%s\n' "$normalized"
+else
+  emit_kv "$normalized"
+fi