@reservine/dx 1.0.0

package/plugins/reservine-dx/commands/cherry-pick-pr.md

@@ -0,0 +1,221 @@
+---
+name: reservine-dx:cherry-pick-pr
+description: Extract specific commits from the current branch into a clean PR against the base development branch
+argument-hint: [commit hashes or description]
+allowed-tools:
+  - Read
+  - Bash
+  - AskUserQuestion
+---
+
+# Cherry-Pick PR
+
+Extract specific commits from the current branch into a clean PR against the base development branch using a temporary worktree.
+
+## Configuration
+
+Read project config before starting:
+
+```bash
+cat .claude/config 2>/dev/null
+cat .claude/config.local 2>/dev/null
+```
+
+Use `DEVELOPMENT_BRANCH` as `<base>` throughout this workflow.
+Use `GITHUB_REPO` for PR URLs and `gh` commands.
+
+If no config file exists, fall back to detection:
+```bash
+git rev-parse --verify origin/main &>/dev/null && echo "main" || echo "dev"
+```
+
+## Workflow
+
+### Step 1: Identify Commits
+
+Ask the user which commits to cherry-pick, or infer from conversation context. Show candidates with:
+
+```bash
+git log --oneline <base>..HEAD
+```
+
+Confirm the selected commits with the user before proceeding. Display them clearly:
+
+```
+Commits to cherry-pick:
+  abc1234 feat: add booking validation
+  def5678 fix: handle null employee
+```
+
+**Existing PR detection:** If the user references an existing PR (e.g., "into #281", "again into 281", "into PR 281"), store the PR number and look up its branch:
+
+```bash
+gh pr view <pr-number> --json headRefName --jq '.headRefName'
+```
+
+When an existing PR is detected:
+- Use the returned branch name as `<branch-name>` throughout
+- **Skip Step 2** (branch name already known)
+- **Skip Step 7** (PR already exists)
+
+### Step 2: Derive Branch Name
+
+> **Skipped when targeting an existing PR** — the branch name comes from `gh pr view`.
+
+Generate a branch name from the commit messages using `<type>/<short-description>` convention:
+
+| Commit prefix | Branch type |
+|---------------|-------------|
+| `feat:` | `feat/` |
+| `fix:` | `fix/` |
+| `chore:` | `chore/` |
+| `refactor:` | `refactor/` |
+| `docs:` | `docs/` |
+| Mixed types | Use the dominant type, or `chore/` as fallback |
+
+Examples:
+- Single commit `feat: add SMS toggle` -> `feat/add-sms-toggle`
+- Multiple commits about config -> `chore/config-system-updates`
+
+Confirm the branch name with the user. They may want to adjust it.
+
+### Step 3: Pre-flight Checks
+
+**New PR flow:**
+
+```bash
+# Fetch latest base branch
+git fetch origin <base>
+
+# Check if branch already exists on remote
+git ls-remote --heads origin <branch-name>
+```
+
+**If branch exists on remote:** Warn the user and ask how to proceed (rename branch, force-push, or abort).
+
+**Existing PR flow:**
+
+```bash
+# Get branch name from existing PR (already done in Step 1)
+gh pr view <pr-number> --json headRefName --jq '.headRefName'
+
+# Fetch the PR branch
+git fetch origin <branch-name>
+```
+
+### Step 4: Create Worktree
+
+**New PR flow:**
+
+```bash
+git worktree add .worktrees/<branch-name> origin/<base> -b <branch-name>
+```
+
+**Existing PR flow** — check out the existing PR branch instead of creating from base:
+
+```bash
+git worktree add .worktrees/<branch-name> origin/<branch-name> -B <branch-name>
+```
+
+### Step 5: Cherry-Pick
+
+```bash
+cd .worktrees/<branch-name>
+git cherry-pick <hash1> <hash2> ...
+```
+
+**If conflicts occur:**
+1. Stop immediately
+2. Show the conflicted files: `git diff --name-only --diff-filter=U`
+3. Show the conflict content for each file
+4. Ask the user how to resolve
+5. After resolution: `git add .` then `git cherry-pick --continue`
+
+**If cherry-pick succeeds cleanly:** Continue to Step 6.
+
+### Step 6: Push
+
+```bash
+cd .worktrees/<branch-name>
+git push -u origin <branch-name>
+```
+
+### Step 7: Create PR
+
+> **Skipped when targeting an existing PR** — the PR already exists, no need to create one.
+
+**New PR flow only:**
+
+```bash
+cd .worktrees/<branch-name>
+gh pr create --base <base> --title "<title>" --body "$(cat <<'EOF'
+## Summary
+<bullet points summarizing the cherry-picked changes>
+
+## Cherry-picked from
+Branch: `<source-branch>`
+Commits:
+- `<hash1>` <message1>
+- `<hash2>` <message2>
+
+## Test plan
+- [ ] <relevant test items based on the changes>
+EOF
+)"
+```
+
+**PR title:** Derive from commits. For single commit, use the commit message. For multiple, write a concise summary.
+
+### Step 8: Cleanup
+
+**Always run cleanup**, even if a previous step failed:
+
+```bash
+# Return to the original repo root first
+cd <original-repo-root>
+git worktree remove .worktrees/<branch-name>
+```
+
+If worktree removal fails (e.g., uncommitted changes from conflict resolution):
+
+```bash
+git worktree remove --force .worktrees/<branch-name>
+```
+
+### Step 9: Report
+
+Return the PR URL and a summary. Always include a full clickable URL.
+
+**New PR** (`gh pr create` returns the URL):
+
+```
+PR created: <url>
+Branch: <branch-name>
+Commits: <count> cherry-picked from <source-branch>
+```
+
+**Existing PR** (construct the URL from `GITHUB_REPO` and the PR number):
+
+```
+PR updated: https://github.com/<GITHUB_REPO>/pull/<pr-number>
+Branch: <branch-name>
+Commits: <count> cherry-picked from <source-branch>
+```
+
+## Error Recovery
+
+| Failure point | Recovery |
+|---------------|----------|
+| Worktree creation fails (branch exists locally) | `git branch -D <branch-name>` then retry |
+| Cherry-pick conflicts | Show conflicts, ask user, resolve, `--continue` |
+| Push fails (branch exists on remote) | Ask user: rename, force-push, or abort |
+| PR creation fails | Show error, suggest manual creation with `gh pr create` |
+| Any failure | Always clean up the worktree before stopping |
+
+## Important Notes
+
+- **Never force-push without explicit user approval**
+- **Always return to the original repo root** before worktree cleanup
+- The worktree lives in `.worktrees/` (gitignored)
+- Cherry-pick preserves original commit messages and authorship
+- If the user is on a long-running branch, remind them that the PR targets `<base>` (the main development branch)

