claude-code-templates 1.21.12 → 1.21.13

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

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

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

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

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

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

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