claude-code-templates 1.21.0 → 1.21.1

package/cli-tool/components/commands/orchestration/sync.md

@@ -0,0 +1,294 @@
+# Orchestration Sync Command
+
+Synchronize task status with git commits, ensuring consistency between version control and task tracking.
+
+## Usage
+
+```
+/orchestration/sync [options]
+```
+
+## Description
+
+Analyzes git history and task status to identify discrepancies, automatically updating task tracking based on commit evidence and maintaining bidirectional consistency.
+
+## Basic Commands
+
+### Full Sync
+```
+/orchestration/sync
+```
+Performs complete synchronization between git and task status.
+
+### Check Sync Status
+```
+/orchestration/sync --check
+```
+Reports inconsistencies without making changes.
+
+### Sync Specific Orchestration
+```
+/orchestration/sync --date 03_15_2024 --project auth_system
+```
+
+## Sync Operations
+
+### Git → Task Status
+Updates task status based on commit messages:
+```
+Found commits:
+- feat(auth): implement JWT validation (TASK-003) ✓
+  Status: in_progress → qa (based on commit)
+  
+- test(auth): add JWT validation tests (TASK-003) ✓
+  Status: qa → completed (tests indicate completion)
+  
+- fix(auth): resolve token expiration (TASK-007) ✓
+  Status: todos → in_progress (work started)
+```
+
+### Task Status → Git
+Identifies tasks marked complete without commits:
+```
+Status Discrepancies:
+- TASK-005: Marked 'completed' but no commits found
+- TASK-008: In 'qa' but no implementation commits
+- TASK-010: Multiple commits but still in 'todos'
+```
+
+## Detection Patterns
+
+### Commit Pattern Matching
+```
+Patterns detected:
+- "feat(auth): implement" → Implementation complete
+- "test(auth): add" → Testing phase
+- "fix(auth): resolve" → Bug fix complete
+- "docs(auth): update" → Documentation done
+- "refactor(auth):" → Code improvement
+```
+
+### Task Reference Extraction
+```
+Scanning commits for task references:
+- Explicit: "Task: TASK-003" ✓
+- In body: "Implements TASK-003" ✓
+- Branch name: "feature/TASK-003-jwt" ✓
+- PR title: "TASK-003: JWT implementation" ✓
+```
+
+## Sync Rules
+
+### Automatic Status Updates
+```yaml
+sync_rules:
+  commit_patterns:
+    - pattern: "feat.*TASK-(\d+)"
+      action: "move to qa if in_progress"
+    - pattern: "test.*TASK-(\d+).*pass"
+      action: "move to completed if in qa"
+    - pattern: "fix.*TASK-(\d+)"
+      action: "move to qa if in_progress"
+    - pattern: "WIP.*TASK-(\d+)"
+      action: "keep in in_progress"
+```
+
+### Conflict Resolution
+```
+Conflict detected for TASK-003:
+- Git evidence: 3 commits, tests passing
+- Task status: in_progress
+- Recommended: Move to completed
+
+Resolution options:
+[1] Trust git (move to completed)
+[2] Trust tracker (keep in_progress)
+[3] Manual review
+[4] Skip
+```
+
+## Analysis Reports
+
+### Sync Summary
+```
+Synchronization Report
+======================
+
+Analyzed: 45 commits across 3 branches
+Tasks referenced: 12
+Status updates needed: 4
+
+Updates to apply:
+- TASK-003: in_progress → completed (3 commits)
+- TASK-007: todos → in_progress (1 commit)
+- TASK-009: qa → completed (tests added)
+- TASK-011: on_hold → in_progress (blocker resolved)
+
+Warnings:
+- TASK-005: Completed without commits
+- TASK-013: Commits without task reference
+```
+
+### Detailed Analysis
+```
+Task: TASK-003 - JWT Implementation
+Current Status: in_progress
+Git Evidence:
+  - feat(auth): implement JWT validation (2 days ago)
+  - test(auth): add validation tests (1 day ago)
+  - fix(auth): handle edge cases (1 day ago)
+  
+Recommendation: Move to completed
+Confidence: High (95%)
+```
+
+## Options
+
+### Dry Run
+```
+/orchestration/sync --dry-run
+```
+Shows what would change without applying updates.
+
+### Force Sync
+```
+/orchestration/sync --force
+```
+Applies all recommendations without prompting.
+
+### Time Range
+```
+/orchestration/sync --since "1 week ago"
+```
+Only analyzes recent commits.
+
+### Branch Specific
+```
+/orchestration/sync --branch feature/auth
+```
+Syncs only tasks related to specific branch.
+
+## Integration Features
+
+### Update Tracking Files
+```
+/orchestration/sync --update-trackers
+```
+Updates TASK-STATUS-TRACKER.yaml with:
+```yaml
+git_tracking:
+  TASK-003:
+    status_from_git: completed
+    confidence: 0.95
+    evidence:
+      - commit: abc123
+        message: "feat(auth): implement JWT"
+        date: "2024-03-13"
+      - commit: def456
+        message: "test(auth): add tests"
+        date: "2024-03-14"
+```
+
+### Generate Commit Report
+```
+/orchestration/sync --commit-report
+```
+Creates report of all task-related commits.
+
+### Fix Orphaned Commits
+```
+/orchestration/sync --link-orphans
+```
+Associates commits without task references.
+
+## Sync Strategies
+
+### Conservative
+```
+/orchestration/sync --conservative
+```
+Only updates with high confidence matches.
+
+### Aggressive
+```
+/orchestration/sync --aggressive
+```
+Updates based on any evidence.
+
+### Interactive
+```
+/orchestration/sync --interactive
+```
+Prompts for each potential update.
+
+## Examples
+
+### Example 1: Daily Sync
+```
+/orchestration/sync --since yesterday
+
+Quick sync results:
+- 5 commits analyzed
+- 2 tasks updated
+- All changes applied successfully
+```
+
+### Example 2: Branch Merge Sync
+```
+/orchestration/sync --after-merge feature/auth
+
+Post-merge sync:
+- 15 commits from feature/auth
+- 5 tasks moved to completed
+- 2 tasks have test failures (kept in qa)
+```
+
+### Example 3: Audit Mode
+```
+/orchestration/sync --audit --report
+
+Audit Report:
+- Tasks with commits: 85%
+- Commits with task refs: 92%
+- Average commits per task: 2.3
+- Orphaned commits: 3
+```
+
+## Webhook Integration
+
+### Auto-sync on Push
+```yaml
+git_hooks:
+  post-commit: /orchestration/sync --last-commit
+  post-merge: /orchestration/sync --branch HEAD
+```
+
+## Best Practices
+
+1. **Regular Syncs**: Run daily or after major commits
+2. **Review Before Force**: Check dry-run output first
+3. **Maintain References**: Include task IDs in commits
+4. **Handle Conflicts**: Don't ignore sync warnings
+5. **Document Decisions**: Note why status differs from git
+
+## Configuration
+
+### Sync Preferences
+```yaml
+sync_config:
+  auto_sync: true
+  confidence_threshold: 0.8
+  require_tests: true
+  trust_git_over_tracker: true
+  patterns:
+    - implementation: "feat|feature"
+    - testing: "test|spec"
+    - completion: "done|complete|finish"
+```
+
+## Notes
+
+- Requires git access to all relevant branches
+- Preserves manual status overrides with flags
+- Supports custom commit message patterns
+- Integrates with CI/CD for automated syncing