package/plugins/reservine-dx/commands/cleanup.md

@@ -0,0 +1,297 @@
+---
+name: reservine-dx:cleanup
+description: >
+  Clean up all artifacts for a finished feature: worktrees (FE + BE), running processes
+  (nx serve, Docker stacks), local and remote branches. Verifies PRs are merged before
+  deleting. Auto-discovers sibling worktrees across repos.
+  Triggers: "cleanup", "clean worktree", "remove worktree", "tear down", "feature done".
+argument-hint: "[branch-name]"
+allowed-tools:
+  - Bash
+  - Read
+  - AskUserQuestion
+---
+
+# Feature Cleanup
+
+Clean up all artifacts for a finished feature branch across both FE and BE repos.
+
+## Step 1: Detect Branch & Resolve Repos
+
+1. Read `.claude/config` + `.claude/config.local`:
+   ```bash
+   cat .claude/config 2>/dev/null
+   cat .claude/config.local 2>/dev/null
+   ```
+   Extract: `GITHUB_REPO`, `DEVELOPMENT_BRANCH`, `BACKEND_DIR`/`FRONTEND_DIR`
+
+2. Auto-detect current repo:
+   ```bash
+   if [[ -f "angular.json" ]] || [[ -f "nx.json" ]]; then
+     CURRENT_REPO="FE"
+   else
+     CURRENT_REPO="BE"
+   fi
+   ```
+
+3. Resolve both repo paths (always need both for cross-repo cleanup):
+   - FE: from `FRONTEND_DIR` or `FRONTEND_DIR_ABSOLUTE` in config
+   - BE: from `BACKEND_DIR` or `BACKEND_DIR_ABSOLUTE` in config
+   - Resolve `FE_GITHUB_REPO` and `BE_GITHUB_REPO` from each repo's `.claude/config`
+   - Fallbacks: `LEFTEQ/reservine` (FE), `genesiscz/ReservineBack` (BE)
+
+4. Determine the target branch:
+   - **If `$ARGUMENTS` provided** → use as branch name
+   - **Else if current dir is inside `.worktrees/`** → extract branch from path
+   - **Else if on a feature branch** (not main/dev/master/release) → use current branch
+   - **Else** → list existing worktrees and `AskUserQuestion`:
+     ```bash
+     echo "=== FE worktrees ===" && git -C <FE_DIR> worktree list
+     echo "=== BE worktrees ===" && git -C <BE_DIR> worktree list
+     ```
+     Present as options: the branch names from all worktrees (deduplicated).
+
+## Step 2: Discover All Artifacts
+
+Run all discovery in parallel (single bash block), collecting results:
+
+### FE artifacts:
+```bash
+FE_DIR="<resolved FE path>"
+
+# Worktree
+FE_WORKTREE=$(git -C "$FE_DIR" worktree list | grep "<branch>" | awk '{print $1}')
+
+# Processes (check ports 4200-4210, 1111, 1112, 1113)
+FE_PIDS=""
+if [[ -n "$FE_WORKTREE" ]]; then
+  for port in 4200 4201 4202 4203 4204 4205 1112; do
+    PID=$(lsof -t -i :$port 2>/dev/null)
+    if [[ -n "$PID" ]]; then
+      # Verify the process is actually serving from this worktree
+      CMD=$(ps -p $PID -o command= 2>/dev/null)
+      if echo "$CMD" | grep -q "$FE_WORKTREE\|port.*$port"; then
+        FE_PIDS="$FE_PIDS $PID:$port"
+      fi
+    fi
+  done
+fi
+
+# Branch (local + remote)
+FE_LOCAL_BRANCH=$(git -C "$FE_DIR" branch --list "<branch>" 2>/dev/null)
+FE_REMOTE_BRANCH=$(git -C "$FE_DIR" ls-remote --heads origin "<branch>" 2>/dev/null)
+
+# PR
+FE_PR=$(gh pr list --head "<branch>" --repo "$FE_GITHUB_REPO" --state all --json number,state,mergedAt,url --jq '.[0]' 2>/dev/null)
+```
+
+### BE artifacts:
+```bash
+BE_DIR="<resolved BE path>"
+
+# Worktree
+BE_WORKTREE=$(git -C "$BE_DIR" worktree list | grep "<branch>" | awk '{print $1}')
+
+# Docker isolated stack
+BRANCH_SLUG=$(echo "<branch>" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/--*/-/g' | sed 's/^-//;s/-$//')
+BE_DOCKER=$(docker ps --filter "name=wt-${BRANCH_SLUG}" --format "{{.Names}}" 2>/dev/null)
+BE_COMPOSE=""
+if [[ -n "$BE_WORKTREE" ]] && [[ -f "$BE_WORKTREE/docker-compose.isolated.yaml" ]]; then
+  BE_COMPOSE="$BE_WORKTREE/docker-compose.isolated.yaml"
+fi
+
+# Branch (local + remote)
+BE_LOCAL_BRANCH=$(git -C "$BE_DIR" branch --list "<branch>" 2>/dev/null)
+BE_REMOTE_BRANCH=$(git -C "$BE_DIR" ls-remote --heads origin "<branch>" 2>/dev/null)
+
+# PR
+BE_PR=$(gh pr list --head "<branch>" --repo "$BE_GITHUB_REPO" --state all --json number,state,mergedAt,url --jq '.[0]' 2>/dev/null)
+```
+
+### Uncommitted changes check:
+```bash
+if [[ -n "$FE_WORKTREE" ]]; then
+  FE_DIRTY=$(git -C "$FE_WORKTREE" status --porcelain 2>/dev/null | grep -v '^??' | head -5)
+fi
+if [[ -n "$BE_WORKTREE" ]]; then
+  BE_DIRTY=$(git -C "$BE_WORKTREE" status --porcelain 2>/dev/null | grep -v '^??' | head -5)
+fi
+```
+
+## Step 3: Check PR Status & Build Summary
+
+Parse the PR JSON for each repo. Build a summary string:
+
+For each repo:
+- **MERGED**: `✓ PR #<num> — merged <relative-time>`
+- **OPEN**: `⚠ PR #<num> — still OPEN`
+- **CLOSED** (not merged): `⚠ PR #<num> — closed without merge`
+- **No PR found**: `⚠ No PR found for this branch`
+
+Determine safety level:
+- All PRs merged → **safe** (recommend "Clean everything")
+- Any PR open/missing → **unsafe** (recommend "Abort", require explicit override)
+
+## Step 4: Present Summary & Confirm
+
+Present the full discovery as a formatted message, then `AskUserQuestion`:
+
+```
+Feature Cleanup: <branch>
+═══════════════════════════
+
+FE (<FE_GITHUB_REPO>):
+  <PR status line>
+  <worktree path or "No worktree found">
+  <processes or "No running processes">
+  <branches: local + remote status>
+  <dirty warning if uncommitted changes>
+
+BE (<BE_GITHUB_REPO>):
+  <PR status line>
+  <worktree path or "No worktree found">
+  <Docker containers or "No isolated stack">
+  <branches: local + remote status>
+  <dirty warning if uncommitted changes>
+```
+
+Options (if all PRs merged and no dirty files):
+- **Clean everything** (Recommended)
+- **Skip FE** — only clean BE
+- **Skip BE** — only clean FE
+- **Abort**
+
+Options (if any PR not merged OR dirty files):
+- **Abort** (Recommended) — with warning about what's at risk
+- **Force clean everything** — delete despite warnings
+- **Skip FE** / **Skip BE**
+
+## Step 5: Execute Cleanup
+
+Execute in this exact order (processes first, then containers, then files, then git):
+
+### 5a: Kill FE processes
+```bash
+for pid_port in $FE_PIDS; do
+  PID=${pid_port%:*}; PORT=${pid_port#*:}
+  kill $PID 2>/dev/null && echo "✓ Killed process PID $PID on :$PORT"
+done
+```
+
+### 5b: Teardown BE Docker
+
+**CRITICAL:** Docker teardown MUST complete fully before the worktree directory is touched.
+Use a two-phase approach: try compose first, then force-remove by slug as mandatory cleanup.
+
+```bash
+SLUG=$(echo "<branch>" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/--*/-/g' | sed 's/^-//;s/-$//')
+
+# Phase 1: Try graceful compose down (if compose file still exists)
+if [[ -n "$BE_COMPOSE" ]] && [[ -f "$BE_COMPOSE" ]]; then
+  cd "$BE_WORKTREE"
+  docker compose -f docker-compose.isolated.yaml down -v 2>&1
+  echo "✓ Docker stack torn down via compose"
+fi
+
+# Phase 2: ALWAYS force-remove by slug (catches orphans, partially-stopped stacks, missing compose files)
+REMAINING=$(docker ps -aq --filter "name=wt-${SLUG}" 2>/dev/null)
+if [[ -n "$REMAINING" ]]; then
+  docker rm -f $REMAINING 2>/dev/null
+  echo "✓ Force-removed remaining Docker containers"
+fi
+
+# Phase 3: Remove Docker volumes by project name pattern
+docker volume ls -q 2>/dev/null | grep "wt.*${SLUG}" | xargs docker volume rm 2>/dev/null
+# Also try the compose project name format
+docker volume ls -q 2>/dev/null | grep "wt-${SLUG}" | xargs docker volume rm 2>/dev/null
+```
+
+### 5c: Remove FE worktree
+```bash
+if [[ -n "$FE_WORKTREE" ]]; then
+  cd "$FE_DIR"
+  git worktree remove --force "$FE_WORKTREE" 2>&1
+  git worktree prune
+  echo "✓ Removed FE worktree"
+fi
+```
+
+### 5d: Remove BE worktree
+```bash
+if [[ -n "$BE_WORKTREE" ]]; then
+  cd "$BE_DIR"
+  # Docker may have created files owned by root — force remove the directory first
+  rm -rf "$BE_WORKTREE" 2>/dev/null
+  git worktree prune
+  echo "✓ Removed BE worktree"
+fi
+```
+
+### 5e: Delete local branches
+```bash
+if [[ -n "$FE_LOCAL_BRANCH" ]]; then
+  git -C "$FE_DIR" branch -D "<branch>" 2>&1
+  echo "✓ Deleted FE local branch"
+fi
+if [[ -n "$BE_LOCAL_BRANCH" ]]; then
+  git -C "$BE_DIR" branch -D "<branch>" 2>&1
+  echo "✓ Deleted BE local branch"
+fi
+```
+
+### 5f: Delete remote branches (only if PR was merged)
+```bash
+# FE
+if [[ "$FE_PR_STATE" == "MERGED" ]] && [[ -n "$FE_REMOTE_BRANCH" ]]; then
+  git -C "$FE_DIR" push origin --delete "<branch>" 2>/dev/null \
+    && echo "✓ Deleted FE remote branch" \
+    || echo "ℹ FE remote branch already deleted"
+fi
+# BE
+if [[ "$BE_PR_STATE" == "MERGED" ]] && [[ -n "$BE_REMOTE_BRANCH" ]]; then
+  git -C "$BE_DIR" push origin --delete "<branch>" 2>/dev/null \
+    && echo "✓ Deleted BE remote branch" \
+    || echo "ℹ BE remote branch already deleted"
+fi
+```
+
+### 5g: Prune remote refs
+```bash
+git -C "$FE_DIR" remote prune origin 2>/dev/null
+git -C "$BE_DIR" remote prune origin 2>/dev/null
+```
+
+## Step 6: Report
+
+Print the final cleanup report:
+
+```
+Cleanup Complete
+═════════════════
+
+FE (<FE_GITHUB_REPO>):
+  <✓/ℹ for each action taken or skipped>
+
+BE (<BE_GITHUB_REPO>):
+  <✓/ℹ for each action taken or skipped>
+```
+
+## Edge Case Handling
+
+| Scenario | Action |
+|----------|--------|
+| Worktree has uncommitted changes | Show dirty files in summary, default to Abort |
+| Docker teardown fails (permission) | Log error, suggest manual `rm -rf` + `docker compose down -v` |
+| Branch doesn't exist locally | Skip with `ℹ` note |
+| Remote branch already deleted | Skip with `ℹ` note (don't error) |
+| No worktree found for branch | Skip with `ℹ` note, still clean branches |
+| Only one repo has artifacts | Clean what exists, report the other as "nothing to clean" |
+| Running from inside the worktree being deleted | `cd` to repo root first before removing |
+| Branch name has `#` characters | Sanitize for Docker slug, use raw name for git ops |
+
+## Notes
+
+- Always `cd` to repo root before `git worktree remove` (can't remove the worktree you're standing in)
+- BE worktrees may have Docker-owned files — use `rm -rf` before `git worktree prune` rather than `git worktree remove`
+- Remote branch deletion is idempotent — GitHub's auto-delete may have already removed it
+- The `lsof` port scan only checks common worktree ports (4200-4205, 1112) — if the user served on a custom port, it won't be detected (acceptable tradeoff)

package/plugins/reservine-dx/commands/commit.md

@@ -0,0 +1,118 @@
+# Claude Command: Commit
+
+When this command is invoked, you MUST spawn a sub-agent to handle all commit work. Do NOT run any git commands yourself — delegate everything.
+
+## Instructions
+
+1. Spawn a single `general-purpose` sub-agent with `mode: "auto"` using the prompt below
+2. Pass through any user arguments (e.g. `$ARGUMENTS`) into the agent prompt where indicated
+3. When the agent returns, relay its summary to the user verbatim — do NOT add your own commentary
+
+## Agent Prompt
+
+Use this as the agent's prompt (replace `{{ARGUMENTS}}` with `$ARGUMENTS`):
+
+---
+
+You are a commit assistant. Your job is to create well-formatted git commits.
+
+**User arguments:** `{{ARGUMENTS}}`
+
+## Steps
+
+### 1. Detect stack & pre-commit checks
+
+**First, detect the stack** by checking files in the working directory:
+
+```bash
+if [[ -f "angular.json" ]] || [[ -f "nx.json" ]]; then
+  STACK="angular"
+elif [[ -f "artisan" ]] || [[ -f "composer.json" ]]; then
+  STACK="laravel"
+fi
+```
+
+**Then, unless the user passed `--no-verify`, run stack-specific checks:**
+
+**Angular (FE):**
+- `nx lint reservine` — lint check
+- `bun run build:reservine:prod` — production build
+
+**Laravel (BE):**
+- `vendor/bin/pint --test` — code style check
+- `vendor/bin/phpstan analyze <changed-php-files> --memory-limit=512M` — static analysis on changed files only
+
+To get the changed PHP files for PHPStan:
+```bash
+git diff --cached --name-only --diff-filter=ACMR -- '*.php' | tr '\n' ' '
+```
+If no PHP files are staged, skip PHPStan.
+
+**Unknown stack:** Skip pre-commit checks with a warning.
+
+If any check fails, report the failure and stop. Do NOT proceed to commit.
+
+If the user passed `--no-verify`, skip all checks entirely.
+
+### 2. Gather context
+
+Run these in parallel:
+- `git status` (to see staged/unstaged/untracked files — never use `-uall`)
+- `git diff --cached` and `git diff` (to see all changes)
+- `git log --oneline -10` (to see recent commit style and detect task IDs)
+
+### 3. Stage files
+
+- If files are already staged, use only those
+- If nothing is staged, run `git add` for all modified and new files (prefer specific filenames over `git add -A`)
+- NEVER stage files that look like secrets (`.env`, credentials, tokens)
+
+### 4. Analyze changes
+
+Review the staged diff. Determine:
+- What type of change this is (feat, fix, docs, style, refactor, perf, test, chore, ci, revert, wip)
+- Whether a task ID can be inferred from the branch name or recent commits
+- Whether the changes should be split into multiple commits (different concerns, different types, different logical groups)
+
+### 5. Commit
+
+For each logical commit:
+1. Stage only the relevant files for that commit
+2. Create the commit with the format below
+3. Use a HEREDOC for the message to preserve formatting
+
+**Commit message format:**
+
+With task ID: `[TASK_ID] - type(scope): description`
+Without task ID: `type(scope): description`
+
+Scope is optional — use it when changes are clearly scoped to a module/area.
+
+Task ID patterns to detect:
+- Branch name like `feat/something-123` or `fix/PROJ-456` → extract the ID
+- Recent commits with `[#123]` or `[PROJ-123]` → reuse the pattern
+- If no ID is apparent, omit it
+
+Rules:
+- Present tense, imperative mood ("add" not "added")
+- First line under 72 characters (excluding task ID)
+- Focus on "why" not "what"
+- Each commit should be atomic — one logical change
+
+### 6. Verify
+
+Run `git status` after committing to confirm success.
+
+### 7. Return summary
+
+Return a concise summary in this format:
+
+```
+Committed N change(s):
+- <commit hash short> <commit message>
+- <commit hash short> <commit message>
+
+Files: <number> changed, <insertions> insertions(+), <deletions> deletions(-)
+```
+
+If the commit was split into multiple commits, list each one. Keep it brief.