claude-code-templates 1.21.12 → 1.21.14

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

@@ -0,0 +1,293 @@
+---
+allowed-tools: Bash(gh:*), Read, Grep, TodoWrite, Edit, MultiEdit
+argument-hint: [pr-number] | --analyze-only | --preview | --priority high|medium|low
+description: Transform Gemini Code Assist PR reviews into prioritized TodoLists with automated execution
+model: claude-sonnet-4-5-20250929
+---
+
+# Gemini PR Review Automation
+
+## Why This Command Exists
+
+**The Problem**: Gemini Code Assist provides free, automated PR reviews on GitHub. But AI-generated reviews often get ignored because they lack the urgency of human feedback.
+
+**The Pain Point**: Manually asking Claude Code to:
+1. "Analyze PR #42's Gemini review"
+2. "Prioritize the issues"
+3. "Create a TodoList"
+4. "Start working on them"
+
+...gets tedious fast.
+
+**The Solution**: One command that automatically fetches Gemini's review, analyzes severity, creates prioritized TodoLists, and optionally starts execution.
+
+## What Makes This Different
+
+| | Code Analysis | Code Improvement | Gemini Review |
+|---|---|---|---|
+| **Trigger** | When you want analysis | When you want improvements | **When Gemini already reviewed** |
+| **Input** | Local codebase | Local codebase | **GitHub PR's Gemini comments** |
+| **Purpose** | General analysis | General improvements | **Convert AI review → actionable TODOs** |
+| **Output** | Analysis report | Applied improvements | **TodoList + Priority + Execution** |
+
+## Triggers
+- PR has Gemini Code Assist review comments waiting to be addressed
+- Need to convert AI feedback into structured action items
+- Want to systematically process automated review feedback
+- Reduce manual context switching between GitHub and development
+
+## Usage
+```bash
+/gemini-review [pr-number] [--analyze-only] [--preview] [--priority high|medium|low]
+```
+
+## Behavioral Flow
+1. **Fetch**: Retrieve PR details and Gemini review comments using GitHub CLI
+2. **Analyze**: Parse and categorize review comments by type and severity
+3. **Prioritize**: Assess each comment for refactoring necessity and impact
+4. **TodoList**: Generate structured TodoList with priority ordering
+5. **Execute**: (Optional) Start working on high-priority items with user confirmation
+
+Key behaviors:
+- Intelligent comment categorization (critical, improvement, suggestion, style)
+- Impact assessment for each review item with effort estimation
+- Automatic TodoList creation with priority matrix (must-fix, should-fix, nice-to-have)
+- Code location mapping and dependency analysis
+- Implementation strategy with phased approach
+
+## Tool Coordination
+- **Bash**: GitHub CLI operations for PR and review data fetching
+- **Sequential Thinking**: Multi-step reasoning for complex refactoring decisions
+- **Grep**: Code pattern analysis and issue location identification
+- **Read**: Source code inspection for context understanding
+- **TodoWrite**: Automatic TodoList generation with priorities
+- **Edit/MultiEdit**: Code modifications when executing fixes
+
+## Key Patterns
+- **Review Parsing**: Gemini comments → structured analysis data
+- **Severity Classification**: Comment type → priority level assignment (Must-fix/Should-fix/Nice-to-have/Skip)
+- **TodoList Generation**: Analysis results → TodoWrite with prioritized items
+- **Impact Analysis**: Code changes → ripple effect assessment
+- **Execution Planning**: Strategy → actionable implementation steps
+
+## Examples
+
+### Analyze Current Branch's PR
+```bash
+/gemini-review
+# Automatically detects current branch's PR
+# Generates prioritized TodoList from Gemini review
+# Ready to execute after user confirmation
+```
+
+### Analyze Specific PR
+```bash
+/gemini-review 42
+# Analyzes Gemini review comments on PR #42
+# Creates prioritized TodoList with effort estimates
+```
+
+### Preview Mode (Safe Execution)
+```bash
+/gemini-review --preview
+# Shows what would be fixed without applying changes
+# Creates TodoList for manual execution
+# Allows review before implementation
+```
+
+## Real Workflow Example
+
+**Before (Manual, Tedious)**:
+```bash
+1. Open GitHub PR page
+2. Read Gemini review (often skipped because "AI generated")
+3. Tell Claude: "Analyze PR #42 Gemini review"
+4. Tell Claude: "Prioritize these issues"
+5. Tell Claude: "Create TodoList"
+6. Tell Claude: "Start working on them"
+```
+
+**After (Automated)**:
+```bash
+/gemini-review 42
+# → TodoList automatically created
+# → Priorities set based on severity
+# → Ready to execute immediately
+```
+
+## Analysis Output Structure
+
+### 1. Review Summary
+- Total comments count by severity
+- Severity distribution (critical/improvement/suggestion/style)
+- Common themes and patterns identified
+- Overall review sentiment and key focus areas
+- Estimated total effort required
+
+### 2. Categorized Analysis
+For each review comment:
+- **Category**: Critical | Improvement | Suggestion | Style
+- **Location**: File path and line numbers with context
+- **Issue**: Description of the problem from Gemini
+- **Impact**: Potential consequences if unaddressed
+- **Decision**: Must-fix | Should-fix | Nice-to-have | Skip
+- **Reasoning**: Why this priority was assigned
+- **Effort**: Estimated implementation time (Small/Medium/Large)
+
+### 3. TodoList Generation
+
+**Automatically creates TodoList with user confirmation before execution**
+
+```
+High Priority (Must-Fix):
+✓ Fix SQL injection in auth.js:45 (15 min)
+✓ Remove exposed API key in config.js:12 (5 min)
+
+Medium Priority (Should-Fix):
+○ Refactor UserService complexity (45 min)
+○ Add error handling to payment flow (30 min)
+
+Low Priority (Nice-to-Have):
+○ Update JSDoc comments (20 min)
+○ Rename variable for clarity (5 min)
+
+Skipped:
+- Style suggestion conflicts with project standards
+- Already addressed in different approach
+```
+
+*Note: User reviews and confirms TodoList before any code modifications are made*
+
+### 4. Execution Plan
+- **Phase 1 - Critical Fixes**: Security and breaking issues (immediate)
+- **Phase 2 - Important Improvements**: Maintainability and performance (same PR)
+- **Phase 3 - Optional Enhancements**: Style and documentation (future PR)
+- **Dependencies**: Order of implementation based on code dependencies
+- **Testing Strategy**: Required test updates for each phase
+
+### 5. Decision Record
+- **Accepted Changes**: What will be implemented and why
+- **Deferred Changes**: What will be addressed in future iterations
+- **Rejected Changes**: What won't be implemented and reasoning
+- **Trade-offs**: Analyzed costs vs. benefits for each decision
+
+## Boundaries
+
+**Will:**
+- Fetch and analyze Gemini Code Assist review comments from GitHub PRs
+- Categorize and prioritize review feedback systematically
+- Generate TodoLists with priority ordering and effort estimates
+- Provide decision reasoning and trade-off analysis
+- Map review comments to specific code locations
+- Execute fixes with user confirmation in preview mode
+
+**Will Not:**
+- Automatically implement changes without user review (unless explicitly requested)
+- Dismiss Gemini suggestions without analysis and documentation
+- Make architectural decisions without considering project context
+- Modify code outside the scope of review comments
+- Work with non-Gemini review systems (GitHub Copilot, CodeRabbit, etc.)
+
+## Decision Criteria
+
+### Must-Fix (Critical) - High Priority
+- Security vulnerabilities and data exposure
+- Data integrity issues and potential corruption
+- Breaking changes or runtime errors
+- Critical performance problems (>100ms delay, memory leaks)
+- Violations of core architecture principles
+
+### Should-Fix (Improvement) - Medium Priority
+- Code maintainability issues and technical debt
+- Moderate performance improvements (10-100ms gains)
+- Important best practice violations
+- Significant readability and documentation gaps
+- Error handling and resilience improvements
+
+### Nice-to-Have (Suggestion) - Low Priority
+- Code style improvements and formatting
+- Minor optimizations (<10ms gains)
+- Optional refactoring opportunities
+- Enhanced error messages and logging
+- Additional code comments and documentation
+
+### Skip (Not Applicable)
+- Conflicts with established project standards
+- Out of scope for current iteration
+- Low ROI improvements (high effort, low impact)
+- Overly opinionated suggestions without clear benefit
+- Already addressed by other means or different approach
+
+## Integration with Git Workflow
+
+### Recommended Flow
+```bash
+1. Create PR → Gemini reviews automatically
+2. Run /gemini-review to generate TodoList
+3. Review TodoList priorities and adjust if needed
+4. Execute fixes systematically (Phase 1 → Phase 2 → Phase 3)
+5. Commit changes with conventional commit messages
+6. Update PR and re-request Gemini review if needed
+```
+
+### Commit Strategy
+- Group related refactoring changes by category
+- Use conventional commit messages referencing review items
+  - `fix(auth): resolve SQL injection vulnerability (Gemini PR#42)`
+  - `refactor(services): reduce UserService complexity (Gemini PR#42)`
+  - `docs: update JSDoc comments (Gemini PR#42)`
+- Create separate commits for critical vs. improvement changes
+- Document decision rationale in commit messages
+
+## Advanced Usage
+
+### Interactive Mode (Recommended for Complex Reviews)
+```
+/gemini-review --interactive
+# Step through each review comment with decision prompts
+# Allows manual priority adjustment
+# Shows code context for each issue
+```
+
+### Export Analysis
+```
+/gemini-review --export gemini-analysis.md
+# Export comprehensive analysis to markdown file
+# Useful for team review and documentation
+# Includes all decisions and reasoning
+```
+
+### Dry Run (No TodoList Creation)
+```
+/gemini-review --dry-run
+# Shows analysis and priorities without creating TodoList
+# Useful for understanding scope before committing
+# No changes to workflow state
+```
+
+## Tool Requirements
+- **GitHub CLI** (`gh`) installed and authenticated
+- **Repository** must have Gemini Code Assist configured as PR reviewer
+- **Current branch** must have associated PR or provide PR number explicitly
+
+## Setup Gemini Code Assist
+
+If you haven't set up Gemini Code Assist yet:
+
+1. Visit [Gemini Code Assist GitHub App](https://developers.google.com/gemini-code-assist/docs/set-up-code-assist-github)
+2. Install the app on your organization/account
+3. Select repositories for integration
+4. Gemini will automatically review PRs with `/gemini` tag or auto-review
+
+**Why Gemini?**
+- **Free**: No cost for automated PR reviews
+- **Comprehensive**: Covers security, performance, best practices
+- **GitHub Native**: Integrated directly into PR workflow
+- **Automated**: No manual review requests needed
+
+## Limitations
+
+- Only supports Gemini Code Assist reviews (not GitHub Copilot, CodeRabbit, etc.)
+- Requires GitHub CLI access and authentication
+- Analysis quality depends on Gemini review quality
+- Cannot modify reviews or re-trigger Gemini analysis

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`