package/cli-tool/components/commands/performance/add-performance-monitoring.md

@@ -0,0 +1,84 @@
+---
+allowed-tools: Read, Bash, Grep, Glob
+argument-hint: [monitoring-type] | --apm | --rum | --custom
+description: Setup comprehensive application performance monitoring with metrics, alerting, and observability
+model: sonnet
+---
+
+# Add Performance Monitoring
+
+Setup application performance monitoring: **$ARGUMENTS**
+
+## Instructions
+
+1. **Performance Monitoring Strategy**
+   - Define key performance indicators (KPIs) and service level objectives (SLOs)
+   - Identify critical user journeys and performance bottlenecks
+   - Plan monitoring architecture and data collection strategy
+   - Assess existing monitoring infrastructure and integration points
+   - Define alerting thresholds and escalation procedures
+
+2. **Application Performance Monitoring (APM)**
+   - Set up comprehensive APM solution (New Relic, Datadog, AppDynamics)
+   - Configure distributed tracing for request lifecycle visibility
+   - Implement custom metrics and performance tracking
+   - Set up transaction monitoring and error tracking
+   - Configure performance profiling and diagnostics
+
+3. **Real User Monitoring (RUM)**
+   - Implement client-side performance tracking and web vitals monitoring
+   - Set up user experience metrics collection (LCP, FID, CLS, TTFB)
+   - Configure custom performance metrics for user interactions
+   - Monitor page load performance and resource loading
+   - Track user journey performance across different devices
+
+4. **Server Performance Monitoring**
+   - Monitor system metrics (CPU, memory, disk, network)
+   - Set up process and application-level monitoring
+   - Configure event loop lag and garbage collection monitoring
+   - Implement custom server performance metrics
+   - Monitor resource utilization and capacity planning
+
+5. **Database Performance Monitoring**
+   - Track database query performance and slow query identification
+   - Monitor database connection pool utilization
+   - Set up database performance metrics and alerting
+   - Implement query execution plan analysis
+   - Monitor database resource usage and optimization opportunities
+
+6. **Error Tracking and Monitoring**
+   - Implement comprehensive error tracking (Sentry, Bugsnag, Rollbar)
+   - Configure error categorization and impact analysis
+   - Set up error alerting and notification systems
+   - Track error trends and resolution metrics
+   - Implement error context and debugging information
+
+7. **Custom Metrics and Dashboards**
+   - Implement business metrics tracking (Prometheus, StatsD)
+   - Create performance dashboards and visualizations
+   - Configure custom alerting rules and thresholds
+   - Set up performance trend analysis and reporting
+   - Implement performance regression detection
+
+8. **Alerting and Notification System**
+   - Configure intelligent alerting based on performance thresholds
+   - Set up multi-channel notifications (email, Slack, PagerDuty)
+   - Implement alert escalation and on-call procedures
+   - Configure alert fatigue prevention and noise reduction
+   - Set up performance incident management workflows
+
+9. **Performance Testing Integration**
+   - Integrate monitoring with load testing and performance testing
+   - Set up continuous performance testing and monitoring
+   - Configure performance baseline tracking and comparison
+   - Implement performance test result analysis and reporting
+   - Monitor performance under different load scenarios
+
+10. **Performance Optimization Recommendations**
+    - Generate actionable performance insights and recommendations
+    - Implement automated performance analysis and reporting
+    - Set up performance optimization tracking and measurement
+    - Configure performance improvement validation
+    - Create performance optimization prioritization frameworks
+
+Focus on monitoring strategies that provide actionable insights for performance optimization. Ensure monitoring overhead is minimal and doesn't impact application performance.

