claude-code-templates 1.21.5 → 1.21.6

package/components/commands/utilities/architecture-scenario-explorer.md

@@ -0,0 +1,375 @@
+# Architecture Scenario Explorer
+
+Explore architectural decisions through systematic scenario analysis with trade-off evaluation and future-proofing assessment.
+
+## Instructions
+
+You are tasked with systematically exploring architectural decisions through comprehensive scenario modeling to optimize system design choices. Follow this approach: **$ARGUMENTS**
+
+### 1. Prerequisites Assessment
+
+**Critical Architecture Context Validation:**
+
+- **System Scope**: What system or component architecture are you designing?
+- **Scale Requirements**: What are the expected usage patterns and growth projections?
+- **Constraints**: What technical, business, or resource constraints apply?
+- **Timeline**: What is the implementation timeline and evolution roadmap?
+- **Success Criteria**: How will you measure architectural success?
+
+**If context is unclear, guide systematically:**
+
+```
+Missing System Scope:
+"What specific system architecture needs exploration?
+- New System Design: Greenfield application or service architecture
+- System Migration: Moving from legacy to modern architecture
+- Scaling Architecture: Expanding existing system capabilities
+- Integration Architecture: Connecting multiple systems and services
+- Platform Architecture: Building foundational infrastructure
+
+Please specify the system boundaries, key components, and primary functions."
+
+Missing Scale Requirements:
+"What are the expected system scale and usage patterns?
+- User Scale: Number of concurrent and total users
+- Data Scale: Volume, velocity, and variety of data processed
+- Transaction Scale: Requests per second, peak load patterns
+- Geographic Scale: Single region, multi-region, or global distribution
+- Growth Projections: Expected scaling timeline and magnitude"
+```
+
+### 2. Architecture Option Generation
+
+**Systematically identify architectural approaches:**
+
+#### Architecture Pattern Matrix
+```
+Architectural Approach Framework:
+
+Monolithic Patterns:
+- Layered Architecture: Traditional n-tier with clear separation
+- Modular Monolith: Well-bounded modules within single deployment
+- Plugin Architecture: Core system with extensible plugin ecosystem
+- Service-Oriented Monolith: Internal service boundaries with single deployment
+
+Distributed Patterns:
+- Microservices: Independent services with business capability alignment
+- Service Mesh: Microservices with infrastructure-level communication
+- Event-Driven: Asynchronous communication with event sourcing
+- CQRS/Event Sourcing: Command-query separation with event storage
+
+Hybrid Patterns:
+- Modular Microservices: Services grouped by business domain
+- Micro-Frontend: Frontend decomposition matching backend services
+- Strangler Fig: Gradual migration from monolith to distributed
+- API Gateway: Centralized entry point with backend service routing
+
+Cloud-Native Patterns:
+- Serverless: Function-based with cloud provider infrastructure
+- Container-Native: Kubernetes-first with cloud-native services
+- Multi-Cloud: Cloud-agnostic with portable infrastructure
+- Edge-First: Distributed computing with edge location optimization
+```
+
+#### Architecture Variation Specification
+```
+For each architectural option:
+
+Structural Characteristics:
+- Component Organization: [how system parts are structured and related]
+- Communication Patterns: [synchronous vs asynchronous, protocols, messaging]
+- Data Management: [database strategy, consistency model, storage patterns]
+- Deployment Model: [packaging, distribution, scaling, and operational approach]
+
+Quality Attributes:
+- Scalability Profile: [horizontal vs vertical scaling, bottleneck analysis]
+- Reliability Characteristics: [failure modes, recovery, fault tolerance]
+- Performance Expectations: [latency, throughput, resource efficiency]
+- Security Model: [authentication, authorization, data protection, attack surface]
+
+Implementation Considerations:
+- Technology Stack: [languages, frameworks, databases, infrastructure]
+- Team Structure Fit: [Conway's Law implications, team capabilities]
+- Development Process: [build, test, deploy, monitor workflows]
+- Evolution Strategy: [how architecture can grow and change over time]
+```
+
+### 3. Scenario Framework Development
+
+**Create comprehensive architectural testing scenarios:**
+
+#### Usage Scenario Matrix
+```
+Multi-Dimensional Scenario Framework:
+
+Load Scenarios:
+- Normal Operation: Typical daily usage patterns and traffic
+- Peak Load: Maximum expected concurrent usage and transaction volume
+- Stress Testing: Beyond normal capacity to identify breaking points
+- Spike Testing: Sudden traffic increases and burst handling
+
+Growth Scenarios:
+- Linear Growth: Steady user and data volume increases over time
+- Exponential Growth: Rapid scaling requirements and viral adoption
+- Geographic Expansion: Multi-region deployment and global scaling
+- Feature Expansion: New capabilities and service additions
+
+Failure Scenarios:
+- Component Failures: Individual service or database outages
+- Infrastructure Failures: Network, storage, or compute disruptions
+- Cascade Failures: Failure propagation and system-wide impacts
+- Disaster Recovery: Major outage recovery and business continuity
+
+Evolution Scenarios:
+- Technology Migration: Framework, language, or platform changes
+- Business Model Changes: New revenue streams or service offerings
+- Regulatory Changes: Compliance requirements and data protection
+- Competitive Response: Market pressures and feature requirements
+```
+
+#### Scenario Impact Modeling
+- Performance impact under each scenario type
+- Cost implications for infrastructure and operations
+- Development velocity and team productivity effects
+- Risk assessment and mitigation requirements
+
+### 4. Trade-off Analysis Framework
+
+**Systematic evaluation of architectural trade-offs:**
+
+#### Quality Attribute Trade-off Matrix
+```
+Architecture Quality Assessment:
+
+Performance Trade-offs:
+- Latency vs Throughput: Response time vs maximum concurrent processing
+- Memory vs CPU: Resource utilization optimization strategies
+- Consistency vs Availability: CAP theorem implications and choices
+- Caching vs Freshness: Data staleness vs response speed
+
+Scalability Trade-offs:
+- Horizontal vs Vertical: Infrastructure scaling approach and economics
+- Stateless vs Stateful: Session management and performance implications
+- Synchronous vs Asynchronous: Communication complexity vs performance
+- Coupling vs Autonomy: Service independence vs operational overhead
+
+Development Trade-offs:
+- Development Speed vs Runtime Performance: Optimization time investment
+- Type Safety vs Flexibility: Compile-time vs runtime error handling
+- Code Reuse vs Service Independence: Shared libraries vs duplication
+- Testing Complexity vs System Reliability: Test investment vs quality
+
+Operational Trade-offs:
+- Complexity vs Control: Managed services vs self-managed infrastructure
+- Monitoring vs Privacy: Observability vs data protection
+- Automation vs Flexibility: Standardization vs customization
+- Cost vs Performance: Infrastructure spending vs response times
+```
+
+#### Decision Matrix Construction
+- Weight assignment for different quality attributes based on business priorities
+- Scoring methodology for each architecture option across quality dimensions
+- Sensitivity analysis for weight and score variations
+- Pareto frontier identification for non-dominated solutions
+
+### 5. Future-Proofing Assessment
+
+**Evaluate architectural adaptability and evolution potential:**
+
+#### Technology Evolution Scenarios
+```
+Future-Proofing Analysis Framework:
+
+Technology Trend Integration:
+- AI/ML Integration: Machine learning capability embedding and scaling
+- Edge Computing: Distributed processing and low-latency requirements
+- Quantum Computing: Post-quantum cryptography and computational impacts
+- Blockchain/DLT: Distributed ledger integration and trust mechanisms
+
+Market Evolution Preparation:
+- Business Model Flexibility: Subscription, marketplace, platform pivots
+- Global Expansion: Multi-tenant, multi-region, multi-regulatory compliance
+- Customer Expectation Evolution: Real-time, personalized, omnichannel experiences
+- Competitive Landscape Changes: Feature parity and differentiation requirements
+
+Regulatory Future-Proofing:
+- Privacy Regulation: GDPR, CCPA evolution and global privacy requirements
+- Security Standards: Zero-trust, compliance framework evolution
+- Data Sovereignty: Geographic data residency and cross-border restrictions
+- Accessibility Requirements: Inclusive design and assistive technology support
+```
+
+#### Adaptability Scoring
+- Architecture flexibility for requirement changes
+- Technology migration feasibility and cost
+- Team skill evolution and learning curve management
+- Investment protection and technical debt management
+
+### 6. Architecture Simulation Engine
+
+**Model architectural behavior under different scenarios:**
+
+#### Performance Simulation Framework
+```
+Multi-Layer Architecture Simulation:
+
+Component-Level Simulation:
+- Individual service performance characteristics and resource usage
+- Database query performance and optimization opportunities
+- Cache hit ratios and invalidation strategies
+- Message queue throughput and latency patterns
+
+Integration-Level Simulation:
+- Service-to-service communication overhead and optimization
+- API gateway performance and routing efficiency
+- Load balancer distribution and health checking
+- Circuit breaker and retry mechanism effectiveness
+
+System-Level Simulation:
+- End-to-end request flow and user experience
+- Peak load distribution and resource allocation
+- Failure propagation and recovery patterns
+- Monitoring and alerting system effectiveness
+
+Infrastructure-Level Simulation:
+- Cloud resource utilization and auto-scaling behavior
+- Network bandwidth and latency optimization
+- Storage performance and data consistency patterns
+- Security policy enforcement and performance impact
+```
+
+#### Cost Modeling Integration
+- Infrastructure cost estimation across different scenarios
+- Development and operational cost projection
+- Total cost of ownership analysis over multi-year timeline
+- Cost optimization opportunities and trade-off analysis
+
+### 7. Risk Assessment and Mitigation
+
+**Comprehensive architectural risk evaluation:**
+
+#### Technical Risk Framework
+```
+Architecture Risk Assessment:
+
+Implementation Risks:
+- Technology Maturity: New vs proven technology adoption risks
+- Complexity Management: System comprehension and debugging challenges
+- Integration Challenges: Third-party service dependencies and compatibility
+- Performance Uncertainty: Untested scaling and optimization requirements
+
+Operational Risks:
+- Deployment Complexity: Release management and rollback capabilities
+- Monitoring Gaps: Observability and troubleshooting limitations
+- Scaling Challenges: Auto-scaling reliability and cost control
+- Disaster Recovery: Backup, recovery, and business continuity planning
+
+Strategic Risks:
+- Technology Lock-in: Vendor dependency and migration flexibility
+- Skill Dependencies: Team expertise requirements and knowledge gaps
+- Evolution Constraints: Architecture modification and extension limitations
+- Competitive Disadvantage: Time-to-market and feature development speed
+```
+
+#### Risk Mitigation Strategy Development
+- Specific mitigation approaches for identified risks
+- Contingency planning and alternative architecture options
+- Early warning indicators and monitoring strategies
+- Risk acceptance criteria and stakeholder communication
+
+### 8. Decision Framework and Recommendations
+
+**Generate systematic architectural guidance:**
+
+#### Architecture Decision Record (ADR) Format
+```
+## Architecture Decision: [System Name] - [Decision Topic]
+
+### Context and Problem Statement
+- Business Requirements: [key functional and non-functional requirements]
+- Current Constraints: [technical, resource, and timeline limitations]
+- Decision Drivers: [factors influencing architectural choice]
+
+### Architecture Options Considered
+
+#### Option 1: [Architecture Name]
+- Description: [architectural approach and key characteristics]
+- Pros: [advantages and benefits]
+- Cons: [disadvantages and risks]
+- Trade-offs: [specific quality attribute impacts]
+
+[Repeat for each option]
+
+### Decision Outcome
+- Selected Architecture: [chosen approach with rationale]
+- Decision Rationale: [why this option was selected]
+- Expected Benefits: [anticipated advantages and success metrics]
+- Accepted Trade-offs: [compromises and mitigation strategies]
+
+### Implementation Strategy
+- Phase 1 (Immediate): [initial implementation steps and validation]
+- Phase 2 (Short-term): [core system development and integration]
+- Phase 3 (Medium-term): [optimization and scaling implementation]
+- Phase 4 (Long-term): [evolution and enhancement roadmap]
+
+### Validation and Success Criteria
+- Performance Metrics: [specific KPIs and acceptable ranges]
+- Quality Gates: [architectural compliance and validation checkpoints]
+- Review Schedule: [when to reassess architectural decisions]
+- Adaptation Triggers: [conditions requiring architectural modification]
+
+### Risks and Mitigation
+- High-Priority Risks: [most significant concerns and responses]
+- Monitoring Strategy: [early warning systems and health checks]
+- Contingency Plans: [alternative approaches if problems arise]
+- Learning and Adaptation: [how to incorporate feedback and improve]
+```
+
+### 9. Continuous Architecture Evolution
+
+**Establish ongoing architectural assessment and improvement:**
+
+#### Architecture Health Monitoring
+- Performance metric tracking against architectural predictions
+- Technical debt accumulation and remediation planning
+- Team productivity and development velocity measurement
+- User satisfaction and business outcome correlation
+
+#### Evolutionary Architecture Practices
+- Regular architecture review and fitness function evaluation
+- Incremental improvement identification and implementation
+- Technology trend assessment and adoption planning
+- Cross-team architecture knowledge sharing and standardization
+
+## Usage Examples
+
+```bash
+# Microservices migration planning
+/dev:architecture-scenario-explorer Evaluate monolith to microservices migration for e-commerce platform with 1M+ users
+
+# New system architecture design
+/dev:architecture-scenario-explorer Design architecture for real-time analytics platform handling 100k events/second
+
+# Scaling architecture assessment
+/dev:architecture-scenario-explorer Analyze architecture options for scaling social media platform from 10k to 1M daily active users
+
+# Technology modernization planning
+/dev:architecture-scenario-explorer Compare serverless vs container-native architectures for data processing pipeline modernization
+```
+
+## Quality Indicators
+
+- **Green**: Multiple architectures analyzed, comprehensive scenarios tested, validated trade-offs
+- **Yellow**: Some architectural options considered, basic scenario coverage, estimated trade-offs
+- **Red**: Single architecture focus, limited scenario analysis, unvalidated assumptions
+
+## Common Pitfalls to Avoid
+
+- Architecture astronauting: Over-engineering for theoretical rather than real requirements
+- Cargo cult architecture: Copying successful patterns without understanding context
+- Technology bias: Choosing architecture based on technology preferences rather than requirements
+- Premature optimization: Solving performance problems that don't exist yet
+- Scalability obsession: Over-optimizing for scale that may never materialize
+- Evolution blindness: Not planning for architectural change and growth
+
+Transform architectural decisions from opinion-based debates into systematic, evidence-driven choices through comprehensive scenario exploration and trade-off analysis.

