claude-code-templates 1.21.11 → 1.21.13

package/cli-tool/components/commands/deployment/changelog-demo-command.md

@@ -0,0 +1,43 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [format] | --generate | --validate | --demo
+description: Demonstrate changelog automation features with real examples and validation
+model: sonnet
+---
+
+# Changelog Automation Demo
+
+Demonstrate changelog automation features: $ARGUMENTS
+
+## Current Project State
+
+- Existing changelog: @CHANGELOG.md (if exists)
+- Package version: @package.json or @pyproject.toml or @Cargo.toml (if exists)
+- Recent commits: !`git log --oneline -10`
+- Git tags: !`git tag -l | tail -5`
+
+## Demo Features
+
+### 1. **Changelog Generation Demo**
+- Generate sample changelog entries from git commits
+- Show different changelog formats (Keep a Changelog, conventional-changelog)
+- Demonstrate automatic categorization of changes
+- Show version numbering and semantic versioning
+
+### 2. **Format Validation Demo**
+- Validate existing changelog format compliance
+- Show format inconsistencies and suggestions
+- Demonstrate automated formatting fixes
+- Show integration with release automation
+
+### 3. **Integration Testing**
+- Test changelog automation without affecting main workflow
+- Validate changelog generation pipeline
+- Test different commit message patterns
+- Show error handling and recovery
+
+### 4. **Performance Benchmarking**
+- Measure changelog generation speed
+- Test with large commit histories
+- Show memory usage and optimization
+- Benchmark different parsing strategies

package/cli-tool/components/commands/deployment/ci-setup.md