package/cli-tool/components/commands/performance/implement-caching-strategy.md

@@ -0,0 +1,84 @@
+---
+allowed-tools: Read, Bash, Grep, Glob
+argument-hint: [cache-type] | --browser | --application | --database
+description: Design and implement comprehensive caching solutions for improved performance and scalability
+model: sonnet
+---
+
+# Implement Caching Strategy
+
+Design and implement caching solutions: **$ARGUMENTS**
+
+## Instructions
+
+1. **Caching Strategy Analysis**
+   - Analyze application architecture and identify caching opportunities
+   - Assess current performance bottlenecks and data access patterns
+   - Define caching requirements (TTL, invalidation, consistency)
+   - Plan multi-layer caching architecture (browser, CDN, application, database)
+   - Evaluate caching technologies and storage solutions
+
+2. **Browser and Client-Side Caching**
+   - Configure HTTP caching headers and cache policies for static assets
+   - Implement service worker caching strategies for progressive web apps
+   - Set up browser storage caching (localStorage, sessionStorage, IndexedDB)
+   - Configure CDN caching rules and edge optimization
+   - Implement cache-first, network-first, and stale-while-revalidate strategies
+
+3. **Application-Level Caching**
+   - Implement in-memory caching for frequently accessed data
+   - Set up distributed caching with Redis or Memcached
+   - Design cache key naming conventions and namespacing
+   - Implement cache warming strategies for critical data
+   - Configure cache expiration and TTL policies
+
+4. **Database Query Caching**
+   - Implement query result caching for expensive database operations
+   - Set up prepared statement caching and connection pooling
+   - Design cache invalidation strategies for data consistency
+   - Implement materialized views for complex aggregations
+   - Configure database-level caching features and optimizations
+
+5. **API Response Caching**
+   - Implement API endpoint response caching with appropriate headers
+   - Set up middleware for automatic response caching
+   - Configure GraphQL query caching and field-level optimization
+   - Implement conditional requests with ETag and Last-Modified headers
+   - Design cache invalidation for API data updates
+
+6. **Cache Invalidation Strategies**
+   - Design intelligent cache invalidation based on data dependencies
+   - Implement event-driven cache invalidation systems
+   - Set up cache tagging and bulk invalidation mechanisms
+   - Configure time-based and trigger-based invalidation policies
+   - Implement cache versioning and rollback strategies
+
+7. **Frontend Caching Strategies**
+   - Implement client-side data caching with libraries like React Query
+   - Set up component-level caching and memoization
+   - Configure asset bundling and chunk caching strategies
+   - Implement progressive image loading and caching
+   - Set up offline-first caching for PWAs
+
+8. **Cache Monitoring and Analytics**
+   - Set up cache performance monitoring and metrics collection
+   - Track cache hit rates, miss rates, and efficiency metrics
+   - Monitor cache memory usage and storage optimization
+   - Implement cache performance alerting and notifications
+   - Analyze cache usage patterns and optimization opportunities
+
+9. **Cache Warming and Preloading**
+   - Implement automated cache warming for critical data
+   - Set up scheduled cache refresh and preloading strategies
+   - Design on-demand cache generation for popular content
+   - Configure cache warming triggers based on usage patterns
+   - Implement predictive caching based on user behavior
+
+10. **Testing and Validation**
+    - Set up cache performance testing and benchmarking
+    - Implement cache consistency validation and testing
+    - Configure cache invalidation testing scenarios
+    - Test cache behavior under high load and failure conditions
+    - Validate cache security and data isolation requirements
+
+Focus on implementing caching strategies that provide the most significant performance improvements while maintaining data consistency and system reliability. Always measure cache effectiveness and adjust strategies based on real-world usage patterns.

