claude-code-templates 1.21.1 → 1.21.2

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

@@ -1,139 +0,0 @@
-# Optimize Build Command
-
-Optimize build processes and speed
-
-## Instructions
-
-Follow this systematic approach to optimize build performance: **$ARGUMENTS**
-
-1. **Build System Analysis**
-   - Identify the build system in use (Webpack, Vite, Rollup, Gradle, Maven, Cargo, etc.)
-   - Review build configuration files and settings
-   - Analyze current build times and output sizes
-   - Map the complete build pipeline and dependencies
-
-2. **Performance Baseline**
-   - Measure current build times for different scenarios:
-     - Clean build (from scratch)
-     - Incremental build (with cache)
-     - Development vs production builds
-   - Document bundle sizes and asset sizes
-   - Identify the slowest parts of the build process
-
-3. **Dependency Optimization**
-   - Analyze build dependencies and their impact
-   - Remove unused dependencies from build process
-   - Update build tools to latest stable versions
-   - Consider alternative, faster build tools
-
-4. **Caching Strategy**
-   - Enable and optimize build caching
-   - Configure persistent cache for CI/CD
-   - Set up shared cache for team development
-   - Implement incremental compilation where possible
-
-5. **Bundle Analysis**
-   - Analyze bundle composition and sizes
-   - Identify large dependencies and duplicates
-   - Use bundle analyzers specific to your build tool
-   - Look for opportunities to split bundles
-
-6. **Code Splitting and Lazy Loading**
-   - Implement dynamic imports and code splitting
-   - Set up route-based splitting for SPAs
-   - Configure vendor chunk separation
-   - Optimize chunk sizes and loading strategies
-
-7. **Asset Optimization**
-   - Optimize images (compression, format conversion, lazy loading)
-   - Minify CSS and JavaScript
-   - Configure tree shaking to remove dead code
-   - Implement asset compression (gzip, brotli)
-
-8. **Development Build Optimization**
-   - Enable fast refresh/hot reloading
-   - Use development-specific optimizations
-   - Configure source maps for better debugging
-   - Optimize development server settings
-
-9. **Production Build Optimization**
-   - Enable all production optimizations
-   - Configure dead code elimination
-   - Set up proper minification and compression
-   - Optimize for smaller bundle sizes
-
-10. **Parallel Processing**
-    - Enable parallel processing where supported
-    - Configure worker threads for build tasks
-    - Optimize for multi-core systems
-    - Use parallel compilation for TypeScript/Babel
-
-11. **File System Optimization**
-    - Optimize file watching and polling
-    - Configure proper include/exclude patterns
-    - Use efficient file loaders and processors
-    - Minimize file I/O operations
-
-12. **CI/CD Build Optimization**
-    - Optimize CI build environments and resources
-    - Implement proper caching strategies for CI
-    - Use build matrices efficiently
-    - Configure parallel CI jobs where beneficial
-
-13. **Memory Usage Optimization**
-    - Monitor and optimize memory usage during builds
-    - Configure heap sizes for build tools
-    - Identify and fix memory leaks in build process
-    - Use memory-efficient compilation options
-
-14. **Output Optimization**
-    - Configure compression and encoding
-    - Optimize file naming and hashing strategies
-    - Set up proper asset manifests
-    - Implement efficient asset serving
-
-15. **Monitoring and Profiling**
-    - Set up build time monitoring
-    - Use build profiling tools to identify bottlenecks
-    - Track bundle size changes over time
-    - Monitor build performance regressions
-
-16. **Tool-Specific Optimizations**
-    
-    **For Webpack:**
-    - Configure optimization.splitChunks
-    - Use thread-loader for parallel processing
-    - Enable optimization.usedExports for tree shaking
-    - Configure resolve.modules and resolve.extensions
-
-    **For Vite:**
-    - Configure build.rollupOptions
-    - Use esbuild for faster transpilation
-    - Optimize dependency pre-bundling
-    - Configure build.chunkSizeWarningLimit
-
-    **For TypeScript:**
-    - Use incremental compilation
-    - Configure project references
-    - Optimize tsconfig.json settings
-    - Use skipLibCheck when appropriate
-
-17. **Environment-Specific Configuration**
-    - Separate development and production configurations
-    - Use environment variables for build optimization
-    - Configure feature flags for conditional builds
-    - Optimize for target environments
-
-18. **Testing Build Optimizations**
-    - Test build outputs for correctness
-    - Verify all optimizations work in target environments
-    - Check for any breaking changes from optimizations
-    - Measure and document performance improvements
-
-19. **Documentation and Maintenance**
-    - Document all optimization changes and their impact
-    - Create build performance monitoring dashboard
-    - Set up alerts for build performance regressions
-    - Regular review and updates of build configuration
-
-Focus on the optimizations that provide the biggest impact for your specific project and team workflow. Always measure before and after to quantify improvements.