@@ -0,0 +1,323 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [platform] | --github-actions | --gitlab-ci | --jenkins | --full-setup
+description: Setup comprehensive CI/CD pipeline with automated testing, building, and deployment
+model: sonnet
+---
+
+# CI/CD Pipeline Setup
+
+Setup continuous integration pipeline: $ARGUMENTS
+
+## Current Project Analysis
+
+- Project type: @package.json or @setup.py or @go.mod or @pom.xml (detect language/framework)
+- Existing workflows: !`find .github/workflows -name "*.yml" 2>/dev/null | head -3`
+- Git branches: !`git branch -r | head -5`
+- Dependencies: @package-lock.json or @requirements.txt or @go.sum (if exists)
+- Build scripts: Check for build commands in package.json or Makefile
+
+## Task
+
+Implement comprehensive CI/CD following best practices: $ARGUMENTS
+
+1. **Project Analysis**
+   - Identify the technology stack and deployment requirements
+   - Review existing build and test processes
+   - Understand deployment environments (dev, staging, prod)
+   - Assess current version control and branching strategy
+
+2. **CI/CD Platform Selection**
+   - Choose appropriate CI/CD platform based on requirements:
+     - **GitHub Actions**: Native GitHub integration, extensive marketplace
+     - **GitLab CI**: Built-in GitLab, comprehensive DevOps platform
+     - **Jenkins**: Self-hosted, highly customizable, extensive plugins
+     - **CircleCI**: Cloud-based, optimized for speed
+     - **Azure DevOps**: Microsoft ecosystem integration
+     - **AWS CodePipeline**: AWS-native solution
+
+3. **Repository Setup**
+   - Ensure proper `.gitignore` configuration
+   - Set up branch protection rules
+   - Configure merge requirements and reviews
+   - Establish semantic versioning strategy
+
+4. **Build Pipeline Configuration**
+   
+   **GitHub Actions Example:**
+   ```yaml
+   name: CI/CD Pipeline
+   
+   on:
+     push:
+       branches: [ main, develop ]
+     pull_request:
+       branches: [ main ]
+   
+   jobs:
+     test:
+       runs-on: ubuntu-latest
+       steps:
+         - uses: actions/checkout@v3
+         - name: Setup Node.js
+           uses: actions/setup-node@v3
+           with:
+             node-version: '18'
+             cache: 'npm'
+         - run: npm ci
+         - run: npm run test
+         - run: npm run build
+   ```
+
+   **GitLab CI Example:**
+   ```yaml
+   stages:
+     - test
+     - build
+     - deploy
+   
+   test:
+     stage: test
+     script:
+       - npm ci
+       - npm run test
+     cache:
+       paths:
+         - node_modules/
+   ```
+
+5. **Environment Configuration**
+   - Set up environment variables and secrets
+   - Configure different environments (dev, staging, prod)
+   - Implement environment-specific configurations
+   - Set up secure secret management
+
+6. **Automated Testing Integration**
+   - Configure unit test execution
+   - Set up integration test running
+   - Implement E2E test execution
+   - Configure test reporting and coverage
+
+   **Multi-stage Testing:**
+   ```yaml
+   test:
+     strategy:
+       matrix:
+         node-version: [16, 18, 20]
+     runs-on: ubuntu-latest
+     steps:
+       - uses: actions/checkout@v3
+       - uses: actions/setup-node@v3
+         with:
+           node-version: ${{ matrix.node-version }}
+       - run: npm ci
+       - run: npm test
+   ```
+
+7. **Code Quality Gates**
+   - Integrate linting and formatting checks
+   - Set up static code analysis (SonarQube, CodeClimate)
+   - Configure security vulnerability scanning
+   - Implement code coverage thresholds
+
+8. **Build Optimization**
+   - Configure build caching strategies
+   - Implement parallel job execution
+   - Optimize Docker image builds
+   - Set up artifact management
+
+   **Caching Example:**
+   ```yaml
+   - name: Cache node modules
+     uses: actions/cache@v3
+     with:
+       path: ~/.npm
+       key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
+       restore-keys: |
+         ${{ runner.os }}-node-
+   ```
+
+9. **Docker Integration**
+   - Create optimized Dockerfiles
+   - Set up multi-stage builds
+   - Configure container registry integration
+   - Implement security scanning for images
+
+   **Multi-stage Dockerfile:**
+   ```dockerfile
+   FROM node:18-alpine AS builder
+   WORKDIR /app
+   COPY package*.json ./
+   RUN npm ci --only=production
+   
+   FROM node:18-alpine AS runtime
+   WORKDIR /app
+   COPY --from=builder /app/node_modules ./node_modules
+   COPY . .
+   EXPOSE 3000
+   CMD ["npm", "start"]
+   ```
+
+10. **Deployment Strategies**
+    - Implement blue-green deployment
+    - Set up canary releases
+    - Configure rolling updates
+    - Implement feature flags integration
+
+11. **Infrastructure as Code**
+    - Use Terraform, CloudFormation, or similar tools
+    - Version control infrastructure definitions
+    - Implement infrastructure testing
+    - Set up automated infrastructure provisioning
+
+12. **Monitoring and Observability**
+    - Set up application performance monitoring
+    - Configure log aggregation and analysis
+    - Implement health checks and alerting
+    - Set up deployment notifications
+
+13. **Security Integration**
+    - Implement dependency vulnerability scanning
+    - Set up container security scanning
+    - Configure SAST (Static Application Security Testing)
+    - Implement secrets scanning
+
+   **Security Scanning Example:**
+   ```yaml
+   security:
+     runs-on: ubuntu-latest
+     steps:
+       - uses: actions/checkout@v3
+       - name: Run Snyk to check for vulnerabilities
+         uses: snyk/actions/node@master
+         env:
+           SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
+   ```
+
+14. **Database Migration Handling**
+    - Automate database schema migrations
+    - Implement rollback strategies
+    - Set up database seeding for testing
+    - Configure backup and recovery procedures
+
+15. **Performance Testing Integration**
+    - Set up load testing in pipeline
+    - Configure performance benchmarks
+    - Implement performance regression detection
+    - Set up performance monitoring
+
+16. **Multi-Environment Deployment**
+    - Configure staging environment deployment
+    - Set up production deployment with approvals
+    - Implement environment promotion workflow
+    - Configure environment-specific configurations
+
+   **Environment Deployment:**
+   ```yaml
+   deploy-staging:
+     needs: test
+     if: github.ref == 'refs/heads/develop'
+     runs-on: ubuntu-latest
+     steps:
+       - name: Deploy to staging
+         run: |
+           # Deploy to staging environment
+   
+   deploy-production:
+     needs: test
+     if: github.ref == 'refs/heads/main'
+     runs-on: ubuntu-latest
+     environment: production
+     steps:
+       - name: Deploy to production
+         run: |
+           # Deploy to production environment
+   ```
+
+17. **Rollback and Recovery**
+    - Implement automated rollback procedures
+    - Set up deployment verification tests
+    - Configure failure detection and alerts
+    - Document manual recovery procedures
+
+18. **Notification and Reporting**
+    - Set up Slack/Teams integration for notifications
+    - Configure email alerts for failures
+    - Implement deployment status reporting
+    - Set up metrics dashboards
+
+19. **Compliance and Auditing**
+    - Implement deployment audit trails
+    - Set up compliance checks (SOC 2, HIPAA, etc.)
+    - Configure approval workflows for sensitive deployments
+    - Document change management processes
+
+20. **Pipeline Optimization**
+    - Monitor pipeline performance and costs
+    - Implement pipeline parallelization
+    - Optimize resource allocation
+    - Set up pipeline analytics and reporting
+
+**Best Practices:**
+
+1. **Fail Fast**: Implement early failure detection
+2. **Parallel Execution**: Run independent jobs in parallel
+3. **Caching**: Cache dependencies and build artifacts
+4. **Security**: Never expose secrets in logs
+5. **Documentation**: Document pipeline processes and procedures
+6. **Monitoring**: Monitor pipeline health and performance
+7. **Testing**: Test pipeline changes in feature branches
+8. **Rollback**: Always have a rollback strategy
+
+**Sample Complete Pipeline:**
+```yaml
+name: Full CI/CD Pipeline
+
+on:
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  lint-and-test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: '18'
+          cache: 'npm'
+      - run: npm ci
+      - run: npm run lint
+      - run: npm run test:coverage
+      - run: npm run build
+
+  security-scan:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Security scan
+        run: npm audit --audit-level=high
+
+  deploy-staging:
+    needs: [lint-and-test, security-scan]
+    if: github.ref == 'refs/heads/develop'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Deploy to staging
+        run: echo "Deploying to staging"
+
+  deploy-production:
+    needs: [lint-and-test, security-scan]
+    if: github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    environment: production
+    steps:
+      - uses: actions/checkout@v3
+      - name: Deploy to production
+        run: echo "Deploying to production"
+```
+
+Start with basic CI and gradually add more sophisticated features as your team and project mature.