package/cli-tool/components/commands/performance/optimize-api-performance.md

@@ -0,0 +1,119 @@
+---
+allowed-tools: Read, Bash, Grep, Glob
+argument-hint: [api-type] | --rest | --graphql | --grpc
+description: Comprehensive API performance optimization with response time reduction, throughput improvement, and scalability enhancements
+model: sonnet
+---
+
+# Optimize API Performance
+
+Analyze and optimize API performance for faster response times, higher throughput, and better scalability: **$ARGUMENTS**
+
+## Instructions
+
+1. **API Performance Analysis**
+   - Analyze current API response times and throughput metrics
+   - Identify slowest endpoints and bottleneck patterns
+   - Profile API request/response lifecycle and processing time
+   - Document baseline performance metrics across different load scenarios
+   - Map API dependency chains and external service calls
+
+2. **Request/Response Optimization**
+   - Optimize request parsing and validation logic
+   - Implement efficient response serialization and compression
+   - Minimize payload sizes through selective field inclusion
+   - Configure appropriate HTTP headers and caching directives
+   - Optimize request routing and middleware processing
+
+3. **Database Query Optimization**
+   - Identify and optimize slow database queries
+   - Implement query result caching strategies
+   - Add appropriate database indexes for API queries
+   - Optimize database connection pooling and management
+   - Implement query batching and aggregation where applicable
+
+4. **Caching Strategy Implementation**
+   - Implement multi-level caching (in-memory, Redis, CDN)
+   - Configure cache invalidation strategies
+   - Set up API response caching with appropriate TTL values
+   - Implement cache warming and preloading strategies
+   - Monitor cache hit ratios and effectiveness
+
+5. **Rate Limiting and Throttling**
+   - Implement intelligent rate limiting based on usage patterns
+   - Configure adaptive throttling for different user tiers
+   - Set up queue management for handling traffic spikes
+   - Implement circuit breaker patterns for external services
+   - Monitor and adjust rate limits based on performance metrics
+
+6. **Concurrency and Parallelization**
+   - Implement proper async/await patterns for I/O operations
+   - Optimize thread pool configuration and management
+   - Implement parallel processing for independent operations
+   - Configure connection pooling for optimal concurrency
+   - Use streaming for large data transfers
+
+7. **API Gateway and Load Balancing**
+   - Configure API gateway for optimal routing and load distribution
+   - Implement health checks and automatic failover
+   - Set up load balancing algorithms for even traffic distribution
+   - Configure request/response transformation at gateway level
+   - Implement API versioning and traffic splitting
+
+8. **Monitoring and Observability**
+   - Set up comprehensive API performance monitoring
+   - Implement distributed tracing for request lifecycle visibility
+   - Configure performance metrics collection and alerting
+   - Monitor API error rates and response time percentiles
+   - Set up real-time performance dashboards
+
+9. **Security Performance Optimization**
+   - Optimize authentication and authorization processes
+   - Implement efficient JWT validation and caching
+   - Configure SSL/TLS termination for optimal performance
+   - Optimize API key validation and rate limiting
+   - Implement security middleware performance tuning
+
+10. **Content Delivery Optimization**
+    - Configure CDN for static API responses and assets
+    - Implement geographic load balancing and edge caching
+    - Optimize API endpoint geographical distribution
+    - Set up content compression and optimization
+    - Configure cache headers for optimal CDN performance
+
+11. **API Design Optimization**
+    - Review and optimize API endpoint design patterns
+    - Implement efficient pagination and filtering strategies
+    - Optimize API versioning and backward compatibility
+    - Design APIs for optimal client-side caching
+    - Implement GraphQL query optimization (if applicable)
+
+12. **Load Testing and Performance Validation**
+    - Implement comprehensive load testing scenarios
+    - Configure performance regression testing in CI/CD
+    - Set up chaos engineering tests for resilience validation
+    - Monitor API performance under various load conditions
+    - Validate performance optimizations with realistic test data
+
+13. **Scalability Planning**
+    - Design API architecture for horizontal scaling
+    - Implement auto-scaling policies based on performance metrics
+    - Configure database scaling strategies (read replicas, sharding)
+    - Plan for traffic growth and capacity requirements
+    - Implement graceful degradation strategies
+
+14. **Third-Party Service Optimization**
+    - Optimize external API calls and integrations
+    - Implement retry policies and exponential backoff
+    - Configure timeout settings for external services
+    - Set up fallback mechanisms for service unavailability
+    - Monitor third-party service performance impact
+
+15. **Performance Testing Automation**
+    - Set up automated performance testing pipelines
+    - Configure performance benchmarking and comparison
+    - Implement performance regression detection
+    - Set up load testing in staging environments
+    - Create performance test data management strategies
+
+Focus on optimizations that provide the highest impact on response times and throughput. Prioritize changes that improve user experience and system scalability while maintaining reliability.