package/cli-tool/components/commands/performance/optimize-bundle-size.md

@@ -1,84 +0,0 @@
----
-allowed-tools: Read, Bash, Grep, Glob
-argument-hint: [build-tool] | --webpack | --vite | --rollup
-description: Reduce and optimize bundle sizes through analysis, configuration, and code splitting strategies
-model: sonnet
----
-
-# Optimize Bundle Size
-
-Reduce and optimize bundle sizes: **$ARGUMENTS**
-
-## Instructions
-
-1. **Bundle Analysis and Assessment**
-   - Analyze current bundle size and composition using webpack-bundle-analyzer or similar tools
-   - Identify large dependencies and unused code across all bundles
-   - Assess current build configuration and optimization settings
-   - Create baseline measurements for optimization tracking
-   - Document current performance metrics and loading times
-
-2. **Build Tool Configuration**
-   - Configure build tool optimization settings for production builds
-   - Enable code splitting and chunk optimization features
-   - Configure tree shaking and dead code elimination
-   - Set up bundle analyzers and visualization tools
-   - Optimize build performance and output sizes
-
-3. **Code Splitting and Lazy Loading**
-   - Implement route-based code splitting for single-page applications
-   - Set up dynamic imports for components and modules
-   - Configure lazy loading for non-critical resources
-   - Optimize chunk sizes and loading strategies
-   - Implement progressive loading patterns
-
-4. **Tree Shaking and Dead Code Elimination**
-   - Configure build tools for optimal tree shaking
-   - Mark packages as side-effect free where appropriate
-   - Optimize import statements for better tree shaking
-   - Use ES6 modules and avoid CommonJS where possible
-   - Implement babel plugins for automatic import optimization
-
-5. **Dependency Optimization**
-   - Analyze and audit package dependencies for size impact
-   - Replace large libraries with smaller alternatives
-   - Use specific imports instead of importing entire libraries
-   - Implement dependency deduplication strategies
-   - Configure external dependencies and CDN usage
-
-6. **Asset Optimization**
-   - Optimize images through compression and format conversion
-   - Implement responsive image loading strategies
-   - Configure asset minification and compression
-   - Set up efficient file loaders and processors
-   - Optimize font loading and subsetting
-
-7. **Module Federation and Micro-frontends**
-   - Implement module federation for large applications
-   - Configure shared dependencies and runtime optimization
-   - Set up micro-frontend architecture for code sharing
-   - Optimize remote module loading and caching
-   - Implement federation performance monitoring
-
-8. **Performance Monitoring and Measurement**
-   - Set up bundle size monitoring and tracking
-   - Configure automated bundle analysis in CI/CD
-   - Monitor bundle size changes over time
-   - Set up performance budgets and alerts
-   - Track loading performance metrics
-
-9. **Progressive Loading Strategies**
-   - Implement resource hints (preload, prefetch, dns-prefetch)
-   - Configure service workers for caching strategies
-   - Set up intersection observer for lazy loading
-   - Optimize critical resource loading priorities
-   - Implement adaptive loading based on connection speed
-
-10. **Validation and Continuous Monitoring**
-    - Set up automated bundle size validation in CI/CD
-    - Configure bundle size thresholds and alerts
-    - Implement bundle size regression testing
-    - Monitor real-world loading performance
-    - Set up automated optimization recommendations
-
-Focus on optimizations that provide the most significant bundle size reductions while maintaining application functionality. Always measure the impact of changes on both bundle size and runtime performance.

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

