claude-code-templates 1.20.3 → 1.21.1

package/cli-tool/components/commands/utilities/code-permutation-tester.md

@@ -0,0 +1,341 @@
+# Code Permutation Tester
+
+Test multiple code variations through simulation before implementation with quality gates and performance prediction.
+
+## Instructions
+
+You are tasked with systematically testing multiple code implementation approaches through simulation to optimize decisions before actual development. Follow this approach: **$ARGUMENTS**
+
+### 1. Prerequisites Assessment
+
+**Critical Code Context Validation:**
+
+- **Code Scope**: What specific code area/function/feature are you testing variations for?
+- **Variation Types**: What different approaches are you considering?
+- **Quality Criteria**: How will you evaluate which variation is best?
+- **Constraints**: What technical, performance, or resource constraints apply?
+- **Decision Timeline**: When do you need to choose an implementation approach?
+
+**If context is unclear, guide systematically:**
+
+```
+Missing Code Scope:
+"What specific code area needs permutation testing?
+- Algorithm Implementation: Different algorithmic approaches for the same problem
+- Architecture Pattern: Various structural patterns (MVC, microservices, etc.)
+- Performance Optimization: Multiple optimization strategies for bottlenecks
+- API Design: Different interface design approaches
+- Data Structure Choice: Various data organization strategies
+
+Please specify the exact function, module, or system component."
+
+Missing Variation Types:
+"What different implementation approaches are you considering?
+- Algorithmic Variations: Different algorithms solving the same problem
+- Framework/Library Choices: Various tech stack options
+- Design Pattern Applications: Different structural and behavioral patterns
+- Performance Trade-offs: Speed vs. memory vs. maintainability variations
+- Integration Approaches: Different ways to connect with existing systems"
+```
+
+### 2. Code Variation Generation
+
+**Systematically identify and structure implementation alternatives:**
+
+#### Implementation Approach Matrix
+```
+Code Variation Framework:
+
+Algorithmic Variations:
+- Brute Force: Simple, readable implementation
+- Optimized: Performance-focused with complexity trade-offs
+- Hybrid: Balanced approach with configurable optimization
+- Novel: Innovative approaches using new techniques
+
+Architectural Variations:
+- Monolithic: Single deployment unit with tight coupling
+- Modular: Loosely coupled modules within single codebase
+- Microservices: Distributed services with independent deployment
+- Serverless: Function-based with cloud provider management
+
+Technology Stack Variations:
+- Traditional: Established, well-documented technologies
+- Modern: Current best practices and recent frameworks
+- Cutting-edge: Latest technologies with higher risk/reward
+- Hybrid: Mix of established and modern approaches
+
+Performance Profile Variations:
+- Memory-optimized: Minimal memory footprint
+- Speed-optimized: Maximum execution performance  
+- Scalability-optimized: Handles growth efficiently
+- Maintainability-optimized: Easy to modify and extend
+```
+
+#### Variation Specification Framework
+```
+For each code variation:
+
+Implementation Details:
+- Core Algorithm/Approach: [specific technical approach]
+- Key Dependencies: [frameworks, libraries, external services]
+- Architecture Pattern: [structural organization approach]
+- Data Flow Design: [how information moves through system]
+
+Quality Characteristics:
+- Performance Profile: [speed, memory, throughput expectations]
+- Maintainability Score: [ease of modification and extension]
+- Scalability Potential: [growth and load handling capability]
+- Reliability Assessment: [error handling and fault tolerance]
+
+Resource Requirements:
+- Development Time: [estimated implementation effort]
+- Team Skill Requirements: [expertise needed for implementation]
+- Infrastructure Needs: [deployment and operational requirements]
+- Ongoing Maintenance: [long-term support and evolution needs]
+```
+
+### 3. Simulation Framework Design
+
+**Create testing environment for code variations:**
+
+#### Code Simulation Methodology
+```
+Multi-Dimensional Testing Approach:
+
+Performance Simulation:
+- Synthetic workload generation and stress testing
+- Memory usage profiling and leak detection
+- Concurrent execution and race condition testing
+- Resource utilization monitoring and optimization
+
+Maintainability Simulation:
+- Code complexity analysis and metrics calculation
+- Change impact simulation and ripple effect analysis
+- Documentation quality and developer onboarding simulation
+- Debugging and troubleshooting ease assessment
+
+Scalability Simulation:
+- Load growth simulation and performance degradation analysis
+- Horizontal scaling simulation and resource efficiency
+- Data volume growth impact and query performance
+- Integration point stress testing and failure handling
+
+Security Simulation:
+- Attack vector simulation and vulnerability assessment
+- Data protection and privacy compliance testing
+- Authentication and authorization load testing
+- Input validation and sanitization effectiveness
+```
+
+#### Testing Environment Setup
+- Isolated testing environments for each variation
+- Consistent data sets and test scenarios across variations
+- Automated testing pipeline and result collection
+- Realistic production environment simulation
+
+### 4. Quality Gate Framework
+
+**Establish systematic evaluation criteria:**
+
+#### Multi-Criteria Evaluation Matrix
+```
+Code Quality Assessment Framework:
+
+Performance Gates (25% weight):
+- Response Time: [acceptable latency thresholds]
+- Throughput: [minimum requests/transactions per second]
+- Resource Usage: [memory, CPU, storage efficiency]
+- Scalability: [performance degradation under load]
+
+Maintainability Gates (25% weight):
+- Code Complexity: [cyclomatic complexity, nesting levels]
+- Test Coverage: [unit, integration, end-to-end test coverage]
+- Documentation Quality: [code comments, API docs, architecture docs]
+- Change Impact: [blast radius of typical modifications]
+
+Reliability Gates (25% weight):
+- Error Handling: [graceful failure and recovery mechanisms]
+- Fault Tolerance: [system behavior under adverse conditions]
+- Data Integrity: [consistency and corruption prevention]
+- Monitoring/Observability: [debugging and operational visibility]
+
+Business Gates (25% weight):
+- Time to Market: [development speed and delivery timeline]
+- Total Cost of Ownership: [development + operational costs]
+- Risk Assessment: [technical and business risk factors]
+- Strategic Alignment: [fit with long-term technology direction]
+
+Gate Score = (Performance × 0.25) + (Maintainability × 0.25) + (Reliability × 0.25) + (Business × 0.25)
+```
+
+#### Threshold Management
+- Minimum acceptable scores for each quality dimension
+- Trade-off analysis for competing quality attributes
+- Conditional gates based on specific use case requirements
+- Risk-adjusted thresholds for different implementation approaches
+
+### 5. Predictive Performance Modeling
+
+**Forecast real-world behavior before implementation:**
+
+#### Performance Prediction Framework
+```
+Multi-Layer Performance Modeling:
+
+Micro-Benchmarks:
+- Individual function and method performance measurement
+- Algorithm complexity analysis and big-O verification
+- Memory allocation patterns and garbage collection impact
+- CPU instruction efficiency and optimization opportunities
+
+Integration Performance:
+- Inter-module communication overhead and optimization
+- Database query performance and connection pooling
+- External API latency and timeout handling
+- Caching strategy effectiveness and hit ratio analysis
+
+System-Level Performance:
+- End-to-end request processing and user experience
+- Concurrent user simulation and resource contention
+- Peak load handling and graceful degradation
+- Infrastructure scaling behavior and cost implications
+
+Production Environment Prediction:
+- Real-world data volume and complexity simulation
+- Production traffic pattern modeling and capacity planning
+- Deployment and rollback performance impact assessment
+- Operational monitoring and alerting effectiveness
+```
+
+#### Confidence Interval Calculation
+- Statistical analysis of performance variation across test runs
+- Confidence levels for performance predictions under different conditions
+- Sensitivity analysis for key performance parameters
+- Risk assessment for performance-related business impacts
+
+### 6. Risk and Trade-off Analysis
+
+**Systematic evaluation of implementation choices:**
+
+#### Technical Risk Assessment
+```
+Risk Evaluation Framework:
+
+Implementation Risks:
+- Technical Complexity: [difficulty and error probability]
+- Dependency Risk: [external library and service dependencies]
+- Performance Risk: [ability to meet performance requirements]
+- Integration Risk: [compatibility with existing systems]
+
+Operational Risks:
+- Deployment Complexity: [rollout difficulty and rollback capability]
+- Monitoring/Debugging: [operational visibility and troubleshooting]
+- Scaling Challenges: [growth accommodation and resource planning]
+- Maintenance Burden: [ongoing support and evolution requirements]
+
+Business Risks:
+- Timeline Risk: [delivery schedule and market timing impact]
+- Resource Risk: [team capacity and skill requirements]
+- Opportunity Cost: [alternative approaches and strategic alignment]
+- Competitive Risk: [technology choice and market position impact]
+```
+
+#### Trade-off Optimization
+- Pareto frontier analysis for competing objectives
+- Multi-objective optimization for quality attributes
+- Scenario-based trade-off evaluation
+- Stakeholder preference weighting and consensus building
+
+### 7. Decision Matrix and Recommendations
+
+**Generate systematic implementation guidance:**
+
+#### Code Variation Evaluation Summary
+```
+## Code Permutation Analysis: [Feature/Module Name]
+
+### Variation Comparison Matrix
+
+| Variation | Performance | Maintainability | Reliability | Business | Overall Score |
+|-----------|-------------|-----------------|-------------|----------|---------------|
+| Approach A | 85% | 70% | 90% | 75% | 80% |
+| Approach B | 70% | 90% | 80% | 85% | 81% |
+| Approach C | 95% | 60% | 70% | 65% | 73% |
+
+### Detailed Analysis
+
+#### Recommended Approach: [Selected Variation]
+
+**Rationale:**
+- Performance Advantages: [specific benefits and measurements]
+- Maintainability Considerations: [long-term support implications]
+- Risk Assessment: [identified risks and mitigation strategies]
+- Business Alignment: [strategic fit and market timing]
+
+**Implementation Plan:**
+- Development Phases: [staged implementation approach]
+- Quality Checkpoints: [validation gates and success criteria]
+- Risk Mitigation: [specific risk reduction strategies]
+- Performance Validation: [ongoing monitoring and optimization]
+
+#### Alternative Considerations:
+- Backup Option: [second-choice approach and trigger conditions]
+- Hybrid Opportunities: [combining best elements from multiple approaches]
+- Future Evolution: [how to migrate or improve chosen approach]
+- Context Dependencies: [when alternative approaches might be better]
+
+### Success Metrics and Monitoring
+- Performance KPIs: [specific metrics and acceptable ranges]
+- Quality Indicators: [maintainability and reliability measures]
+- Business Outcomes: [user satisfaction and business impact metrics]
+- Early Warning Signs: [indicators that approach is not working]
+```
+
+### 8. Continuous Learning Integration
+
+**Establish feedback loops for approach refinement:**
+
+#### Implementation Validation
+- Real-world performance comparison to simulation predictions
+- Developer experience and productivity measurement
+- User feedback and satisfaction assessment
+- Business outcome tracking and success evaluation
+
+#### Knowledge Capture
+- Decision rationale documentation and lessons learned
+- Best practice identification and pattern library development
+- Anti-pattern recognition and avoidance strategies
+- Team capability building and expertise development
+
+## Usage Examples
+
+```bash
+# Algorithm optimization testing
+/dev:code-permutation-tester Test 5 different sorting algorithms for large dataset processing with memory and speed constraints
+
+# Architecture pattern evaluation
+/dev:code-permutation-tester Compare microservices vs monolith vs modular monolith for payment processing system
+
+# Framework selection simulation
+/dev:code-permutation-tester Evaluate React vs Vue vs Angular for customer dashboard with performance and maintainability focus
+
+# Database optimization testing
+/dev:code-permutation-tester Test NoSQL vs relational vs hybrid database approaches for user analytics platform
+```
+
+## Quality Indicators
+
+- **Green**: Multiple variations tested, comprehensive quality gates, validated performance predictions
+- **Yellow**: Some variations tested, basic quality assessment, estimated performance  
+- **Red**: Single approach, minimal testing, unvalidated assumptions
+
+## Common Pitfalls to Avoid
+
+- Premature optimization: Over-engineering for theoretical rather than real requirements
+- Analysis paralysis: Testing too many variations without making decisions
+- Context ignorance: Not considering real-world constraints and team capabilities
+- Quality tunnel vision: Optimizing for single dimension while ignoring others
+- Simulation disconnect: Testing scenarios that don't match production reality
+- Decision delay: Not acting on simulation results in timely manner
+
+Transform code implementation from guesswork into systematic, evidence-based decision making through comprehensive variation testing and simulation.

