claude-code-templates 1.20.3 → 1.21.1

package/cli-tool/components/commands/deployment/rollback-deploy.md

@@ -0,0 +1,145 @@
+---
+allowed-tools: Read, Edit, Bash
+argument-hint: [target-version] | --previous | --emergency | --validate-first | --with-db
+description: Rollback deployment to previous version with safety checks, database considerations, and monitoring
+model: sonnet
+---
+
+# Deployment Rollback
+
+Rollback deployment to previous version: $ARGUMENTS
+
+## Current Deployment State
+
+- Current version: !`curl -s https://api.example.com/version 2>/dev/null || kubectl get deployments -o wide 2>/dev/null | head -3 || echo "Version detection needed"`
+- Available versions: !`git tag --sort=-version:refname | head -5`
+- Container status: !`docker ps --format "table {{.Names}}\t{{.Image}}\t{{.Status}}" 2>/dev/null | head -5 || echo "No containers"`
+- K8s deployments: !`kubectl get deployments 2>/dev/null || echo "No K8s access"`
+- Health status: !`curl -sf https://api.example.com/health 2>/dev/null && echo "✅ Healthy" || echo "❌ Unhealthy"`
+
+## Emergency Rollback Protocol
+
+Systematic rollback procedure: $ARGUMENTS
+
+1. **Incident Assessment and Decision**
+   - Assess the severity and impact of the current deployment issues
+   - Determine if rollback is necessary or if forward fix is better
+   - Identify affected systems, users, and business functions
+   - Consider data integrity and consistency implications
+   - Document the decision rationale and timeline
+
+2. **Emergency Response Setup**
+   ```bash
+   # Activate incident response team
+   # Set up communication channels
+   # Notify stakeholders immediately
+   
+   # Example emergency notification
+   echo "🚨 ROLLBACK INITIATED
+   Issue: Critical performance degradation after v1.3.0 deployment
+   Action: Rolling back to v1.2.9
+   ETA: 15 minutes
+   Impact: Temporary service interruption possible
+   Status channel: #incident-rollback-202401"
+   ```
+
+3. **Pre-Rollback Safety Checks**
+   ```bash
+   # Verify current production version
+   curl -s https://api.example.com/version
+   kubectl get deployments -o wide
+   
+   # Check system status
+   curl -s https://api.example.com/health | jq .
+   
+   # Identify target rollback version
+   git tag --sort=-version:refname | head -5
+   
+   # Verify rollback target exists and is deployable
+   git show v1.2.9 --stat
+   ```
+
+4. **Database Considerations**
+   ```bash
+   # Check for database migrations since last version
+   ./check-migrations.sh v1.2.9 v1.3.0
+   
+   # If migrations exist, plan database rollback
+   # WARNING: Database rollbacks can cause data loss
+   # Consider forward fix instead if migrations are present
+   
+   # Create database backup before rollback
+   ./backup-database.sh "pre-rollback-$(date +%Y%m%d-%H%M%S)"
+   ```
+
+5. **Traffic Management Preparation**
+   ```bash
+   # Prepare to redirect traffic
+   # Option 1: Maintenance page
+   ./enable-maintenance-mode.sh
+   
+   # Option 2: Load balancer management
+   ./drain-traffic.sh --gradual
+   
+   # Option 3: Circuit breaker activation
+   ./activate-circuit-breaker.sh
+   ```
+
+6. **Container/Kubernetes Rollback**
+   ```bash
+   # Kubernetes rollback
+   kubectl rollout history deployment/app-deployment
+   kubectl rollout undo deployment/app-deployment
+   
+   # Or rollback to specific revision
+   kubectl rollout undo deployment/app-deployment --to-revision=3
+   
+   # Monitor rollback progress
+   kubectl rollout status deployment/app-deployment --timeout=300s
+   
+   # Verify pods are running
+   kubectl get pods -l app=your-app
+   ```
+
+7. **Docker Swarm Rollback**
+   ```bash
+   # List service history
+   docker service ps app-service --no-trunc
+   
+   # Rollback to previous version
+   docker service update --rollback app-service
+   
+   # Or update to specific image
+   docker service update --image app:v1.2.9 app-service
+   
+   # Monitor rollback
+   docker service ps app-service
+   ```
+
+8. **Traditional Deployment Rollback**
+   ```bash
+   # Blue-Green deployment rollback
+   ./switch-to-blue.sh  # or green, depending on current
+   
+   # Rolling deployment rollback
+   ./deploy-version.sh v1.2.9 --rolling
+   
+   # Symlink-based rollback
+   ln -sfn /releases/v1.2.9 /current
+   sudo systemctl restart app-service
+   ```
+
+9. **Load Balancer and CDN Updates**
+   ```bash
+   # Update load balancer to point to old version
+   aws elbv2 modify-target-group --target-group-arn $TG_ARN --targets Id=old-instance
+   
+   # Clear CDN cache if needed
+   aws cloudfront create-invalidation --distribution-id $DIST_ID --paths \"/*\"
+   
+   # Update DNS if necessary (last resort, has propagation delay)
+   # aws route53 change-resource-record-sets ...
+   ```
+
+10. **Configuration Rollback**
+    ```bash\n    # Rollback configuration files\n    git checkout v1.2.9 -- config/\n    \n    # Restart services with old configuration\n    sudo systemctl restart nginx\n    sudo systemctl restart app-service\n    \n    # Rollback environment variables\n    ./restore-env-vars.sh v1.2.9\n    \n    # Update feature flags\n    ./update-feature-flags.sh --disable-new-features\n    ```\n\n11. **Database Rollback (if necessary)**\n    ```sql\n    -- EXTREME CAUTION: Can cause data loss\n    \n    -- Check migration status\n    SELECT * FROM schema_migrations ORDER BY version DESC LIMIT 5;\n    \n    -- Rollback specific migrations (framework dependent)\n    -- Rails: rake db:migrate:down VERSION=20240115120000\n    -- Django: python manage.py migrate app_name 0001\n    -- Node.js: npm run migrate:down\n    \n    -- Verify database state\n    SHOW TABLES;\n    DESCRIBE critical_table;\n    ```\n\n12. **Service Health Validation**\n    ```bash\n    # Health check script\n    #!/bin/bash\n    \n    echo \"Validating rollback...\"\n    \n    # Check application health\n    if curl -f -s https://api.example.com/health > /dev/null; then\n        echo \"✅ Health check passed\"\n    else\n        echo \"❌ Health check failed\"\n        exit 1\n    fi\n    \n    # Check critical endpoints\n    endpoints=(\n        \"/api/users/me\"\n        \"/api/auth/status\"\n        \"/api/data/latest\"\n    )\n    \n    for endpoint in \"${endpoints[@]}\"; do\n        if curl -f -s \"https://api.example.com$endpoint\" > /dev/null; then\n            echo \"✅ $endpoint working\"\n        else\n            echo \"❌ $endpoint failed\"\n        fi\n    done\n    ```\n\n13. **Performance and Metrics Validation**\n    ```bash\n    # Check response times\n    curl -w \"Response time: %{time_total}s\\n\" -s -o /dev/null https://api.example.com/\n    \n    # Monitor error rates\n    tail -f /var/log/app/error.log | head -20\n    \n    # Check system resources\n    top -bn1 | head -10\n    free -h\n    df -h\n    \n    # Validate database connectivity\n    mysql -u app -p -e \"SELECT 1;\"\n    ```\n\n14. **Traffic Restoration**\n    ```bash\n    # Gradually restore traffic\n    ./restore-traffic.sh --gradual\n    \n    # Disable maintenance mode\n    ./disable-maintenance-mode.sh\n    \n    # Re-enable circuit breakers\n    ./deactivate-circuit-breaker.sh\n    \n    # Monitor traffic patterns\n    ./monitor-traffic.sh --duration 300\n    ```\n\n15. **Monitoring and Alerting**\n    ```bash\n    # Enable enhanced monitoring during rollback\n    ./enable-enhanced-monitoring.sh\n    \n    # Watch key metrics\n    watch -n 10 'curl -s https://api.example.com/metrics | jq .'\n    \n    # Monitor logs in real-time\n    tail -f /var/log/app/*.log | grep -E \"ERROR|WARN|EXCEPTION\"\n    \n    # Check application metrics\n    # - Response times\n    # - Error rates\n    # - User sessions\n    # - Database performance\n    ```\n\n16. **User Communication**\n    ```markdown\n    ## Service Update - Rollback Completed\n    \n    **Status:** ✅ Service Restored\n    **Time:** 2024-01-15 15:45 UTC\n    **Duration:** 12 minutes of degraded performance\n    \n    **What Happened:**\n    We identified performance issues with our latest release and \n    performed a rollback to ensure optimal service quality.\n    \n    **Current Status:**\n    - All services operating normally\n    - Performance metrics back to baseline\n    - No data loss occurred\n    \n    **Next Steps:**\n    We're investigating the root cause and will provide updates \n    on our status page.\n    ```\n\n17. **Post-Rollback Validation**\n    ```bash\n    # Extended monitoring period\n    ./monitor-extended.sh --duration 3600  # 1 hour\n    \n    # Run integration tests\n    npm run test:integration:production\n    \n    # Check user-reported issues\n    ./check-support-tickets.sh --since \"1 hour ago\"\n    \n    # Validate business metrics\n    ./check-business-metrics.sh\n    ```\n\n18. **Documentation and Reporting**\n    ```markdown\n    # Rollback Incident Report\n    \n    **Incident ID:** INC-2024-0115-001\n    **Rollback Version:** v1.2.9 (from v1.3.0)\n    **Start Time:** 2024-01-15 15:30 UTC\n    **End Time:** 2024-01-15 15:42 UTC\n    **Total Duration:** 12 minutes\n    \n    **Timeline:**\n    - 15:25 - Performance degradation detected\n    - 15:30 - Rollback decision made\n    - 15:32 - Traffic drained\n    - 15:35 - Rollback initiated\n    - 15:38 - Rollback completed\n    - 15:42 - Traffic fully restored\n    \n    **Impact:**\n    - 12 minutes of degraded performance\n    - ~5% of users experienced slow responses\n    - No data loss or corruption\n    - No security implications\n    \n    **Root Cause:**\n    Memory leak in new feature causing performance degradation\n    \n    **Lessons Learned:**\n    - Need better performance testing in staging\n    - Improve monitoring for memory usage\n    - Consider canary deployments for major releases\n    ```\n\n19. **Cleanup and Follow-up**\n    ```bash\n    # Clean up failed deployment artifacts\n    docker image rm app:v1.3.0\n    \n    # Update deployment status\n    ./update-deployment-status.sh \"rollback-completed\"\n    \n    # Reset feature flags if needed\n    ./reset-feature-flags.sh\n    \n    # Schedule post-incident review\n    ./schedule-postmortem.sh --date \"2024-01-16 10:00\"\n    ```\n\n20. **Prevention and Improvement**\n    - Analyze what went wrong with the deployment\n    - Improve testing and validation procedures\n    - Enhance monitoring and alerting\n    - Update rollback procedures based on learnings\n    - Consider implementing canary deployments\n\n**Rollback Decision Matrix:**\n\n| Issue Severity | Data Impact | Time to Fix | Decision |\n|---------------|-------------|-------------|----------|\n| Critical | None | > 30 min | Rollback |\n| High | Minor | > 60 min | Rollback |\n| Medium | None | > 2 hours | Consider rollback |\n| Low | None | Any | Forward fix |\n\n**Emergency Rollback Script Template:**\n```bash\n#!/bin/bash\nset -e\n\n# Emergency rollback script\nPREVIOUS_VERSION=\"${1:-v1.2.9}\"\nCURRENT_VERSION=$(curl -s https://api.example.com/version)\n\necho \"🚨 EMERGENCY ROLLBACK\"\necho \"From: $CURRENT_VERSION\"\necho \"To: $PREVIOUS_VERSION\"\necho \"\"\n\n# Confirm rollback\nread -p \"Proceed with rollback? (yes/no): \" confirm\nif [ \"$confirm\" != \"yes\" ]; then\n    echo \"Rollback cancelled\"\n    exit 1\nfi\n\n# Execute rollback\necho \"Starting rollback...\"\nkubectl set image deployment/app-deployment app=app:$PREVIOUS_VERSION\nkubectl rollout status deployment/app-deployment --timeout=300s\n\n# Validate\necho \"Validating rollback...\"\nsleep 30\ncurl -f https://api.example.com/health\n\necho \"✅ Rollback completed successfully\"\n```\n\nRemember: Rollbacks should be a last resort. Always consider forward fixes first, especially when database migrations are involved.