package/components/commands/utilities/check-file.md

@@ -0,0 +1,53 @@
+# File Analysis Tool
+
+Perform comprehensive analysis of $ARGUMENTS to identify code quality issues, security vulnerabilities, and optimization opportunities.
+
+## Task
+
+I'll analyze the specified file and provide detailed insights on:
+
+1. Code quality metrics and maintainability
+2. Security vulnerabilities and best practices
+3. Performance bottlenecks and optimization opportunities
+4. Dependency usage and potential issues
+5. TypeScript/JavaScript specific patterns and improvements
+6. Test coverage and missing tests
+
+## Process
+
+I'll follow these steps:
+
+1. Read and parse the target file
+2. Analyze code structure and complexity
+3. Check for security vulnerabilities and anti-patterns  
+4. Evaluate performance implications
+5. Review dependency usage and imports
+6. Provide actionable recommendations for improvement
+
+## Analysis Areas
+
+### Code Quality
+- Cyclomatic complexity and maintainability metrics
+- Code duplication and refactoring opportunities
+- Naming conventions and code organization
+- TypeScript type safety and best practices
+
+### Security Assessment
+- Input validation and sanitization
+- Authentication and authorization patterns
+- Sensitive data exposure risks
+- Common vulnerability patterns (XSS, injection, etc.)
+
+### Performance Review
+- Bundle size impact and optimization opportunities
+- Runtime performance bottlenecks
+- Memory usage patterns
+- Lazy loading and code splitting opportunities
+
+### Best Practices
+- Framework-specific patterns (React, Vue, Angular)
+- Modern JavaScript/TypeScript features usage
+- Error handling and logging practices
+- Testing patterns and coverage gaps
+
+I'll provide specific, actionable recommendations tailored to your project's technology stack and architecture.

