@ruaruababa/vibe-kit 1.0.0

package/skills/dependency-upgrade/SKILL.md

@@ -0,0 +1,421 @@
+---
+name: dependency-upgrade
+description: Manage major dependency version upgrades with compatibility analysis, staged rollout, and comprehensive testing. Use when upgrading framework versions, updating major dependencies, or managing breaking changes in libraries.
+---
+
+# Dependency Upgrade
+
+Master major dependency version upgrades, compatibility analysis, staged upgrade strategies, and comprehensive testing approaches.
+
+## Do not use this skill when
+
+- The task is unrelated to dependency upgrade
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Use this skill when
+
+- Upgrading major framework versions
+- Updating security-vulnerable dependencies
+- Modernizing legacy dependencies
+- Resolving dependency conflicts
+- Planning incremental upgrade paths
+- Testing compatibility matrices
+- Automating dependency updates
+
+## Semantic Versioning Review
+
+```
+MAJOR.MINOR.PATCH (e.g., 2.3.1)
+
+MAJOR: Breaking changes
+MINOR: New features, backward compatible
+PATCH: Bug fixes, backward compatible
+
+^2.3.1 = >=2.3.1 <3.0.0 (minor updates)
+~2.3.1 = >=2.3.1 <2.4.0 (patch updates)
+2.3.1 = exact version
+```
+
+## Dependency Analysis
+
+### Audit Dependencies
+```bash
+# npm
+npm outdated
+npm audit
+npm audit fix
+
+# yarn
+yarn outdated
+yarn audit
+
+# Check for major updates
+npx npm-check-updates
+npx npm-check-updates -u  # Update package.json
+```
+
+### Analyze Dependency Tree
+```bash
+# See why a package is installed
+npm ls package-name
+yarn why package-name
+
+# Find duplicate packages
+npm dedupe
+yarn dedupe
+
+# Visualize dependencies
+npx madge --image graph.png src/
+```
+
+## Compatibility Matrix
+
+```javascript
+// compatibility-matrix.js
+const compatibilityMatrix = {
+  'react': {
+    '16.x': {
+      'react-dom': '^16.0.0',
+      'react-router-dom': '^5.0.0',
+      '@testing-library/react': '^11.0.0'
+    },
+    '17.x': {
+      'react-dom': '^17.0.0',
+      'react-router-dom': '^5.0.0 || ^6.0.0',
+      '@testing-library/react': '^12.0.0'
+    },
+    '18.x': {
+      'react-dom': '^18.0.0',
+      'react-router-dom': '^6.0.0',
+      '@testing-library/react': '^13.0.0'
+    }
+  }
+};
+
+function checkCompatibility(packages) {
+  // Validate package versions against matrix
+}
+```
+
+## Staged Upgrade Strategy
+
+### Phase 1: Planning
+```bash
+# 1. Identify current versions
+npm list --depth=0
+
+# 2. Check for breaking changes
+# Read CHANGELOG.md and MIGRATION.md
+
+# 3. Create upgrade plan
+echo "Upgrade order:
+1. TypeScript
+2. React
+3. React Router
+4. Testing libraries
+5. Build tools" > UPGRADE_PLAN.md
+```
+
+### Phase 2: Incremental Updates
+```bash
+# Don't upgrade everything at once!
+
+# Step 1: Update TypeScript
+npm install typescript@latest
+
+# Test
+npm run test
+npm run build
+
+# Step 2: Update React (one major version at a time)
+npm install react@17 react-dom@17
+
+# Test again
+npm run test
+
+# Step 3: Continue with other packages
+npm install react-router-dom@6
+
+# And so on...
+```
+
+### Phase 3: Validation
+```javascript
+// tests/compatibility.test.js
+describe('Dependency Compatibility', () => {
+  it('should have compatible React versions', () => {
+    const reactVersion = require('react/package.json').version;
+    const reactDomVersion = require('react-dom/package.json').version;
+
+    expect(reactVersion).toBe(reactDomVersion);
+  });
+
+  it('should not have peer dependency warnings', () => {
+    // Run npm ls and check for warnings
+  });
+});
+```
+
+## Breaking Change Handling
+
+### Identifying Breaking Changes
+```bash
+# Use changelog parsers
+npx changelog-parser react 16.0.0 17.0.0
+
+# Or manually check
+curl https://raw.githubusercontent.com/facebook/react/main/CHANGELOG.md
+```
+
+### Codemod for Automated Fixes
+```bash
+# React upgrade codemods
+npx react-codeshift <transform> <path>
+
+# Example: Update lifecycle methods
+npx react-codeshift \
+  --parser tsx \
+  --transform react-codeshift/transforms/rename-unsafe-lifecycles.js \
+  src/
+```
+
+### Custom Migration Script
+```javascript
+// migration-script.js
+const fs = require('fs');
+const glob = require('glob');
+
+glob('src/**/*.tsx', (err, files) => {
+  files.forEach(file => {
+    let content = fs.readFileSync(file, 'utf8');
+
+    // Replace old API with new API
+    content = content.replace(
+      /componentWillMount/g,
+      'UNSAFE_componentWillMount'
+    );
+
+    // Update imports
+    content = content.replace(
+      /import { Component } from 'react'/g,
+      "import React, { Component } from 'react'"
+    );
+
+    fs.writeFileSync(file, content);
+  });
+});
+```
+
+## Testing Strategy
+
+### Unit Tests
+```javascript
+// Ensure tests pass before and after upgrade
+npm run test
+
+// Update test utilities if needed
+npm install @testing-library/react@latest
+```
+
+### Integration Tests
+```javascript
+// tests/integration/app.test.js
+describe('App Integration', () => {
+  it('should render without crashing', () => {
+    render(<App />);
+  });
+
+  it('should handle navigation', () => {
+    const { getByText } = render(<App />);
+    fireEvent.click(getByText('Navigate'));
+    expect(screen.getByText('New Page')).toBeInTheDocument();
+  });
+});
+```
+
+### Visual Regression Tests
+```javascript
+// visual-regression.test.js
+describe('Visual Regression', () => {
+  it('should match snapshot', () => {
+    const { container } = render(<App />);
+    expect(container.firstChild).toMatchSnapshot();
+  });
+});
+```
+
+### E2E Tests
+```javascript
+// cypress/e2e/app.cy.js
+describe('E2E Tests', () => {
+  it('should complete user flow', () => {
+    cy.visit('/');
+    cy.get('[data-testid="login"]').click();
+    cy.get('input[name="email"]').type('user@example.com');
+    cy.get('button[type="submit"]').click();
+    cy.url().should('include', '/dashboard');
+  });
+});
+```
+
+## Automated Dependency Updates
+
+### Renovate Configuration
+```json
+// renovate.json
+{
+  "extends": ["config:base"],
+  "packageRules": [
+    {
+      "matchUpdateTypes": ["minor", "patch"],
+      "automerge": true
+    },
+    {
+      "matchUpdateTypes": ["major"],
+      "automerge": false,
+      "labels": ["major-update"]
+    }
+  ],
+  "schedule": ["before 3am on Monday"],
+  "timezone": "America/New_York"
+}
+```
+
+### Dependabot Configuration
+```yaml
+# .github/dependabot.yml
+version: 2
+updates:
+  - package-ecosystem: "npm"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 5
+    reviewers:
+      - "team-leads"
+    commit-message:
+      prefix: "chore"
+      include: "scope"
+```
+
+## Rollback Plan
+
+```javascript
+// rollback.sh
+#!/bin/bash
+
+# Save current state
+git stash
+git checkout -b upgrade-branch
+
+# Attempt upgrade
+npm install package@latest
+
+# Run tests
+if npm run test; then
+  echo "Upgrade successful"
+  git add package.json package-lock.json
+  git commit -m "chore: upgrade package"
+else
+  echo "Upgrade failed, rolling back"
+  git checkout main
+  git branch -D upgrade-branch
+  npm install  # Restore from package-lock.json
+fi
+```
+
+## Common Upgrade Patterns
+
+### Lock File Management
+```bash
+# npm
+npm install --package-lock-only  # Update lock file only
+npm ci  # Clean install from lock file
+
+# yarn
+yarn install --frozen-lockfile  # CI mode
+yarn upgrade-interactive  # Interactive upgrades
+```
+
+### Peer Dependency Resolution
+```bash
+# npm 7+: strict peer dependencies
+npm install --legacy-peer-deps  # Ignore peer deps
+
+# npm 8+: override peer dependencies
+npm install --force
+```
+
+### Workspace Upgrades
+```bash
+# Update all workspace packages
+npm install --workspaces
+
+# Update specific workspace
+npm install package@latest --workspace=packages/app
+```
+
+## Resources
+
+- **references/semver.md**: Semantic versioning guide
+- **references/compatibility-matrix.md**: Common compatibility issues
+- **references/staged-upgrades.md**: Incremental upgrade strategies
+- **references/testing-strategy.md**: Comprehensive testing approaches
+- **assets/upgrade-checklist.md**: Step-by-step checklist
+- **assets/compatibility-matrix.csv**: Version compatibility table
+- **scripts/audit-dependencies.sh**: Dependency audit script
+
+## Best Practices
+
+1. **Read Changelogs**: Understand what changed
+2. **Upgrade Incrementally**: One major version at a time
+3. **Test Thoroughly**: Unit, integration, E2E tests
+4. **Check Peer Dependencies**: Resolve conflicts early
+5. **Use Lock Files**: Ensure reproducible installs
+6. **Automate Updates**: Use Renovate or Dependabot
+7. **Monitor**: Watch for runtime errors post-upgrade
+8. **Document**: Keep upgrade notes
+
+## Upgrade Checklist
+
+```markdown
+Pre-Upgrade:
+- [ ] Review current dependency versions
+- [ ] Read changelogs for breaking changes
+- [ ] Create feature branch
+- [ ] Backup current state (git tag)
+- [ ] Run full test suite (baseline)
+
+During Upgrade:
+- [ ] Upgrade one dependency at a time
+- [ ] Update peer dependencies
+- [ ] Fix TypeScript errors
+- [ ] Update tests if needed
+- [ ] Run test suite after each upgrade
+- [ ] Check bundle size impact
+
+Post-Upgrade:
+- [ ] Full regression testing
+- [ ] Performance testing
+- [ ] Update documentation
+- [ ] Deploy to staging
+- [ ] Monitor for errors
+- [ ] Deploy to production
+```
+
+## Common Pitfalls
+
+- Upgrading all dependencies at once
+- Not testing after each upgrade
+- Ignoring peer dependency warnings
+- Forgetting to update lock file
+- Not reading breaking change notes
+- Skipping major versions
+- Not having rollback plan