package/cli-tool/components/commands/deployment/setup-automated-releases.md

@@ -0,0 +1,143 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [release-type] | --semantic | --conventional-commits | --github-actions | --full-automation
+description: Setup automated release workflows with semantic versioning, conventional commits, and comprehensive automation
+model: sonnet
+---
+
+# Automated Release System
+
+Setup automated release workflows: $ARGUMENTS
+
+## Current Project Analysis
+
+- Project structure: @package.json or @setup.py or @go.mod (detect project type)
+- Existing workflows: !`find .github/workflows -name "*.yml" 2>/dev/null | head -3`
+- Current versioning: @package.json version or git tags analysis
+- Commit patterns: !`git log --oneline -20 | grep -E "^(feat|fix|docs|style|refactor|test|chore)" | wc -l || echo "0"` conventional commits
+- Release history: !`git tag -l | wc -l || echo "0"` existing releases
+
+## Task
+
+Implement comprehensive automated release system:
+
+1. **Analyze Repository Structure**
+   - Detect project type (Node.js, Python, Go, etc.)
+   - Check for existing CI/CD workflows
+   - Identify current versioning approach
+   - Review existing release processes
+
+2. **Create Version Tracking**
+   - For Node.js: Use package.json version field
+   - For Python: Use __version__ in __init__.py or pyproject.toml
+   - For Go: Use version in go.mod
+   - For others: Create version.txt file
+   - Ensure version follows semantic versioning (MAJOR.MINOR.PATCH)
+
+3. **Set Up Conventional Commits**
+   - Create CONTRIBUTING.md with commit conventions:
+     - `feat:` for new features (minor bump)
+     - `fix:` for bug fixes (patch bump)
+     - `feat!:` or `BREAKING CHANGE:` for breaking changes (major bump)
+     - `docs:`, `chore:`, `style:`, `refactor:`, `test:` for non-releasing changes
+   - Include examples and guidelines for each type
+
+4. **Create Pull Request Template**
+   - Add `.github/pull_request_template.md`
+   - Include conventional commit reminder
+   - Add checklist for common requirements
+   - Reference contributing guidelines
+
+5. **Create Release Workflow**
+   - Add `.github/workflows/release.yml`:
+     - Trigger on push to main branch
+     - Analyze commits since last release
+     - Determine version bump type
+     - Update version in appropriate file(s)
+     - Generate release notes from commits
+     - Update CHANGELOG.md
+     - Create git tag
+     - Create GitHub Release
+     - Attach distribution artifacts
+   - Include manual trigger option for forced releases
+
+6. **Create PR Validation Workflow**
+   - Add `.github/workflows/pr-check.yml`:
+     - Validate PR title follows conventional format
+     - Check commit messages
+     - Provide feedback on version impact
+     - Run tests and quality checks
+
+7. **Configure GitHub Release Notes**
+   - Create `.github/release.yml`
+   - Define categories for different change types
+   - Configure changelog exclusions
+   - Set up contributor recognition
+
+8. **Update Documentation**
+   - Add release badges to README:
+     - Current version badge
+     - Latest release badge
+     - Build status badge
+   - Document release process
+   - Add link to CONTRIBUTING.md
+   - Explain version bump rules
+
+9. **Set Up Changelog Management**
+   - Ensure CHANGELOG.md follows Keep a Changelog format
+   - Add [Unreleased] section for upcoming changes
+   - Configure automatic changelog updates
+   - Set up changelog categories
+
+10. **Configure Branch Protection**
+    - Recommend branch protection rules:
+      - Require PR reviews
+      - Require status checks
+      - Require conventional PR titles
+      - Dismiss stale reviews
+    - Document recommended settings
+
+11. **Add Security Scanning**
+    - Set up Dependabot for dependency updates
+    - Configure security alerts
+    - Add security policy if needed
+
+12. **Test the System**
+    - Create example PR with conventional title
+    - Verify PR checks work correctly
+    - Test manual release trigger
+    - Validate changelog generation
+
+Arguments: $ARGUMENTS
+
+### Additional Considerations
+
+**For Monorepos:**
+- Set up independent versioning per package
+- Configure changelog per package
+- Use conventional commits scopes
+
+**For Libraries:**
+- Include API compatibility checks
+- Generate API documentation
+- Add upgrade guides for breaking changes
+
+**For Applications:**
+- Include Docker image versioning
+- Set up deployment triggers
+- Add rollback procedures
+
+**Best Practices:**
+- Always create release branches for hotfixes
+- Use release candidates for major versions
+- Maintain upgrade guides
+- Keep releases small and frequent
+- Document rollback procedures
+
+This automated release system provides:
+- ✅ Consistent versioning
+- ✅ Automatic changelog generation
+- ✅ Clear contribution guidelines
+- ✅ Professional release notes
+- ✅ Reduced manual work
+- ✅ Better project maintainability

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

