claude-code-templates 1.21.1 → 1.21.2

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

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

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

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