package/cli-tool/components/commands/deployment/containerize-application.md

@@ -0,0 +1,93 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [application-type] | --node | --python | --java | --go | --multi-stage
+description: Containerize application with optimized Docker configuration, security, and multi-stage builds
+model: sonnet
+---
+
+# Application Containerization
+
+Containerize application for deployment: $ARGUMENTS
+
+## Current Application Analysis
+
+- Application type: @package.json or @setup.py or @go.mod or @pom.xml (detect runtime)
+- Existing Docker: @Dockerfile or @docker-compose.yml (if exists)
+- Dependencies: !`find . -name "*requirements*.txt" -o -name "package*.json" -o -name "go.mod" | head -3`
+- Port configuration: !`grep -r "PORT\|listen\|bind" src/ 2>/dev/null | head -3 || echo "Port detection needed"`
+- Build tools: @Makefile or build scripts detection
+
+## Task
+
+Implement production-ready containerization strategy:
+
+1. **Application Analysis and Containerization Strategy**
+   - Analyze application architecture and runtime requirements
+   - Identify application dependencies and external services
+   - Determine optimal base image and runtime environment
+   - Plan multi-stage build strategy for optimization
+   - Assess security requirements and compliance needs
+
+2. **Dockerfile Creation and Optimization**
+   - Create comprehensive Dockerfile with multi-stage builds
+   - Select minimal base images (Alpine, distroless, or slim variants)
+   - Configure proper layer caching and build optimization
+   - Implement security best practices (non-root user, minimal attack surface)
+   - Set up proper file permissions and ownership
+
+3. **Build Process Configuration**
+   - Configure .dockerignore file to exclude unnecessary files
+   - Set up build arguments and environment variables
+   - Implement build-time dependency installation and cleanup
+   - Configure application bundling and asset optimization
+   - Set up proper build context and file structure
+
+4. **Runtime Configuration**
+   - Configure application startup and health checks
+   - Set up proper signal handling and graceful shutdown
+   - Configure logging and output redirection
+   - Set up environment-specific configuration management
+   - Configure resource limits and performance tuning
+
+5. **Security Hardening**
+   - Run application as non-root user with minimal privileges
+   - Configure security scanning and vulnerability assessment
+   - Implement secrets management and secure credential handling
+   - Set up network security and firewall rules
+   - Configure security policies and access controls
+
+6. **Docker Compose Configuration**
+   - Create docker-compose.yml for local development
+   - Configure service dependencies and networking
+   - Set up volume mounting and data persistence
+   - Configure environment variables and secrets
+   - Set up development vs production configurations
+
+7. **Container Orchestration Preparation**
+   - Prepare configurations for Kubernetes deployment
+   - Create deployment manifests and service definitions
+   - Configure ingress and load balancing
+   - Set up persistent volumes and storage classes
+   - Configure auto-scaling and resource management
+
+8. **Monitoring and Observability**
+   - Configure application metrics and health endpoints
+   - Set up logging aggregation and centralized logging
+   - Configure distributed tracing and monitoring
+   - Set up alerting and notification systems
+   - Configure performance monitoring and profiling
+
+9. **CI/CD Integration**
+   - Configure automated Docker image building
+   - Set up image scanning and security validation
+   - Configure image registry and artifact management
+   - Set up automated deployment pipelines
+   - Configure rollback and blue-green deployment strategies
+
+10. **Testing and Validation**
+    - Test container builds and functionality
+    - Validate security configurations and compliance
+    - Test deployment in different environments
+    - Validate performance and resource utilization
+    - Test backup and disaster recovery procedures
+    - Create documentation for container deployment and management