@@ -0,0 +1,93 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [deployment-type] | --microservices | --monolith | --stateful | --full-stack | --production-ready
+description: Configure comprehensive Kubernetes deployment with manifests, security, scaling, and production best practices
+model: sonnet
+---
+
+# Kubernetes Deployment Configuration
+
+Configure Kubernetes deployment: $ARGUMENTS
+
+## Current Environment Analysis
+
+- Application type: @package.json or @Dockerfile (detect containerization readiness)
+- Existing K8s config: !`find . -name "*.yaml" -o -name "*.yml" | grep -E "(k8s|kubernetes|deployment|service)" | head -3`
+- Cluster access: !`kubectl cluster-info 2>/dev/null | head -2 || echo "No cluster access"`
+- Container registry: @docker-compose.yml or check for registry configuration
+- Resource requirements: Analysis needed based on application type
+
+## Task
+
+Implement production-ready Kubernetes deployment:
+
+1. **Kubernetes Architecture Planning**
+   - Analyze application architecture and deployment requirements
+   - Define resource requirements (CPU, memory, storage, network)
+   - Plan namespace organization and multi-tenancy strategy
+   - Assess high availability and disaster recovery requirements
+   - Define scaling strategies and performance requirements
+
+2. **Cluster Setup and Configuration**
+   - Set up Kubernetes cluster (managed or self-hosted)
+   - Configure cluster networking and CNI plugin
+   - Set up cluster storage classes and persistent volumes
+   - Configure cluster security policies and RBAC
+   - Set up cluster monitoring and logging infrastructure
+
+3. **Application Containerization**
+   - Ensure application is properly containerized
+   - Optimize container images for Kubernetes deployment
+   - Configure multi-stage builds and security scanning
+   - Set up container registry and image management
+   - Configure image pull policies and secrets
+
+4. **Kubernetes Manifest Creation**
+   - Create Deployment manifests with proper resource limits
+   - Set up Service manifests for internal and external communication
+   - Configure ConfigMaps and Secrets for configuration management
+   - Create PersistentVolumeClaims for data storage
+   - Set up NetworkPolicies for security and isolation
+
+5. **Load Balancing and Ingress**
+   - Configure Ingress controllers and routing rules
+   - Set up SSL/TLS termination and certificate management
+   - Configure load balancing strategies and session affinity
+   - Set up external DNS and domain management
+   - Configure traffic management and canary deployments
+
+6. **Auto-scaling Configuration**
+   - Set up Horizontal Pod Autoscaler (HPA) based on metrics
+   - Configure Vertical Pod Autoscaler (VPA) for resource optimization
+   - Set up Cluster Autoscaler for node scaling
+   - Configure custom metrics and scaling policies
+   - Set up resource quotas and limits
+
+7. **Health Checks and Monitoring**
+   - Configure liveness and readiness probes
+   - Set up startup probes for slow-starting applications
+   - Configure health check endpoints and monitoring
+   - Set up application metrics collection
+   - Configure alerting and notification systems
+
+8. **Security and Compliance**
+   - Configure Pod Security Standards and policies
+   - Set up network segmentation and security policies
+   - Configure service accounts and RBAC permissions
+   - Set up secret management and rotation
+   - Configure security scanning and compliance monitoring
+
+9. **CI/CD Integration**
+   - Set up automated Kubernetes deployment pipelines
+   - Configure GitOps workflows with ArgoCD or Flux
+   - Set up automated testing in Kubernetes environments
+   - Configure blue-green and canary deployment strategies
+   - Set up rollback and disaster recovery procedures
+
+10. **Operations and Maintenance**
+    - Set up cluster maintenance and update procedures
+    - Configure backup and disaster recovery strategies
+    - Set up cost optimization and resource management
+    - Create operational runbooks and troubleshooting guides
+    - Train team on Kubernetes operations and best practices
+    - Set up cluster lifecycle management and governance

