claude-code-templates 1.20.3 → 1.21.1

package/cli-tool/components/commands/git-workflow/create-worktrees.md

@@ -0,0 +1,174 @@
+# Git Worktree Commands
+
+## Create Worktrees for All Open PRs
+
+This command fetches all open pull requests using GitHub CLI, then creates a git worktree for each PR's branch in the `./tree/<BRANCH_NAME>` directory.
+
+```bash
+# Ensure GitHub CLI is installed and authenticated
+gh auth status || (echo "Please run 'gh auth login' first" && exit 1)
+
+# Create the tree directory if it doesn't exist
+mkdir -p ./tree
+
+# List all open PRs and create worktrees for each branch
+gh pr list --json headRefName --jq '.[].headRefName' | while read branch; do
+  # Handle branch names with slashes (like "feature/foo")
+  branch_path="./tree/${branch}"
+  
+  # For branches with slashes, create the directory structure
+  if [[ "$branch" == */* ]]; then
+    dir_path=$(dirname "$branch_path")
+    mkdir -p "$dir_path"
+  fi
+
+  # Check if worktree already exists
+  if [ ! -d "$branch_path" ]; then
+    echo "Creating worktree for $branch"
+    git worktree add "$branch_path" "$branch"
+  else
+    echo "Worktree for $branch already exists"
+  fi
+done
+
+# Display all created worktrees
+echo "\nWorktree list:"
+git worktree list
+```
+
+### Example Output
+
+```
+Creating worktree for fix-bug-123
+HEAD is now at a1b2c3d Fix bug 123
+Creating worktree for feature/new-feature
+HEAD is now at e4f5g6h Add new feature
+Worktree for documentation-update already exists
+
+Worktree list:
+/path/to/repo                      abc1234 [main]
+/path/to/repo/tree/fix-bug-123     a1b2c3d [fix-bug-123]
+/path/to/repo/tree/feature/new-feature e4f5g6h [feature/new-feature]
+/path/to/repo/tree/documentation-update d5e6f7g [documentation-update]
+```
+
+### Cleanup Stale Worktrees (Optional)
+
+You can add this to remove stale worktrees for branches that no longer exist:
+
+```bash
+# Get current branches
+current_branches=$(git branch -a | grep -v HEAD | grep -v main | sed 's/^[ *]*//' | sed 's|remotes/origin/||' | sort | uniq)
+
+# Get existing worktrees (excluding main worktree)
+worktree_paths=$(git worktree list | tail -n +2 | awk '{print $1}')
+
+for path in $worktree_paths; do
+  # Extract branch name from path
+  branch_name=$(basename "$path")
+  
+  # Skip special cases
+  if [[ "$branch_name" == "main" ]]; then
+    continue
+  fi
+  
+  # Check if branch still exists
+  if ! echo "$current_branches" | grep -q "^$branch_name$"; then
+    echo "Removing stale worktree for deleted branch: $branch_name"
+    git worktree remove --force "$path"
+  fi
+done
+```
+
+## Create New Branch and Worktree
+
+This interactive command creates a new git branch and sets up a worktree for it:
+
+```bash
+#!/bin/bash
+
+# Ensure we're in a git repository
+if ! git rev-parse --is-inside-work-tree > /dev/null 2>&1; then
+  echo "Error: Not in a git repository"
+  exit 1
+fi
+
+# Get the repository root
+repo_root=$(git rev-parse --show-toplevel)
+
+# Prompt for branch name
+read -p "Enter new branch name: " branch_name
+
+# Validate branch name (basic validation)
+if [[ -z "$branch_name" ]]; then
+  echo "Error: Branch name cannot be empty"
+  exit 1
+fi
+
+if git show-ref --verify --quiet "refs/heads/$branch_name"; then
+  echo "Warning: Branch '$branch_name' already exists"
+  read -p "Do you want to use the existing branch? (y/n): " use_existing
+  if [[ "$use_existing" != "y" ]]; then
+    exit 1
+  fi
+fi
+
+# Create branch directory
+branch_path="$repo_root/tree/$branch_name"
+
+# Handle branch names with slashes (like "feature/foo")
+if [[ "$branch_name" == */* ]]; then
+  dir_path=$(dirname "$branch_path")
+  mkdir -p "$dir_path"
+fi
+
+# Make sure parent directory exists
+mkdir -p "$(dirname "$branch_path")"
+
+# Check if a worktree already exists
+if [ -d "$branch_path" ]; then
+  echo "Error: Worktree directory already exists: $branch_path"
+  exit 1
+fi
+
+# Create branch and worktree
+if git show-ref --verify --quiet "refs/heads/$branch_name"; then
+  # Branch exists, create worktree
+  echo "Creating worktree for existing branch '$branch_name'..."
+  git worktree add "$branch_path" "$branch_name"
+else
+  # Create new branch and worktree
+  echo "Creating new branch '$branch_name' and worktree..."
+  git worktree add -b "$branch_name" "$branch_path"
+fi
+
+echo "Success! New worktree created at: $branch_path"
+echo "To start working on this branch, run: cd $branch_path"
+```
+
+### Example Usage
+
+```
+$ ./create-branch-worktree.sh
+Enter new branch name: feature/user-authentication
+Creating new branch 'feature/user-authentication' and worktree...
+Preparing worktree (creating new branch 'feature/user-authentication')
+HEAD is now at abc1234 Previous commit message
+Success! New worktree created at: /path/to/repo/tree/feature/user-authentication
+To start working on this branch, run: cd /path/to/repo/tree/feature/user-authentication
+```
+
+### Creating a New Branch from a Different Base
+
+If you want to start your branch from a different base (not the current HEAD), you can modify the script:
+
+```bash
+read -p "Enter new branch name: " branch_name
+read -p "Enter base branch/commit (default: HEAD): " base_commit
+base_commit=${base_commit:-HEAD}
+
+# Then use the specified base when creating the worktree
+git worktree add -b "$branch_name" "$branch_path" "$base_commit"
+```
+
+This will allow you to specify any commit, tag, or branch name as the starting point for your new branch.

