claude-code-templates 1.21.1 → 1.21.2

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

@@ -1,294 +0,0 @@
-# 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

@@ -1,84 +0,0 @@
----
-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

@@ -1,84 +0,0 @@
----
-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

@@ -1,119 +0,0 @@
----
-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.