package/cli-tool/components/commands/utilities/code-review.md

@@ -0,0 +1,70 @@
+---
+allowed-tools: Read, Bash, Grep, Glob
+argument-hint: [file-path] | [commit-hash] | --full
+description: Comprehensive code quality review with security, performance, and architecture analysis
+model: sonnet
+---
+
+# Code Quality Review
+
+Perform comprehensive code quality review: $ARGUMENTS
+
+## Current State
+
+- Git status: !`git status --porcelain`
+- Recent changes: !`git diff --stat HEAD~5`
+- Repository info: !`git log --oneline -5`
+- Build status: !`npm run build --dry-run 2>/dev/null || echo "No build script"`
+
+## Task
+
+Follow these steps to conduct a thorough code review:
+
+1. **Repository Analysis**
+   - Examine the repository structure and identify the primary language/framework
+   - Check for configuration files (package.json, requirements.txt, Cargo.toml, etc.)
+   - Review README and documentation for context
+
+2. **Code Quality Assessment**
+   - Scan for code smells, anti-patterns, and potential bugs
+   - Check for consistent coding style and naming conventions
+   - Identify unused imports, variables, or dead code
+   - Review error handling and logging practices
+
+3. **Security Review**
+   - Look for common security vulnerabilities (SQL injection, XSS, etc.)
+   - Check for hardcoded secrets, API keys, or passwords
+   - Review authentication and authorization logic
+   - Examine input validation and sanitization
+
+4. **Performance Analysis**
+   - Identify potential performance bottlenecks
+   - Check for inefficient algorithms or database queries
+   - Review memory usage patterns and potential leaks
+   - Analyze bundle size and optimization opportunities
+
+5. **Architecture & Design**
+   - Evaluate code organization and separation of concerns
+   - Check for proper abstraction and modularity
+   - Review dependency management and coupling
+   - Assess scalability and maintainability
+
+6. **Testing Coverage**
+   - Check existing test coverage and quality
+   - Identify areas lacking proper testing
+   - Review test structure and organization
+   - Suggest additional test scenarios
+
+7. **Documentation Review**
+   - Evaluate code comments and inline documentation
+   - Check API documentation completeness
+   - Review README and setup instructions
+   - Identify areas needing better documentation
+
+8. **Recommendations**
+   - Prioritize issues by severity (critical, high, medium, low)
+   - Provide specific, actionable recommendations
+   - Suggest tools and practices for improvement
+   - Create a summary report with next steps
+
+Remember to be constructive and provide specific examples with file paths and line numbers where applicable.