@@ -1,84 +0,0 @@
----
-allowed-tools: Read, Bash, Grep, Glob
-argument-hint: [database-type] | --postgresql | --mysql | --mongodb
-description: Optimize database queries, indexing, and performance for improved response times and scalability
-model: sonnet
----
-
-# Optimize Database Performance
-
-Optimize database queries and performance: **$ARGUMENTS**
-
-## Instructions
-
-1. **Database Performance Analysis**
-   - Analyze current database performance and identify bottlenecks
-   - Review slow query logs and execution plans
-   - Assess database schema design and normalization
-   - Evaluate indexing strategy and query patterns
-   - Monitor database resource utilization (CPU, memory, I/O)
-
-2. **Query Optimization**
-   - Identify and optimize slow-performing queries
-   - Analyze query execution plans and optimization strategies
-   - Rewrite queries for better performance and efficiency
-   - Implement query hints and optimization directives
-   - Configure query timeout and resource limits
-
-3. **Index Strategy Optimization**
-   - Analyze existing indexes and their usage patterns
-   - Design optimal indexing strategy for query patterns
-   - Create composite indexes for multi-column queries
-   - Implement covering indexes to avoid table lookups
-   - Remove unused and redundant indexes
-
-4. **Schema Design Optimization**
-   - Optimize table structure and data types
-   - Implement denormalization strategies for read-heavy workloads
-   - Design partitioning strategies for large tables
-   - Create materialized views for complex aggregations
-   - Optimize foreign key relationships and constraints
-
-5. **Connection Pool Optimization**
-   - Configure optimal database connection pooling settings
-   - Tune connection pool size and timeout settings
-   - Implement connection monitoring and health checks
-   - Optimize connection lifecycle and cleanup procedures
-   - Configure connection security and SSL settings
-
-6. **Query Result Caching**
-   - Implement intelligent database result caching
-   - Design cache invalidation strategies for data consistency
-   - Set up query-level and result-set caching
-   - Configure cache expiration and refresh policies
-   - Monitor cache effectiveness and hit rates
-
-7. **Database Monitoring and Profiling**
-   - Set up comprehensive database performance monitoring
-   - Monitor query performance and resource usage
-   - Track database connections and session activity
-   - Implement alerting for performance degradation
-   - Configure automated performance reporting
-
-8. **Read Replica and Load Balancing**
-   - Configure read replicas for query distribution
-   - Implement intelligent read/write query routing
-   - Set up load balancing across database instances
-   - Monitor replication lag and consistency
-   - Configure failover and disaster recovery procedures
-
-9. **Database Vacuum and Maintenance**
-   - Implement automated database maintenance procedures
-   - Configure vacuum and analyze operations for optimal performance
-   - Set up index rebuilding and maintenance schedules
-   - Monitor table bloat and fragmentation
-   - Implement automated cleanup and archival strategies
-
-10. **Performance Testing and Benchmarking**
-    - Set up database performance testing frameworks
-    - Implement load testing scenarios for realistic workloads
-    - Benchmark query performance under different conditions
-    - Test database scalability and capacity limits
-    - Monitor performance regression and improvements
-
-Focus on database optimizations that provide the most significant performance improvements for your specific workload patterns. Always measure performance before and after changes to validate optimizations.

package/cli-tool/components/commands/performance/optimize-memory-usage.md