package/cli-tool/components/commands/git-workflow/fix-github-issue.md

@@ -0,0 +1,13 @@
+Please analyze and fix the GitHub issue: $ARGUMENTS.
+
+Follow these steps:
+
+1. Use `gh issue view` to get the issue details
+2. Understand the problem described in the issue
+3. Search the codebase for relevant files
+4. Implement the necessary changes to fix the issue
+5. Write and run tests to verify the fix
+6. Ensure code passes linting and type checking
+7. Create a descriptive commit message
+
+Remember to use the GitHub CLI (`gh`) for all GitHub-related tasks.

package/cli-tool/components/commands/git-workflow/git-bisect-helper.md

@@ -0,0 +1,261 @@
+---
+allowed-tools: Bash(git bisect:*), Bash(git log:*), Bash(git show:*), Bash(git checkout:*), Bash(npm:*), Bash(yarn:*), Bash(pnpm:*), Read, Edit, Grep
+argument-hint: [good-commit] [bad-commit] | --auto [test-command] | --reset | --continue
+description: Use PROACTIVELY to guide automated git bisect sessions for finding regression commits with smart test execution
+model: sonnet
+---
+
+# Git Bisect Helper & Automation
+
+Automated git bisect session to find regression commits: $ARGUMENTS
+
+## Current Repository State
+
+- Current branch: !`git branch --show-current`
+- Recent commits: !`git log --oneline -10`
+- Git status: !`git status --porcelain`
+- Bisect status: !`git bisect log 2>/dev/null || echo "No active bisect session"`
+- Available tags: !`git tag --sort=-version:refname | head -10`
+
+## Task
+
+Set up and manage an intelligent git bisect session to identify the exact commit that introduced a regression or bug.
+
+## Bisect Session Management
+
+### 1. Session Initialization
+- Analyze commit history to suggest good/bad commit candidates
+- Set up bisect session with appropriate range
+- Validate that the range actually contains the regression
+- Create backup branch before starting bisect
+
+### 2. Automatic Test Execution
+- Run specified test command at each bisect point
+- Interpret test results (exit codes, output patterns)
+- Automatically mark commits as good/bad based on test outcomes
+- Handle test environment setup/teardown
+
+### 3. Manual Verification Support
+- Provide clear instructions for manual testing at each step
+- Show relevant changes in current commit
+- Guide user through good/bad decision process
+- Maintain bisect log with detailed reasoning
+
+### 4. Smart Commit Analysis
+- Analyze commit messages for relevant keywords
+- Show file changes that might be related to the issue
+- Highlight suspicious patterns or large changes
+- Skip obviously unrelated commits when possible
+
+## Bisect Modes
+
+### Automatic Bisect (`--auto [test-command]`)
+```bash
+# Automatically bisect using test command
+/git-bisect-helper --auto "npm test"
+/git-bisect-helper --auto "python -m pytest tests/test_regression.py"
+/git-bisect-helper --auto "./scripts/check-performance.sh"
+```
+
+**Process:**
+1. Run test command at each bisect point
+2. Mark commit as good (exit code 0) or bad (non-zero)
+3. Continue until regression commit is found
+4. Provide detailed report of findings
+
+### Manual Guided Bisect
+```bash
+# Interactive bisect with guidance
+/git-bisect-helper v1.2.0 HEAD
+/git-bisect-helper abc123 def456
+```
+
+**Process:**
+1. Show current commit details and changes
+2. Provide testing suggestions
+3. Wait for user input (good/bad)
+4. Continue to next bisect point
+5. Offer insights about current commit
+
+### Continue Existing Session (`--continue`)
+```bash
+# Resume interrupted bisect session
+/git-bisect-helper --continue
+```
+
+**Process:**
+1. Analyze current bisect state
+2. Show progress and remaining steps
+3. Continue with appropriate mode
+4. Provide context from previous steps
+
+### Reset Session (`--reset`)
+```bash
+# Clean up and reset bisect session
+/git-bisect-helper --reset
+```
+
+**Process:**
+1. End current bisect session
+2. Return to original branch
+3. Clean up temporary files
+4. Provide session summary
+
+## Intelligent Test Execution
+
+### Test Environment Detection
+- **Node.js**: Detect package.json and run appropriate package manager
+- **Python**: Identify requirements.txt, setup.py, pyproject.toml
+- **Ruby**: Look for Gemfile and use bundler
+- **Java**: Detect Maven (pom.xml) or Gradle (build.gradle)
+- **Go**: Identify go.mod and use go test
+- **Rust**: Detect Cargo.toml and use cargo test
+
+### Build System Integration
+- Run build process before testing if needed
+- Handle dependency installation for older commits
+- Manage environment variable requirements
+- Skip build for commits that don't compile (mark as bad)
+
+### Test Result Interpretation
+- Parse test output for meaningful error patterns
+- Distinguish between test failures and environment issues
+- Handle flaky tests with retry logic
+- Provide confidence levels for automated decisions
+
+## Commit Analysis Features
+
+### Change Impact Assessment
+```bash
+# Analyze current bisect commit
+Files changed: !`git show --name-only --pretty="" HEAD`
+Commit message: !`git log -1 --pretty=format:"%s"`
+Author and date: !`git log -1 --pretty=format:"%an (%ar)"`
+```
+
+### Regression Pattern Detection
+- Identify commits touching critical areas
+- Flag commits with suspicious change patterns
+- Highlight performance-related modifications
+- Detect dependency or configuration changes
+
+### Context Preservation
+- Maintain detailed log of bisect decisions
+- Record reasoning for each good/bad marking
+- Save test outputs for later analysis
+- Document environmental factors
+
+## Advanced Bisect Strategies
+
+### Skip Strategy for Build Issues
+- Automatically skip commits that don't compile
+- Handle dependency version conflicts
+- Skip commits with known build system issues
+- Focus bisect on functional commits only
+
+### Performance Regression Detection
+- Use performance benchmarks instead of pass/fail tests
+- Set acceptable performance thresholds
+- Track performance trends across commits
+- Identify performance cliff points
+
+### Multi-criteria Bisecting
+- Test multiple aspects simultaneously
+- Handle cases where good/bad isn't binary
+- Support complex regression scenarios
+- Provide weighted decision making
+
+## Bisect Session Reporting
+
+### Progress Tracking
+```
+Bisect Progress:
+🎯 Target: Find regression in user authentication
+📊 Commits remaining: ~4 (out of 127)
+⏱️  Estimated time: 8 minutes
+🔍 Current commit: abc123 - "refactor auth middleware"
+```
+
+### Final Report
+```
+🎉 Regression Found!
+
+Bad Commit: def456
+Author: John Doe
+Date: 2024-01-15 14:30:00
+Message: "optimize database queries"
+
+Files Changed:
+- src/auth/database.js
+- src/middleware/auth.js
+- tests/auth.test.js
+
+Bisect Log: 15 steps, 3 manual verifications
+Total Time: 12 minutes
+
+Recovery Commands:
+git revert def456                    # Revert the problematic commit
+git cherry-pick def456^..def456~1    # Cherry-pick the good parts
+```
+
+## Integration with Development Workflow
+
+### CI/CD Integration
+- Use same test commands as CI pipeline
+- Respect CI environment variables
+- Handle containerized test environments
+- Integrate with existing quality gates
+
+### Team Collaboration
+- Share bisect sessions with team members
+- Document findings in issue tracking
+- Create reproducible bisect scripts
+- Establish team bisect best practices
+
+### Debugging Enhancement
+- Generate debug reports for problematic commits
+- Create minimal reproduction cases
+- Suggest fix approaches based on regression type
+- Link to relevant documentation or similar issues
+
+## Safety and Recovery
+
+### Session Backup
+- Create backup branch before starting
+- Save original HEAD position
+- Maintain recovery information
+- Handle interrupted sessions gracefully
+
+### Error Handling
+- Recover from corrupted bisect state
+- Handle repository state conflicts
+- Manage disk space issues during long bisects
+- Provide clear error messages and solutions
+
+## Example Workflows
+
+### Performance Regression
+```bash
+# Find when tests became slower
+/git-bisect-helper --auto "timeout 30s npm test"
+```
+
+### Feature Regression  
+```bash
+# Find when feature X broke
+/git-bisect-helper --auto "./test-feature-x.sh"
+```
+
+### Build Regression
+```bash
+# Find when build started failing
+/git-bisect-helper --auto "npm run build"
+```
+
+### Manual Investigation
+```bash
+# Interactive bisect for complex issues
+/git-bisect-helper v2.1.0 HEAD
+```
+
+The bisect helper provides intelligent automation while maintaining full control over the debugging process, making regression hunting efficient and systematic.