package/components/commands/utilities/clean-branches.md

@@ -0,0 +1,243 @@
+# Clean Branches Command
+
+Clean up merged and stale git branches
+
+## Instructions
+
+Follow this systematic approach to clean up git branches: **$ARGUMENTS**
+
+1. **Repository State Analysis**
+   - Check current branch and uncommitted changes
+   - List all local and remote branches
+   - Identify the main/master branch name
+   - Review recent branch activity and merge history
+
+   ```bash
+   # Check current status
+   git status
+   git branch -a
+   git remote -v
+   
+   # Check main branch name
+   git symbolic-ref refs/remotes/origin/HEAD | sed 's@^refs/remotes/origin/@@'
+   ```
+
+2. **Safety Precautions**
+   - Ensure working directory is clean
+   - Switch to main/master branch
+   - Pull latest changes from remote
+   - Create backup of current branch state if needed
+
+   ```bash
+   # Ensure clean state
+   git stash push -m "Backup before branch cleanup"
+   git checkout main  # or master
+   git pull origin main
+   ```
+
+3. **Identify Merged Branches**
+   - List branches that have been merged into main
+   - Exclude protected branches (main, master, develop)
+   - Check both local and remote merged branches
+   - Verify merge status to avoid accidental deletion
+
+   ```bash
+   # List merged local branches
+   git branch --merged main | grep -v "main\\|master\\|develop\\|\\*"
+   
+   # List merged remote branches
+   git branch -r --merged main | grep -v "main\\|master\\|develop\\|HEAD"
+   ```
+
+4. **Identify Stale Branches**
+   - Find branches with no recent activity
+   - Check last commit date for each branch
+   - Identify branches older than specified timeframe (e.g., 30 days)
+   - Consider branch naming patterns for feature/hotfix branches
+
+   ```bash
+   # List branches by last commit date
+   git for-each-ref --format='%(committerdate) %(authorname) %(refname)' --sort=committerdate refs/heads
+   
+   # Find branches older than 30 days
+   git for-each-ref --format='%(refname:short) %(committerdate)' refs/heads | awk '$2 < "'$(date -d '30 days ago' '+%Y-%m-%d')'"'
+   ```
+
+5. **Interactive Branch Review**
+   - Review each branch before deletion
+   - Check if branch has unmerged changes
+   - Verify branch purpose and status
+   - Ask for confirmation before deletion
+
+   ```bash
+   # Check for unmerged changes
+   git log main..branch-name --oneline
+   
+   # Show branch information
+   git show-branch branch-name main
+   ```
+
+6. **Protected Branch Configuration**
+   - Identify branches that should never be deleted
+   - Configure protection rules for important branches
+   - Document branch protection policies
+   - Set up automated protection for new repositories
+
+   ```bash
+   # Example protected branches
+   PROTECTED_BRANCHES=("main" "master" "develop" "staging" "production")
+   ```
+
+7. **Local Branch Cleanup**
+   - Delete merged local branches safely
+   - Remove stale feature branches
+   - Clean up tracking branches for deleted remotes
+   - Update local branch references
+
+   ```bash
+   # Delete merged branches (interactive)
+   git branch --merged main | grep -v "main\\|master\\|develop\\|\\*" | xargs -n 1 -p git branch -d
+   
+   # Force delete if needed (use with caution)
+   git branch -D branch-name
+   ```
+
+8. **Remote Branch Cleanup**
+   - Remove merged remote branches
+   - Clean up remote tracking references
+   - Delete obsolete remote branches
+   - Update remote branch information
+
+   ```bash
+   # Prune remote tracking branches
+   git remote prune origin
+   
+   # Delete remote branch
+   git push origin --delete branch-name
+   
+   # Remove local tracking of deleted remote branches
+   git branch -dr origin/branch-name
+   ```
+
+9. **Automated Cleanup Script**
+   
+   ```bash
+   #!/bin/bash
+   
+   # Git branch cleanup script
+   set -e
+   
+   # Configuration
+   MAIN_BRANCH="main"
+   PROTECTED_BRANCHES=("main" "master" "develop" "staging" "production")
+   STALE_DAYS=30
+   
+   # Functions
+   is_protected() {
+       local branch=$1
+       for protected in "${PROTECTED_BRANCHES[@]}"; do
+           if [[ "$branch" == "$protected" ]]; then
+               return 0
+           fi
+       done
+       return 1
+   }
+   
+   # Switch to main branch
+   git checkout $MAIN_BRANCH
+   git pull origin $MAIN_BRANCH
+   
+   # Clean up merged branches
+   echo "Cleaning up merged branches..."
+   merged_branches=$(git branch --merged $MAIN_BRANCH | grep -v "\\*\\|$MAIN_BRANCH")
+   
+   for branch in $merged_branches; do
+       if ! is_protected "$branch"; then
+           echo "Deleting merged branch: $branch"
+           git branch -d "$branch"
+       fi
+   done
+   
+   # Prune remote tracking branches
+   echo "Pruning remote tracking branches..."
+   git remote prune origin
+   
+   echo "Branch cleanup completed!"
+   ```
+
+10. **Team Coordination**
+    - Notify team before cleaning shared branches
+    - Check if branches are being used by others
+    - Coordinate branch cleanup schedules
+    - Document branch cleanup procedures
+
+11. **Branch Naming Convention Cleanup**
+    - Identify branches with non-standard naming
+    - Clean up temporary or experimental branches
+    - Remove old hotfix and feature branches
+    - Enforce consistent naming conventions
+
+12. **Verification and Validation**
+    - Verify important branches are still present
+    - Check that no active work was deleted
+    - Validate remote branch synchronization
+    - Confirm team members have no issues
+
+    ```bash
+    # Verify cleanup results
+    git branch -a
+    git remote show origin
+    ```
+
+13. **Documentation and Reporting**
+    - Document what branches were cleaned up
+    - Report any issues or conflicts found
+    - Update team documentation about branch lifecycle
+    - Create branch cleanup schedule and policies
+
+14. **Rollback Procedures**
+    - Document how to recover deleted branches
+    - Use reflog to find deleted branch commits
+    - Create emergency recovery procedures
+    - Set up branch restoration scripts
+
+    ```bash
+    # Recover deleted branch using reflog
+    git reflog --no-merges --since="2 weeks ago"
+    git checkout -b recovered-branch commit-hash
+    ```
+
+15. **Automation Setup**
+    - Set up automated branch cleanup scripts
+    - Configure CI/CD pipeline for branch cleanup
+    - Create scheduled cleanup jobs
+    - Implement branch lifecycle policies
+
+16. **Best Practices Implementation**
+    - Establish branch lifecycle guidelines
+    - Set up automated merge detection
+    - Configure branch protection rules
+    - Implement code review requirements
+
+**Advanced Cleanup Options:**
+
+```bash
+# Clean up all merged branches except protected ones
+git branch --merged main | grep -E "^  (feature|hotfix|bugfix)/" | xargs -n 1 git branch -d
+
+# Interactive cleanup with confirmation
+git branch --merged main | grep -v "main\|master\|develop" | xargs -n 1 -p git branch -d
+
+# Batch delete remote branches
+git branch -r --merged main | grep origin | grep -v "main\|master\|develop\|HEAD" | cut -d/ -f2- | xargs -n 1 git push origin --delete
+
+# Clean up branches older than specific date
+git for-each-ref --format='%(refname:short) %(committerdate:short)' refs/heads | awk '$2 < "2023-01-01"' | cut -d' ' -f1 | xargs -n 1 git branch -D
+```
+
+Remember to:
+- Always backup important branches before cleanup
+- Coordinate with team members before deleting shared branches
+- Test cleanup scripts in a safe environment first
+- Document all cleanup procedures and policies
+- Set up regular cleanup schedules to prevent accumulation

package/components/commands/utilities/clean.md

@@ -0,0 +1 @@
+Fix all black, isort, flake8 and mypy issues in the entire codebase