@@ -1,91 +0,0 @@
----
-allowed-tools: Read, Bash, Grep, Glob
-argument-hint: [target-area] | --frontend | --backend | --database
-description: Comprehensive memory usage optimization with leak detection, garbage collection tuning, and memory profiling
-model: sonnet
----
-
-# Optimize Memory Usage
-
-Analyze and optimize memory usage patterns to prevent leaks and improve application performance: **$ARGUMENTS**
-
-## Instructions
-
-1. **Memory Analysis and Profiling**
-   - Profile current memory usage patterns using appropriate tools (Chrome DevTools, Node.js --inspect, Valgrind)
-   - Identify memory leaks and excessive memory consumption hotspots
-   - Analyze garbage collection patterns and performance impact
-   - Create baseline measurements for optimization tracking
-   - Document memory allocation hotspots and growth patterns over time
-
-2. **Memory Leak Detection**
-   - Set up memory leak detection for different runtime environments
-   - Monitor heap snapshots and compare over time intervals
-   - Track DOM node leaks in browser applications
-   - Implement event listener cleanup and monitoring
-   - Use profiling tools to identify growing memory patterns
-
-3. **Garbage Collection Optimization**
-   - Configure garbage collection settings for your runtime environment
-   - Tune Node.js heap sizes and GC flags for optimal performance
-   - Monitor GC pause times and frequency
-   - Implement GC performance monitoring and alerting
-   - Optimize object lifecycles to reduce GC pressure
-
-4. **Memory Pool and Object Reuse**
-   - Implement object pooling for frequently allocated objects
-   - Create buffer pools for Node.js applications
-   - Reuse DOM elements and components in frontend applications
-   - Design memory-efficient data structures (circular buffers, sparse arrays)
-   - Pre-allocate objects to reduce runtime allocation overhead
-
-5. **String and Text Optimization**
-   - Implement string interning for frequently used strings
-   - Optimize string concatenation and manipulation operations
-   - Use efficient text processing algorithms
-   - Minimize string duplication across the application
-   - Consider string compression for large text data
-
-6. **Database Connection Optimization**
-   - Implement proper connection pooling with appropriate limits
-   - Configure connection timeouts and cleanup procedures
-   - Optimize query result caching and memory usage
-   - Monitor database connection memory overhead
-   - Implement connection leak detection and prevention
-
-7. **Frontend Memory Optimization**
-   - Optimize component lifecycle and cleanup
-   - Implement proper event listener cleanup
-   - Use lazy loading for images and components
-   - Minimize bundle size and code splitting
-   - Monitor and optimize browser memory usage patterns
-
-8. **Backend Memory Optimization**
-   - Optimize server request handling and cleanup
-   - Implement streaming for large data processing
-   - Configure appropriate memory limits and monitoring
-   - Optimize middleware and request lifecycle
-   - Use memory-efficient data processing patterns
-
-9. **Container and Deployment Optimization**
-   - Configure appropriate container memory limits
-   - Optimize Docker image layers for memory efficiency
-   - Monitor memory usage in production environments
-   - Implement memory-based auto-scaling policies
-   - Set up memory usage alerting and monitoring
-
-10. **Memory Monitoring and Alerting**
-    - Set up real-time memory monitoring dashboards
-    - Configure memory usage alerts and thresholds
-    - Implement memory leak detection in production
-    - Track memory performance metrics over time
-    - Create automated memory optimization testing
-
-11. **Production Memory Management**
-    - Implement graceful memory pressure handling
-    - Configure memory-based health checks
-    - Set up memory usage trending and analysis
-    - Implement emergency memory cleanup procedures
-    - Monitor and optimize memory usage patterns
-
-Focus on the specific memory optimization strategies that provide the biggest impact for your target environment. Always measure memory usage before and after optimizations to quantify improvements.

package/cli-tool/components/commands/performance/performance-audit.md

@@ -1,89 +0,0 @@
----
-allowed-tools: Read, Bash, Grep, Glob
-argument-hint: [target-area] | --frontend | --backend | --full
-description: Comprehensive performance audit with metrics, bottleneck identification, and optimization recommendations
-model: sonnet
----
-
-# Performance Audit
-
-Conduct comprehensive performance audit: $ARGUMENTS
-
-## Current Performance Context
-
-- Bundle analysis: !`npm run build -- --analyze 2>/dev/null || echo "No build analyzer"`
-- Dependencies: !`npm list --depth=0 --prod 2>/dev/null | head -10`
-- Build time: !`time npm run build >/dev/null 2>&1 || echo "No build script"`
-- Performance config: @webpack.config.js or @vite.config.js or @next.config.js (if exists)
-
-## Task
-
-Conduct comprehensive performance audit following these steps:
-
-1. **Technology Stack Analysis**
-   - Identify the primary language, framework, and runtime environment
-   - Review build tools and optimization configurations
-   - Check for performance monitoring tools already in place
-
-2. **Code Performance Analysis**
-   - Identify inefficient algorithms and data structures
-   - Look for nested loops and O(n²) operations
-   - Check for unnecessary computations and redundant operations
-   - Review memory allocation patterns and potential leaks
-
-3. **Database Performance**
-   - Analyze database queries for efficiency
-   - Check for missing indexes and slow queries
-   - Review connection pooling and database configuration
-   - Identify N+1 query problems and excessive database calls
-
-4. **Frontend Performance (if applicable)**
-   - Analyze bundle size and chunk optimization
-   - Check for unused code and dependencies
-   - Review image optimization and lazy loading
-   - Examine render performance and re-render cycles
-   - Check for memory leaks in UI components
-
-5. **Network Performance**
-   - Review API call patterns and caching strategies
-   - Check for unnecessary network requests
-   - Analyze payload sizes and compression
-   - Examine CDN usage and static asset optimization
-
-6. **Asynchronous Operations**
-   - Review async/await usage and promise handling
-   - Check for blocking operations and race conditions
-   - Analyze task queuing and background processing
-   - Identify opportunities for parallel execution
-
-7. **Memory Usage**
-   - Check for memory leaks and excessive memory consumption
-   - Review garbage collection patterns
-   - Analyze object lifecycle and cleanup
-   - Identify large objects and unnecessary data retention
-
-8. **Build & Deployment Performance**
-   - Analyze build times and optimization opportunities
-   - Review dependency bundling and tree shaking
-   - Check for development vs production optimizations
-   - Examine deployment pipeline efficiency
-
-9. **Performance Monitoring**
-   - Check existing performance metrics and monitoring
-   - Identify key performance indicators (KPIs) to track
-   - Review alerting and performance thresholds
-   - Suggest performance testing strategies
-
-10. **Benchmarking & Profiling**
-    - Run performance profiling tools appropriate for the stack
-    - Create benchmarks for critical code paths
-    - Measure before and after optimization impact
-    - Document performance baselines
-
-11. **Optimization Recommendations**
-    - Prioritize optimizations by impact and effort
-    - Provide specific code examples and alternatives
-    - Suggest architectural improvements for scalability
-    - Recommend appropriate performance tools and libraries
-
-Include specific file paths, line numbers, and measurable metrics where possible. Focus on high-impact, low-effort optimizations first.