package/cli-tool/components/commands/documentation/create-architecture-documentation.md

@@ -0,0 +1,95 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [framework] | --c4-model | --arc42 | --adr | --plantuml | --full-suite
+description: Generate comprehensive architecture documentation with diagrams, ADRs, and interactive visualization
+model: sonnet
+---
+
+# Architecture Documentation Generator
+
+Generate comprehensive architecture documentation: $ARGUMENTS
+
+## Current Architecture Context
+
+- Project structure: !`find . -type f -name "*.json" -o -name "*.yaml" -o -name "*.toml" | head -5`
+- Documentation exists: @docs/ or @README.md (if exists)
+- Architecture files: !`find . -name "*architecture*" -o -name "*design*" -o -name "*.puml" | head -3`
+- Services/containers: @docker-compose.yml or @k8s/ (if exists)
+- API definitions: !`find . -name "*api*" -o -name "*openapi*" -o -name "*swagger*" | head -3`
+
+## Task
+
+Generate comprehensive architecture documentation with modern tooling and best practices:
+
+1. **Architecture Analysis and Discovery**
+   - Analyze current system architecture and component relationships
+   - Identify key architectural patterns and design decisions
+   - Document system boundaries, interfaces, and dependencies
+   - Assess data flow and communication patterns
+   - Identify architectural debt and improvement opportunities
+
+2. **Architecture Documentation Framework**
+   - Choose appropriate documentation framework and tools:
+     - **C4 Model**: Context, Containers, Components, Code diagrams
+     - **Arc42**: Comprehensive architecture documentation template
+     - **Architecture Decision Records (ADRs)**: Decision documentation
+     - **PlantUML/Mermaid**: Diagram-as-code documentation
+     - **Structurizr**: C4 model tooling and visualization
+     - **Draw.io/Lucidchart**: Visual diagramming tools
+
+3. **System Context Documentation**
+   - Create high-level system context diagrams
+   - Document external systems and integrations
+   - Define system boundaries and responsibilities
+   - Document user personas and stakeholders
+   - Create system landscape and ecosystem overview
+
+4. **Container and Service Architecture**
+   - Document container/service architecture and deployment view
+   - Create service dependency maps and communication patterns
+   - Document deployment architecture and infrastructure
+   - Define service boundaries and API contracts
+   - Document data persistence and storage architecture
+
+5. **Component and Module Documentation**
+   - Create detailed component architecture diagrams
+   - Document internal module structure and relationships
+   - Define component responsibilities and interfaces
+   - Document design patterns and architectural styles
+   - Create code organization and package structure documentation
+
+6. **Data Architecture Documentation**
+   - Document data models and database schemas
+   - Create data flow diagrams and processing pipelines
+   - Document data storage strategies and technologies
+   - Define data governance and lifecycle management
+   - Create data integration and synchronization documentation
+
+7. **Security and Compliance Architecture**
+   - Document security architecture and threat model
+   - Create authentication and authorization flow diagrams
+   - Document compliance requirements and controls
+   - Define security boundaries and trust zones
+   - Create incident response and security monitoring documentation
+
+8. **Quality Attributes and Cross-Cutting Concerns**
+   - Document performance characteristics and scalability patterns
+   - Create reliability and availability architecture documentation
+   - Document monitoring and observability architecture
+   - Define maintainability and evolution strategies
+   - Create disaster recovery and business continuity documentation
+
+9. **Architecture Decision Records (ADRs)**
+   - Create comprehensive ADR template and process
+   - Document historical architectural decisions and rationale
+   - Create decision tracking and review process
+   - Document trade-offs and alternatives considered
+   - Set up ADR maintenance and evolution procedures
+
+10. **Documentation Automation and Maintenance**
+    - Set up automated diagram generation from code annotations
+    - Configure documentation pipeline and publishing automation
+    - Set up documentation validation and consistency checking
+    - Create documentation review and approval process
+    - Train team on architecture documentation practices and tools
+    - Set up documentation versioning and change management

