@weotro/dx 0.1.5 → 0.1.6

package/skills/prune-git-repository/scripts/prune-branches.sh

@@ -0,0 +1,136 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+remote=origin
+base=main
+stale_days=20
+execute=false
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --remote) remote=$2; shift 2 ;;
+    --base) base=$2; shift 2 ;;
+    --stale-days) stale_days=$2; shift 2 ;;
+    --execute) execute=true; shift ;;
+    *) echo "unknown argument: $1" >&2; exit 2 ;;
+  esac
+done
+
+[[ "$stale_days" =~ ^[0-9]+$ ]] || { echo "--stale-days must be a non-negative integer" >&2; exit 2; }
+command -v rtk >/dev/null || { echo "rtk is required" >&2; exit 1; }
+git_raw() { rtk proxy git "$@"; }
+
+git_raw rev-parse --is-inside-work-tree >/dev/null
+git_raw fetch "$remote" --prune
+base_ref="refs/remotes/$remote/$base"
+git_raw show-ref --verify --quiet "$base_ref" || { echo "missing $base_ref" >&2; exit 1; }
+
+if cutoff=$(date -v-"${stale_days}"d +%s 2>/dev/null); then
+  cutoff_iso=$(date -r "$cutoff" '+%Y-%m-%d %H:%M:%S %z')
+else
+  cutoff=$(date -d "$stale_days days ago" +%s)
+  cutoff_iso=$(date -d "@$cutoff" '+%Y-%m-%d %H:%M:%S %z')
+fi
+
+tmp=$(mktemp -d)
+trap 'rm -rf "$tmp"' EXIT
+: > "$tmp/local"
+: > "$tmp/remote"
+: > "$tmp/protected"
+current=$(git_raw branch --show-current)
+git_raw worktree list --porcelain | sed -n 's/^branch refs\/heads\///p' > "$tmp/checked-out"
+
+git_raw for-each-ref --format='%(refname)|%(refname:short)|%(committerdate:unix)' refs/heads > "$tmp/local-refs"
+while IFS='|' read -r ref short ts; do
+  [[ "$short" == "$base" ]] && continue
+  reason=
+  if git_raw merge-base --is-ancestor "$ref" "$base_ref"; then
+    reason=merged
+  elif [[ "$ts" -le "$cutoff" ]]; then
+    reason=stale-unmerged
+  fi
+  if [[ -n "$reason" ]] && grep -Fqx "$short" "$tmp/checked-out"; then
+    printf 'local|%s|%s\n' "$short" "$reason" >> "$tmp/protected"
+  elif [[ -n "$reason" ]]; then
+    printf '%s|%s|%s\n' "$short" "$reason" "$ts" >> "$tmp/local"
+  fi
+done < "$tmp/local-refs"
+
+git_raw for-each-ref --format='%(refname)|%(committerdate:unix)' "refs/remotes/$remote" > "$tmp/remote-refs"
+while IFS='|' read -r ref ts; do
+  [[ "$ref" == "refs/remotes/$remote/HEAD" || "$ref" == "$base_ref" ]] && continue
+  name=${ref#"refs/remotes/$remote/"}
+  [[ "$name" == "$ref" || -z "$name" ]] && continue
+  reason=
+  if git_raw merge-base --is-ancestor "$ref" "$base_ref"; then
+    reason=merged
+  elif [[ "$ts" -le "$cutoff" ]]; then
+    reason=stale-unmerged
+  fi
+  if [[ -n "$reason" ]] && grep -Fqx "$name" "$tmp/checked-out"; then
+    printf 'remote|%s|%s\n' "$name" "$reason" >> "$tmp/protected"
+  elif [[ -n "$reason" ]]; then
+    printf '%s|%s|%s\n' "$name" "$reason" "$ts" >> "$tmp/remote"
+  fi
+done < "$tmp/remote-refs"
+
+echo "cutoff=$cutoff_iso"
+echo "local_candidates=$(wc -l < "$tmp/local" | tr -d ' ')"
+awk -F'|' '{print "  " $1 " [" $2 "]"}' "$tmp/local"
+echo "remote_candidates=$(wc -l < "$tmp/remote" | tr -d ' ')"
+awk -F'|' '{print "  " $1 " [" $2 "]"}' "$tmp/remote"
+echo "protected_checked_out=$(wc -l < "$tmp/protected" | tr -d ' ')"
+awk -F'|' '{print "  " $1 ":" $2 " [" $3 "]"}' "$tmp/protected"
+
+if ! $execute; then
+  echo "dry_run=true"
+  exit 0
+fi
+
+failures=0
+
+batch=()
+flush_remote_batch() {
+  [[ ${#batch[@]} -eq 0 ]] && return 0
+  if ! git_raw push "$remote" "${batch[@]}"; then
+    failures=$((failures + 1))
+  fi
+  batch=()
+}
+
+while IFS='|' read -r name reason ts; do
+  [[ -z "$name" ]] && continue
+  batch+=(":refs/heads/$name")
+  if [[ ${#batch[@]} -ge 30 ]]; then flush_remote_batch; fi
+done < "$tmp/remote"
+flush_remote_batch
+
+local_deleted=0
+while IFS='|' read -r name reason ts; do
+  [[ -z "$name" ]] && continue
+  if git_raw branch -D -- "$name"; then
+    local_deleted=$((local_deleted + 1))
+  else
+    failures=$((failures + 1))
+  fi
+done < "$tmp/local"
+
+git_raw fetch "$remote" --prune
+remote_left=0
+while IFS='|' read -r name reason ts; do
+  [[ -z "$name" ]] && continue
+  if git_raw ls-remote --exit-code --heads "$remote" "refs/heads/$name" >/dev/null 2>&1; then
+    remote_left=$((remote_left + 1))
+  fi
+done < "$tmp/remote"
+
+local_left=0
+while IFS='|' read -r name reason ts; do
+  [[ -z "$name" ]] && continue
+  if git_raw show-ref --verify --quiet "refs/heads/$name"; then
+    local_left=$((local_left + 1))
+  fi
+done < "$tmp/local"
+
+echo "local_deleted=$local_deleted local_left=$local_left remote_left=$remote_left failures=$failures"
+[[ "$local_left" -eq 0 && "$remote_left" -eq 0 && "$failures" -eq 0 ]]

package/skills/prune-git-repository/scripts/prune-tags-releases.sh

@@ -0,0 +1,117 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+remote=origin
+keep=10
+execute=false
+tags_only=false
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --remote) remote=$2; shift 2 ;;
+    --keep) keep=$2; shift 2 ;;
+    --execute) execute=true; shift ;;
+    --tags-only) tags_only=true; shift ;;
+    *) echo "unknown argument: $1" >&2; exit 2 ;;
+  esac
+done
+
+[[ "$keep" =~ ^[1-9][0-9]*$ ]] || { echo "--keep must be a positive integer" >&2; exit 2; }
+command -v rtk >/dev/null || { echo "rtk is required" >&2; exit 1; }
+git_raw() { rtk proxy git "$@"; }
+gh_raw() { rtk proxy gh "$@"; }
+jq_raw() { rtk proxy jq "$@"; }
+
+git_raw rev-parse --is-inside-work-tree >/dev/null
+git_raw fetch "$remote" --tags --prune
+tmp=$(mktemp -d)
+trap 'rm -rf "$tmp"' EXIT
+
+git_raw for-each-ref --sort=-creatordate --format='%(refname:short)' refs/tags | sed -n "1,${keep}p" > "$tmp/keep-tags"
+sort "$tmp/keep-tags" > "$tmp/keep-tags-sorted"
+git_raw tag --list | sort > "$tmp/local-tags"
+git_raw ls-remote --tags --refs "$remote" | awk '{sub("refs/tags/", "", $2); print $2}' | sort > "$tmp/remote-tags"
+comm -23 "$tmp/local-tags" "$tmp/keep-tags-sorted" > "$tmp/delete-local"
+comm -23 "$tmp/remote-tags" "$tmp/keep-tags-sorted" > "$tmp/delete-remote"
+
+echo "keep_tags=$(wc -l < "$tmp/keep-tags" | tr -d ' ')"
+sed 's/^/  /' "$tmp/keep-tags"
+echo "delete_local_tags=$(wc -l < "$tmp/delete-local" | tr -d ' ')"
+echo "delete_remote_tags=$(wc -l < "$tmp/delete-remote" | tr -d ' ')"
+
+if ! $tags_only; then
+  command -v gh >/dev/null || { echo "gh is required for Release cleanup" >&2; exit 1; }
+  command -v jq >/dev/null || { echo "jq is required for Release cleanup" >&2; exit 1; }
+  gh_raw auth status >/dev/null
+  gh_raw release list --limit 1000 --json tagName,publishedAt,createdAt,isDraft,isPrerelease,name > "$tmp/releases.json"
+  jq_raw -r 'sort_by(.publishedAt // .createdAt) | reverse | .[].tagName' "$tmp/releases.json" | sed -n "1,${keep}p" > "$tmp/keep-releases"
+  jq_raw -r 'sort_by(.publishedAt // .createdAt) | reverse | .[].tagName' "$tmp/releases.json" | sed -n "$((keep + 1)),\$p" > "$tmp/delete-releases"
+  sort "$tmp/keep-releases" > "$tmp/keep-releases-sorted"
+  echo "keep_releases=$(wc -l < "$tmp/keep-releases" | tr -d ' ')"
+  sed 's/^/  /' "$tmp/keep-releases"
+  echo "delete_releases=$(wc -l < "$tmp/delete-releases" | tr -d ' ')"
+  if ! cmp -s "$tmp/keep-tags-sorted" "$tmp/keep-releases-sorted"; then
+    echo "retained tag and Release sets differ; refusing combined cleanup" >&2
+    diff -u "$tmp/keep-tags-sorted" "$tmp/keep-releases-sorted" || true
+    exit 1
+  fi
+fi
+
+if ! $execute; then
+  echo "dry_run=true"
+  exit 0
+fi
+
+if ! $tags_only; then
+  while IFS= read -r tag_name; do
+    [[ -z "$tag_name" ]] && continue
+    gh_raw release delete "$tag_name" --yes
+  done < "$tmp/delete-releases"
+fi
+
+batch=()
+flush_tag_batch() {
+  [[ ${#batch[@]} -eq 0 ]] && return 0
+  git_raw push "$remote" "${batch[@]}"
+  batch=()
+}
+while IFS= read -r tag_name; do
+  [[ -z "$tag_name" ]] && continue
+  batch+=(":refs/tags/$tag_name")
+  if [[ ${#batch[@]} -ge 40 ]]; then flush_tag_batch; fi
+done < "$tmp/delete-remote"
+flush_tag_batch
+
+batch=()
+while IFS= read -r tag_name; do
+  [[ -z "$tag_name" ]] && continue
+  batch+=("$tag_name")
+  if [[ ${#batch[@]} -ge 80 ]]; then
+    git_raw tag -d "${batch[@]}"
+    batch=()
+  fi
+done < "$tmp/delete-local"
+[[ ${#batch[@]} -eq 0 ]] || git_raw tag -d "${batch[@]}"
+
+# Synchronize retained local-only tags after old remote tags are removed.
+while IFS= read -r tag_name; do
+  [[ -z "$tag_name" ]] && continue
+  if ! git_raw ls-remote --exit-code --tags --refs "$remote" "refs/tags/$tag_name" >/dev/null 2>&1; then
+    git_raw push "$remote" "refs/tags/$tag_name:refs/tags/$tag_name"
+  fi
+done < "$tmp/keep-tags"
+
+git_raw fetch "$remote" --prune --prune-tags
+git_raw tag --list | sort > "$tmp/final-local"
+git_raw ls-remote --tags --refs "$remote" | awk '{sub("refs/tags/", "", $2); print $2}' | sort > "$tmp/final-remote"
+cmp -s "$tmp/final-local" "$tmp/final-remote" || { diff -u "$tmp/final-local" "$tmp/final-remote"; exit 1; }
+[[ $(wc -l < "$tmp/final-local" | tr -d ' ') -eq $(wc -l < "$tmp/keep-tags" | tr -d ' ') ]]
+
+if ! $tags_only; then
+  gh_raw release list --limit 1000 --json tagName,publishedAt,createdAt > "$tmp/final-releases.json"
+  jq_raw -r '.[].tagName' "$tmp/final-releases.json" | sort > "$tmp/final-release-tags"
+  cmp -s "$tmp/final-remote" "$tmp/final-release-tags" || { diff -u "$tmp/final-remote" "$tmp/final-release-tags"; exit 1; }
+fi
+
+echo "final_tag_count=$(wc -l < "$tmp/final-local" | tr -d ' ')"
+if ! $tags_only; then echo "final_release_count=$(jq_raw 'length' "$tmp/final-releases.json")"; fi

package/skills/prune-git-repository/scripts/prune-worktrees.sh

@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+execute=false
+if [[ "${1:-}" == "--execute" ]]; then
+  execute=true
+elif [[ $# -ne 0 ]]; then
+  echo "usage: $0 [--execute]" >&2
+  exit 2
+fi
+
+command -v rtk >/dev/null || { echo "rtk is required" >&2; exit 1; }
+git_raw() { rtk proxy git "$@"; }
+
+repo_root=$(git_raw rev-parse --show-toplevel)
+repo_root=$(cd "$repo_root" && pwd -P)
+tmp=$(mktemp -d)
+trap 'rm -rf "$tmp"' EXIT
+
+git_raw worktree list --porcelain > "$tmp/worktrees"
+sed -n 's/^worktree //p' "$tmp/worktrees" | while IFS= read -r wt_path; do
+  [[ "$wt_path" == "$repo_root" ]] && continue
+  printf '%s\n' "$wt_path"
+done > "$tmp/candidates"
+
+count=$(wc -l < "$tmp/candidates" | tr -d ' ')
+echo "current_worktree=$repo_root"
+echo "candidate_worktrees=$count"
+sed 's/^/  /' "$tmp/candidates"
+
+if ! $execute; then
+  echo "dry_run=true"
+  exit 0
+fi
+
+removed=0
+failed=0
+while IFS= read -r wt_path; do
+  [[ -z "$wt_path" ]] && continue
+  [[ "$wt_path" == "$repo_root" || "$wt_path" == "/" ]] && { echo "refusing unsafe path: $wt_path" >&2; exit 1; }
+
+  if [[ ! -e "$wt_path" ]]; then
+    continue
+  fi
+
+  if git_raw worktree remove --force --force -- "$wt_path"; then
+    removed=$((removed + 1))
+    continue
+  fi
+
+  echo "git removal failed; using registered-path fallback: $wt_path" >&2
+  if rtk proxy /usr/bin/find "$wt_path" -mindepth 1 -maxdepth 1 -exec /bin/rm -rf -- '{}' + \
+    && rtk proxy /usr/bin/find "$wt_path" -depth -delete >/dev/null 2>&1; then
+    removed=$((removed + 1))
+  else
+    failed=$((failed + 1))
+  fi
+done < "$tmp/candidates"
+
+git_raw worktree prune --expire now
+git_raw worktree list --porcelain > "$tmp/final"
+sed -n 's/^worktree //p' "$tmp/final" | awk -v current="$repo_root" '$0 != current' > "$tmp/remaining"
+remaining=$(wc -l < "$tmp/remaining" | tr -d ' ')
+
+echo "removed=$removed failed=$failed remaining=$remaining"
+if [[ "$remaining" -ne 0 || "$failed" -ne 0 ]]; then
+  sed 's/^/  remaining: /' "$tmp/remaining" >&2
+  exit 1
+fi
+
+cat "$tmp/final"

package/skills/create-issue/SKILL.md

@@ -1,90 +0,0 @@
----
-name: create-issue
-description: 仅在用户显式调用 $create-issue、/create-issue 或明确要求使用 create-issue 技能时使用；不要通过关键词、任务类型或上下文自动触发。
----
-
-# Create Issue
-
-## Overview
-
-Turn a converged discussion into issue(s) that read like **an architect handing a spec to a programmer**: the programmer can locate the work, understand the plan without asking back, and verify done objectively — without the user re-issuing instructions each time.
-
-**Core principle — write it as a task dispatch, not a bug note.** Every issue must let a programmer execute end-to-end on first read. That means three things per finding:
-1. **Stable location** — anchor to a durable identifier (`file` + function/class/symbol/section name, or a short quoted snippet). Line numbers are a *navigation hint only*, always approximate, never the anchor — code shifts and a hard line pin rots immediately and over-constrains the fix.
-2. **An unambiguous plan** — what to change and why, with no decision left dangling that forces the programmer to come back and ask.
-3. **An objective acceptance check** — verifiable by behavior/text/data-state plus a runnable command where applicable.
-
-An issue that says "the button is wrong" forces the developer to re-investigate what you already know. An issue pinned to `Button.tsx:42` sends them to the wrong line after one edit. Anchor by symbol, plan the work, define done.
-
-**Manual-only:** this skill NEVER auto-triggers on keywords (提issue / file an issue / etc.). Run it only when the user explicitly invokes `/create-issue` or names the skill.
-
-## When to Use
-
-Only on explicit invocation. Appropriate when a review/investigation has converged — you've already located code and compared against a source of truth, and actionable items emerged.
-
-**Not for:** still-exploring discussions, trivial one-line fixes the user is about to do themselves, or vague ideas with no verifiable outcome.
-
-## Workflow
-
-1. **Probe the repo's issue conventions first.** Read `CONTRIBUTING`, issue templates (`.github/`), or any `git-workflow`/ruler docs; skim a recent `gh issue list`. Match their template, labels, title style. Never hardcode another repo's format.
-2. **Group issues:**
-   - **3+ issues → always auto-create one parent/umbrella tracking issue + child issues. Do NOT ask, do NOT discuss.** Children link back with `Refs: #<parent>`; the parent lists children as a checklist and holds the cross-issue map.
-   - **Fewer than 3 → apply the Merge vs. Split table.** Confirm via AskUserQuestion only when genuinely ambiguous; otherwise state the default and proceed.
-3. **Anchor every finding to a stable location.** Anchor by `file` + durable identifier (function/class/method/symbol name, or a short quoted snippet), NOT by a hard line number. A line number may ride along as an approximate hint (`Button.tsx · onSubmit() (~L42)`), but the symbol is the anchor — it survives edits, a line pin doesn't. Pair each with its source-of-truth location (design section, spec criterion). Present as a table: `维度 | 期望(真源) | 现状(代码) | 位置(符号/锚点)`.
-4. **Plan the work like an architect.** State the intended approach so a programmer can execute without coming back to ask. Resolve the decisions you can already resolve; for genuinely open ones, say so explicitly and give the constraint/tradeoff rather than leaving a silent gap. Name the shared root cause once. Avoid ambiguity: if a phrasing could be read two ways, rewrite it.
-5. **Draw the boundary.** Explicitly list what's OUT of scope, what stays unchanged, and any knock-on effects on other files/modules — so the developer doesn't "fix" intentional things or miss a ripple. Call out adjacent code the change must NOT break.
-6. **Make acceptance criteria objective.** Each checkbox judges ONE thing, verifiable by behavior/text/data-state PLUS a runnable command (lint/build/test) where applicable. No "code is cleaner" subjective items.
-7. **Create via heredoc**, not `-m`/`--body` single-line (literal `\n` won't become newlines). Title in Conventional Commits style. For plain ordinals use `A1`/`第1项`/`` `#1` `` — never bare `#1`/`#2` (GitHub resolves them to issue links).
-8. **Review created issues — both plan AND code (MANDATORY).** After ALL issues are created, dispatch a subagent to audit them (see section below). The audit has TWO jobs: (a) verify claims match the codebase, and (b) read each issue as the programmer who'll execute it and flag any plan-level defect — ambiguity, missing decision, wrong/risky approach, undefined scope. Fix EVERY problem it reports via `gh issue edit` before reporting done.
-9. **Report back** the created URL(s) + one-line grouping/boundary summary + what the review found and fixed.
-
-## Post-Creation Review (mandatory)
-
-After creating every issue, dispatch a subagent (Explore or general-purpose). Hand it the issue numbers/URLs and have it run BOTH passes below per issue. Reading code consistency alone is not enough — a factually-correct issue can still be unexecutable.
-
-**Pass A — Code consistency (does it match reality?):**
-- Every location anchor (file + symbol) actually exists and points at the claimed code. (Don't fail an issue over a stale line-number hint — anchors are symbols; line numbers are approximate by design.)
-- Each acceptance criterion is objectively verifiable (a real command / path / behavior), not aspirational.
-- Claims about current state (bugs, missing permissions/config, signatures) are true in the code TODAY.
-- No finding contradicts the codebase or describes work already done.
-
-**Pass B — Plan soundness (read it as the assigned programmer):** Ask "could I execute this start-to-finish without coming back to ask a question?"
-- **Ambiguity:** any sentence open to two readings; vague pronouns; "fix the handling" with no defined target behavior.
-- **Missing decision:** the issue defers a choice it should have made (which API, which file, which pattern) and leaves the programmer guessing.
-- **Wrong/risky approach:** the proposed plan would break adjacent code, fight an existing convention (check ruler/CLAUDE.md), or pick a clearly worse path.
-- **Undefined scope/boundary:** no out-of-scope statement, or knock-on effects on other modules not called out.
-- **Acceptance ≠ goal:** the checkboxes, even if objective, don't actually prove the stated goal is met.
-- **Structural:** `Refs:`/parent links correct; no bare `#n` ordinal mis-links; 3+ issues have an umbrella.
-
-The subagent returns a per-issue defect list spanning both passes. **You MUST fix ALL reported problems** via `gh issue edit` (heredoc), then re-verify. Do not report the task complete while any reported problem stands unfixed.
-
-## Merge vs. Split (only when <3 issues)
-
-| Signal | Action |
-|--------|--------|
-| Same component / source-of-truth target / change cycle, mutually non-blocking | One issue, internal groups (A/B/C) |
-| Different host (e.g. web vs. mobile/Flutter), independent tracking/rollback, one item far heavier | Split, link with `Refs:` |
-| User explicitly asks to split/merge | Follow user, link related ones |
-
-## Common Mistakes
-
-- **Pinning to a hard line number** → after one edit the anchor points at the wrong code and over-constrains the fix. Anchor by file + symbol; line numbers are an approximate hint only.
-- **Filename with no symbol anchor at all** → developer re-hunts. Always name the function/class/section.
-- **Writing a bug note, not a task spec** → "X is wrong" with no plan leaves the programmer to redesign. State the intended approach.
-- **Leaving a decision dangling** → "handle this better" forces a round-trip question. Resolve it, or state the constraint explicitly if genuinely open.
-- **Acceptance criteria all subjective/visual** → not verifiable. Attach a command or observable behavior.
-- **Acceptance that doesn't prove the goal** → objective but checks the wrong thing. Tie each checkbox to the stated goal.
-- **Asking about grouping for 3+ issues** → don't. Auto-create umbrella + children.
-- **Post-creation review only checks code, not the plan** → ships factually-correct but unexecutable/ambiguous issues. Run BOTH passes (code consistency + plan soundness).
-- **No out-of-scope section** → developer changes intentional things or misses a ripple. Always state the boundary and knock-on effects.
-- **`-m "...\n..."`** → literal `\n` in the issue body. Use heredoc `--body-file -`.
-- **Bare `#1`/`#2` for ordinals** → GitHub mis-links them. Use `A1` / backticks.
-
-## Red Flags — stop and fix before reporting done
-
-- About to anchor a finding to a bare line number, or with no symbol/source-of-truth reference at all.
-- The issue describes what's wrong but not what to do about it — a programmer would have to design the fix from scratch.
-- A sentence in the issue could be read two ways, or defers a decision the issue should have made.
-- An acceptance checkbox you can't verify by running something or observing a concrete state — or that doesn't actually prove the goal.
-- 3+ issues created without an umbrella, or related issues without `Refs:`.
-- Reported done without running BOTH review passes (code + plan) and fixing every finding.