package/cli-tool/components/commands/git-workflow/pr-review.md

@@ -0,0 +1,76 @@
+# PR Review
+
+**PR Link/Number**: $ARGUMENTS
+
+> **Instructions**: Execute each task in the order given to conduct a thorough code review.  Update GitHub with this review.
+> **Important**: The future is now—any improvements or “future” recommendations must be addressed **immediately**.
+
+---
+
+## Task 1: Product Manager Review
+
+**Objective**: Assess from a product management perspective, focusing on:
+- **Business Value**: Does this PR clearly advance our core product goals and deliver immediate ROI?
+- **User Experience**: Is the change intuitive and delightful for users right now? If not, make fixes immediately.
+- **Strategic Alignment**: Does the PR align with current (and long-term, i.e., now) strategic objectives?
+
+**Action**: Provide clear directives on how to ensure maximum user and business impact. All “future” suggestions must be implemented now.
+
+---
+
+## Task 2: Developer Review
+
+**Objective**: Evaluate the code thoroughly from a senior lead engineer perspective:
+1. **Code Quality & Maintainability**: Is the code structured for readability and easy maintenance? If not, refactor now.
+2. **Performance & Scalability**: Will these changes operate efficiently at scale? If not, optimize immediately.
+3. **Best Practices & Standards**: Note any deviation from coding standards and correct it now.
+
+**Action**: Leave a concise yet complete review comment, ensuring all improvements happen immediately—no deferrals.
+
+---
+
+## Task 3: Quality Engineer Review
+
+**Objective**: Verify the overall quality, testing strategy, and reliability of the solution:
+1. **Test Coverage**: Are there sufficient tests (unit, integration, E2E)? If not, add them now.
+2. **Potential Bugs & Edge Cases**: Have all edge cases been considered? If not, address them immediately.
+3. **Regression Risk**: Confirm changes don’t undermine existing functionality. If risk is identified, mitigate now with additional checks or tests.
+
+**Action**: Provide a detailed QA assessment, insisting any “future” improvements be completed right away.
+
+---
+
+## Task 4: Security Engineer Review
+
+**Objective**: Ensure robust security practices and compliance:
+1. **Vulnerabilities**: Could these changes introduce security vulnerabilities? If so, fix them right away.
+2. **Data Handling**: Are we properly protecting sensitive data (e.g., encryption, sanitization)? Address all gaps now.
+3. **Compliance**: Confirm alignment with any relevant security or privacy standards (e.g., OWASP, GDPR, HIPAA). Implement missing requirements immediately.
+
+**Action**: Provide a security assessment. Any recommended fixes typically scheduled for “later” must be addressed now.
+
+---
+
+## Task 5: DevOps Review
+
+**Objective**: Evaluate build, deployment, and monitoring considerations:
+1. **CI/CD Pipeline**: Validate that the PR integrates smoothly with existing build/test/deploy processes. If not, fix it now.
+2. **Infrastructure & Configuration**: Check whether the code changes require immediate updates to infrastructure or configs.
+3. **Monitoring & Alerts**: Identify new monitoring needs or potential improvements and implement them immediately.
+
+**Action**: Provide a DevOps-centric review, insisting that any improvements or tweaks be executed now.
+
+---
+
+## Task 6: UI/UX Designer Review
+
+**Objective**: Ensure optimal user-centric design:
+1. **Visual Consistency**: Confirm adherence to brand/design guidelines. If not, adjust now.
+2. **Usability & Accessibility**: Validate that the UI is intuitive and compliant with accessibility standards. Make any corrections immediately.
+3. **Interaction Flow**: Assess whether the user flow is seamless. If friction exists, refine now.
+
+**Action**: Provide a detailed UI/UX evaluation. Any enhancements typically set for “later” must be done immediately.
+
+---
+
+**End of PR Review**

package/cli-tool/components/commands/git-workflow/update-branch-name.md

@@ -0,0 +1,9 @@
+# Update Branch Name
+
+Follow these steps to update the current branch name:
+
+1. Check differences between current branch and main branch HEAD using `git diff main...HEAD`
+2. Analyze the changed files to understand what work is being done
+3. Determine an appropriate descriptive branch name based on the changes
+4. Update the current branch name using `git branch -m [new-branch-name]`
+5. Verify the branch name was updated with `git branch`