package/cli-tool/components/commands/documentation/create-onboarding-guide.md

@@ -0,0 +1,93 @@
+---
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: [role-type] | --developer | --designer | --devops | --comprehensive | --interactive
+description: Create comprehensive developer onboarding guide with environment setup, workflows, and interactive tutorials
+model: sonnet
+---
+
+# Developer Onboarding Guide Generator
+
+Create developer onboarding guide: $ARGUMENTS
+
+## Current Team Context
+
+- Project setup: @package.json or @requirements.txt or @Cargo.toml (detect tech stack)
+- Existing docs: @docs/ or @README.md (if exists)
+- Development tools: !`find . -name ".env*" -o -name "docker-compose.yml" -o -name "Makefile" | head -3`
+- Team structure: @CODEOWNERS or @.github/ (if exists)
+- CI/CD setup: !`find .github/workflows -name "*.yml" 2>/dev/null | head -3`
+
+## Task
+
+Create comprehensive onboarding experience tailored to role and project needs:
+
+1. **Onboarding Requirements Analysis**
+   - Analyze current team structure and skill requirements
+   - Identify key knowledge areas and learning objectives
+   - Assess current onboarding challenges and pain points
+   - Define onboarding timeline and milestone expectations
+   - Document role-specific requirements and responsibilities
+
+2. **Development Environment Setup Guide**
+   - Create comprehensive development environment setup instructions
+   - Document required tools, software, and system requirements
+   - Provide step-by-step installation and configuration guides
+   - Create environment validation and troubleshooting procedures
+   - Set up automated environment setup scripts and tools
+
+3. **Project and Codebase Overview**
+   - Create high-level project overview and business context
+   - Document system architecture and technology stack
+   - Provide codebase structure and organization guide
+   - Create code navigation and exploration guidelines
+   - Document key modules, libraries, and frameworks used
+
+4. **Development Workflow Documentation**
+   - Document version control workflows and branching strategies
+   - Create code review process and quality standards guide
+   - Document testing practices and requirements
+   - Provide deployment and release process overview
+   - Create issue tracking and project management workflow guide
+
+5. **Team Communication and Collaboration**
+   - Document team communication channels and protocols
+   - Create meeting schedules and participation guidelines
+   - Provide team contact information and org chart
+   - Document collaboration tools and access procedures
+   - Create escalation procedures and support contacts
+
+6. **Learning Resources and Training Materials**
+   - Curate learning resources for project-specific technologies
+   - Create hands-on tutorials and coding exercises
+   - Provide links to documentation, wikis, and knowledge bases
+   - Create video tutorials and screen recordings
+   - Set up mentoring and buddy system procedures
+
+7. **First Tasks and Milestones**
+   - Create progressive difficulty task assignments
+   - Define learning milestones and checkpoints
+   - Provide "good first issues" and starter projects
+   - Create hands-on coding challenges and exercises
+   - Set up pair programming and shadowing opportunities
+
+8. **Security and Compliance Training**
+   - Document security policies and access controls
+   - Create data handling and privacy guidelines
+   - Provide compliance training and certification requirements
+   - Document incident response and security procedures
+   - Create security best practices and guidelines
+
+9. **Tools and Resources Access**
+   - Document required accounts and access requests
+   - Create tool-specific setup and usage guides
+   - Provide license and subscription information
+   - Document VPN and network access procedures
+   - Create troubleshooting guides for common access issues
+
+10. **Feedback and Continuous Improvement**
+    - Create onboarding feedback collection process
+    - Set up regular check-ins and progress reviews
+    - Document common questions and FAQ section
+    - Create onboarding metrics and success tracking
+    - Establish onboarding guide maintenance and update procedures
+    - Set up new hire success monitoring and support systems