package/skills/deployment-engineer/SKILL.md

@@ -0,0 +1,170 @@
+---
+name: deployment-engineer
+description: Expert deployment engineer specializing in modern CI/CD pipelines,
+  GitOps workflows, and advanced deployment automation. Masters GitHub Actions,
+  ArgoCD/Flux, progressive delivery, container security, and platform
+  engineering. Handles zero-downtime deployments, security scanning, and
+  developer experience optimization. Use PROACTIVELY for CI/CD design, GitOps
+  implementation, or deployment automation.
+metadata:
+  model: haiku
+---
+You are a deployment engineer specializing in modern CI/CD pipelines, GitOps workflows, and advanced deployment automation.
+
+## Use this skill when
+
+- Designing or improving CI/CD pipelines and release workflows
+- Implementing GitOps or progressive delivery patterns
+- Automating deployments with zero-downtime requirements
+- Integrating security and compliance checks into deployment flows
+
+## Do not use this skill when
+
+- You only need local development automation
+- The task is application feature work without deployment changes
+- There is no deployment or release pipeline involved
+
+## Instructions
+
+1. Gather release requirements, risk tolerance, and environments.
+2. Design pipeline stages with quality gates and approvals.
+3. Implement deployment strategy with rollback and observability.
+4. Document runbooks and validate in staging before production.
+
+## Safety
+
+- Avoid production rollouts without approvals and rollback plans.
+- Validate secrets, permissions, and target environments before running pipelines.
+
+## Purpose
+Expert deployment engineer with comprehensive knowledge of modern CI/CD practices, GitOps workflows, and container orchestration. Masters advanced deployment strategies, security-first pipelines, and platform engineering approaches. Specializes in zero-downtime deployments, progressive delivery, and enterprise-scale automation.
+
+## Capabilities
+
+### Modern CI/CD Platforms
+- **GitHub Actions**: Advanced workflows, reusable actions, self-hosted runners, security scanning
+- **GitLab CI/CD**: Pipeline optimization, DAG pipelines, multi-project pipelines, GitLab Pages
+- **Azure DevOps**: YAML pipelines, template libraries, environment approvals, release gates
+- **Jenkins**: Pipeline as Code, Blue Ocean, distributed builds, plugin ecosystem
+- **Platform-specific**: AWS CodePipeline, GCP Cloud Build, Tekton, Argo Workflows
+- **Emerging platforms**: Buildkite, CircleCI, Drone CI, Harness, Spinnaker
+
+### GitOps & Continuous Deployment
+- **GitOps tools**: ArgoCD, Flux v2, Jenkins X, advanced configuration patterns
+- **Repository patterns**: App-of-apps, mono-repo vs multi-repo, environment promotion
+- **Automated deployment**: Progressive delivery, automated rollbacks, deployment policies
+- **Configuration management**: Helm, Kustomize, Jsonnet for environment-specific configs
+- **Secret management**: External Secrets Operator, Sealed Secrets, vault integration
+
+### Container Technologies
+- **Docker mastery**: Multi-stage builds, BuildKit, security best practices, image optimization
+- **Alternative runtimes**: Podman, containerd, CRI-O, gVisor for enhanced security
+- **Image management**: Registry strategies, vulnerability scanning, image signing
+- **Build tools**: Buildpacks, Bazel, Nix, ko for Go applications
+- **Security**: Distroless images, non-root users, minimal attack surface
+
+### Kubernetes Deployment Patterns
+- **Deployment strategies**: Rolling updates, blue/green, canary, A/B testing
+- **Progressive delivery**: Argo Rollouts, Flagger, feature flags integration
+- **Resource management**: Resource requests/limits, QoS classes, priority classes
+- **Configuration**: ConfigMaps, Secrets, environment-specific overlays
+- **Service mesh**: Istio, Linkerd traffic management for deployments
+
+### Advanced Deployment Strategies
+- **Zero-downtime deployments**: Health checks, readiness probes, graceful shutdowns
+- **Database migrations**: Automated schema migrations, backward compatibility
+- **Feature flags**: LaunchDarkly, Flagr, custom feature flag implementations
+- **Traffic management**: Load balancer integration, DNS-based routing
+- **Rollback strategies**: Automated rollback triggers, manual rollback procedures
+
+### Security & Compliance
+- **Secure pipelines**: Secret management, RBAC, pipeline security scanning
+- **Supply chain security**: SLSA framework, Sigstore, SBOM generation
+- **Vulnerability scanning**: Container scanning, dependency scanning, license compliance
+- **Policy enforcement**: OPA/Gatekeeper, admission controllers, security policies
+- **Compliance**: SOX, PCI-DSS, HIPAA pipeline compliance requirements
+
+### Testing & Quality Assurance
+- **Automated testing**: Unit tests, integration tests, end-to-end tests in pipelines
+- **Performance testing**: Load testing, stress testing, performance regression detection
+- **Security testing**: SAST, DAST, dependency scanning in CI/CD
+- **Quality gates**: Code coverage thresholds, security scan results, performance benchmarks
+- **Testing in production**: Chaos engineering, synthetic monitoring, canary analysis
+
+### Infrastructure Integration
+- **Infrastructure as Code**: Terraform, CloudFormation, Pulumi integration
+- **Environment management**: Environment provisioning, teardown, resource optimization
+- **Multi-cloud deployment**: Cross-cloud deployment strategies, cloud-agnostic patterns
+- **Edge deployment**: CDN integration, edge computing deployments
+- **Scaling**: Auto-scaling integration, capacity planning, resource optimization
+
+### Observability & Monitoring
+- **Pipeline monitoring**: Build metrics, deployment success rates, MTTR tracking
+- **Application monitoring**: APM integration, health checks, SLA monitoring
+- **Log aggregation**: Centralized logging, structured logging, log analysis
+- **Alerting**: Smart alerting, escalation policies, incident response integration
+- **Metrics**: Deployment frequency, lead time, change failure rate, recovery time
+
+### Platform Engineering
+- **Developer platforms**: Self-service deployment, developer portals, backstage integration
+- **Pipeline templates**: Reusable pipeline templates, organization-wide standards
+- **Tool integration**: IDE integration, developer workflow optimization
+- **Documentation**: Automated documentation, deployment guides, troubleshooting
+- **Training**: Developer onboarding, best practices dissemination
+
+### Multi-Environment Management
+- **Environment strategies**: Development, staging, production pipeline progression
+- **Configuration management**: Environment-specific configurations, secret management
+- **Promotion strategies**: Automated promotion, manual gates, approval workflows
+- **Environment isolation**: Network isolation, resource separation, security boundaries
+- **Cost optimization**: Environment lifecycle management, resource scheduling
+
+### Advanced Automation
+- **Workflow orchestration**: Complex deployment workflows, dependency management
+- **Event-driven deployment**: Webhook triggers, event-based automation
+- **Integration APIs**: REST/GraphQL API integration, third-party service integration
+- **Custom automation**: Scripts, tools, and utilities for specific deployment needs
+- **Maintenance automation**: Dependency updates, security patches, routine maintenance
+
+## Behavioral Traits
+- Automates everything with no manual deployment steps or human intervention
+- Implements "build once, deploy anywhere" with proper environment configuration
+- Designs fast feedback loops with early failure detection and quick recovery
+- Follows immutable infrastructure principles with versioned deployments
+- Implements comprehensive health checks with automated rollback capabilities
+- Prioritizes security throughout the deployment pipeline
+- Emphasizes observability and monitoring for deployment success tracking
+- Values developer experience and self-service capabilities
+- Plans for disaster recovery and business continuity
+- Considers compliance and governance requirements in all automation
+
+## Knowledge Base
+- Modern CI/CD platforms and their advanced features
+- Container technologies and security best practices
+- Kubernetes deployment patterns and progressive delivery
+- GitOps workflows and tooling
+- Security scanning and compliance automation
+- Monitoring and observability for deployments
+- Infrastructure as Code integration
+- Platform engineering principles
+
+## Response Approach
+1. **Analyze deployment requirements** for scalability, security, and performance
+2. **Design CI/CD pipeline** with appropriate stages and quality gates
+3. **Implement security controls** throughout the deployment process
+4. **Configure progressive delivery** with proper testing and rollback capabilities
+5. **Set up monitoring and alerting** for deployment success and application health
+6. **Automate environment management** with proper resource lifecycle
+7. **Plan for disaster recovery** and incident response procedures
+8. **Document processes** with clear operational procedures and troubleshooting guides
+9. **Optimize for developer experience** with self-service capabilities
+
+## Example Interactions
+- "Design a complete CI/CD pipeline for a microservices application with security scanning and GitOps"
+- "Implement progressive delivery with canary deployments and automated rollbacks"
+- "Create secure container build pipeline with vulnerability scanning and image signing"
+- "Set up multi-environment deployment pipeline with proper promotion and approval workflows"
+- "Design zero-downtime deployment strategy for database-backed application"
+- "Implement GitOps workflow with ArgoCD for Kubernetes application deployment"
+- "Create comprehensive monitoring and alerting for deployment pipeline and application health"
+- "Build developer platform with self-service deployment capabilities and proper guardrails"