package/cli-tool/components/commands/performance/setup-cdn-optimization.md

@@ -1,84 +0,0 @@
----
-allowed-tools: Read, Bash, Grep, Glob
-argument-hint: [cdn-provider] | --cloudflare | --aws | --fastly
-description: Configure CDN for optimal content delivery, caching, and global performance optimization
-model: sonnet
----
-
-# Setup CDN Optimization
-
-Configure CDN for optimal delivery: **$ARGUMENTS**
-
-## Instructions
-
-1. **CDN Strategy and Provider Selection**
-   - Analyze application traffic patterns and global user distribution
-   - Evaluate CDN providers based on performance, cost, and features
-   - Assess content types and specific caching requirements
-   - Plan CDN architecture and edge location strategy
-   - Define performance and cost optimization goals
-
-2. **CDN Configuration and Setup**
-   - Configure CDN with optimal settings for your content types
-   - Set up origin servers and failover configurations
-   - Configure SSL/TLS certificates and security settings
-   - Implement custom domain and DNS configuration
-   - Set up monitoring and analytics tracking
-
-3. **Static Asset Optimization**
-   - Optimize asset build process for CDN delivery
-   - Configure content hashing and versioning strategies
-   - Set up asset bundling and code splitting for CDN
-   - Implement responsive image delivery and optimization
-   - Configure font loading and optimization strategies
-
-4. **Compression and Optimization**
-   - Configure Gzip and Brotli compression settings
-   - Set up build-time compression for static assets
-   - Implement dynamic compression for API responses
-   - Configure minification and asset optimization
-   - Set up progressive image formats (WebP, AVIF)
-
-5. **Cache Headers and Policies**
-   - Design intelligent caching strategies for different content types
-   - Configure cache control headers and TTL values
-   - Implement ETags and conditional request handling
-   - Set up cache hierarchy and multi-tier caching
-   - Configure cache warming and preloading strategies
-
-6. **Image Optimization and Delivery**
-   - Implement responsive image delivery with multiple formats
-   - Set up automatic image compression and optimization
-   - Configure lazy loading and progressive image loading
-   - Implement image resizing and format conversion
-   - Set up WebP and AVIF format support with fallbacks
-
-7. **CDN Purging and Cache Invalidation**
-   - Implement intelligent cache invalidation strategies
-   - Set up automated purging for deployment pipelines
-   - Configure selective purging by tags or patterns
-   - Implement real-time cache invalidation for dynamic content
-   - Set up cache invalidation monitoring and alerts
-
-8. **Performance Monitoring and Analytics**
-   - Set up CDN performance monitoring and metrics tracking
-   - Monitor cache hit ratios and bandwidth usage
-   - Track response times and error rates across regions
-   - Implement real user monitoring for CDN performance
-   - Set up alerts for performance degradation
-
-9. **Security and Access Control**
-   - Configure CDN security headers and policies
-   - Implement hotlink protection and referrer validation
-   - Set up DDoS protection and rate limiting
-   - Configure geo-blocking and access restrictions
-   - Implement secure token authentication for protected content
-
-10. **Cost Optimization and Monitoring**
-    - Monitor CDN usage and costs across different tiers
-    - Implement cost optimization strategies for bandwidth usage
-    - Set up automated cost alerts and budget monitoring
-    - Analyze usage patterns for tier optimization
-    - Configure cost-effective caching policies
-
-Focus on CDN optimizations that provide the most significant performance improvements for your specific content types and user base. Always measure CDN performance impact and adjust configurations based on real-world usage patterns.