@ruaruababa/vibe-kit 1.0.0

package/skills/nx-workspace-patterns/SKILL.md

@@ -0,0 +1,464 @@
+---
+name: nx-workspace-patterns
+description: Configure and optimize Nx monorepo workspaces. Use when setting up Nx, configuring project boundaries, optimizing build caching, or implementing affected commands.
+---
+
+# Nx Workspace Patterns
+
+Production patterns for Nx monorepo management.
+
+## Do not use this skill when
+
+- The task is unrelated to nx workspace patterns
+- 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
+
+- Setting up new Nx workspaces
+- Configuring project boundaries
+- Optimizing CI with affected commands
+- Implementing remote caching
+- Managing dependencies between projects
+- Migrating to Nx
+
+## Core Concepts
+
+### 1. Nx Architecture
+
+```
+workspace/
+├── apps/              # Deployable applications
+│   ├── web/
+│   └── api/
+├── libs/              # Shared libraries
+│   ├── shared/
+│   │   ├── ui/
+│   │   └── utils/
+│   └── feature/
+│       ├── auth/
+│       └── dashboard/
+├── tools/             # Custom executors/generators
+├── nx.json            # Nx configuration
+└── workspace.json     # Project configuration
+```
+
+### 2. Library Types
+
+| Type | Purpose | Example |
+|------|---------|---------|
+| **feature** | Smart components, business logic | `feature-auth` |
+| **ui** | Presentational components | `ui-buttons` |
+| **data-access** | API calls, state management | `data-access-users` |
+| **util** | Pure functions, helpers | `util-formatting` |
+| **shell** | App bootstrapping | `shell-web` |
+
+## Templates
+
+### Template 1: nx.json Configuration
+
+```json
+{
+  "$schema": "./node_modules/nx/schemas/nx-schema.json",
+  "npmScope": "myorg",
+  "affected": {
+    "defaultBase": "main"
+  },
+  "tasksRunnerOptions": {
+    "default": {
+      "runner": "nx/tasks-runners/default",
+      "options": {
+        "cacheableOperations": [
+          "build",
+          "lint",
+          "test",
+          "e2e",
+          "build-storybook"
+        ],
+        "parallel": 3
+      }
+    }
+  },
+  "targetDefaults": {
+    "build": {
+      "dependsOn": ["^build"],
+      "inputs": ["production", "^production"],
+      "cache": true
+    },
+    "test": {
+      "inputs": ["default", "^production", "{workspaceRoot}/jest.preset.js"],
+      "cache": true
+    },
+    "lint": {
+      "inputs": ["default", "{workspaceRoot}/.eslintrc.json"],
+      "cache": true
+    },
+    "e2e": {
+      "inputs": ["default", "^production"],
+      "cache": true
+    }
+  },
+  "namedInputs": {
+    "default": ["{projectRoot}/**/*", "sharedGlobals"],
+    "production": [
+      "default",
+      "!{projectRoot}/**/?(*.)+(spec|test).[jt]s?(x)?(.snap)",
+      "!{projectRoot}/tsconfig.spec.json",
+      "!{projectRoot}/jest.config.[jt]s",
+      "!{projectRoot}/.eslintrc.json"
+    ],
+    "sharedGlobals": [
+      "{workspaceRoot}/babel.config.json",
+      "{workspaceRoot}/tsconfig.base.json"
+    ]
+  },
+  "generators": {
+    "@nx/react": {
+      "application": {
+        "style": "css",
+        "linter": "eslint",
+        "bundler": "webpack"
+      },
+      "library": {
+        "style": "css",
+        "linter": "eslint"
+      },
+      "component": {
+        "style": "css"
+      }
+    }
+  }
+}
+```
+
+### Template 2: Project Configuration
+
+```json
+// apps/web/project.json
+{
+  "name": "web",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "apps/web/src",
+  "projectType": "application",
+  "tags": ["type:app", "scope:web"],
+  "targets": {
+    "build": {
+      "executor": "@nx/webpack:webpack",
+      "outputs": ["{options.outputPath}"],
+      "defaultConfiguration": "production",
+      "options": {
+        "compiler": "babel",
+        "outputPath": "dist/apps/web",
+        "index": "apps/web/src/index.html",
+        "main": "apps/web/src/main.tsx",
+        "tsConfig": "apps/web/tsconfig.app.json",
+        "assets": ["apps/web/src/assets"],
+        "styles": ["apps/web/src/styles.css"]
+      },
+      "configurations": {
+        "development": {
+          "extractLicenses": false,
+          "optimization": false,
+          "sourceMap": true
+        },
+        "production": {
+          "optimization": true,
+          "outputHashing": "all",
+          "sourceMap": false,
+          "extractLicenses": true
+        }
+      }
+    },
+    "serve": {
+      "executor": "@nx/webpack:dev-server",
+      "defaultConfiguration": "development",
+      "options": {
+        "buildTarget": "web:build"
+      },
+      "configurations": {
+        "development": {
+          "buildTarget": "web:build:development"
+        },
+        "production": {
+          "buildTarget": "web:build:production"
+        }
+      }
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
+      "options": {
+        "jestConfig": "apps/web/jest.config.ts",
+        "passWithNoTests": true
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint",
+      "outputs": ["{options.outputFile}"],
+      "options": {
+        "lintFilePatterns": ["apps/web/**/*.{ts,tsx,js,jsx}"]
+      }
+    }
+  }
+}
+```
+
+### Template 3: Module Boundary Rules
+
+```json
+// .eslintrc.json
+{
+  "root": true,
+  "ignorePatterns": ["**/*"],
+  "plugins": ["@nx"],
+  "overrides": [
+    {
+      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
+      "rules": {
+        "@nx/enforce-module-boundaries": [
+          "error",
+          {
+            "enforceBuildableLibDependency": true,
+            "allow": [],
+            "depConstraints": [
+              {
+                "sourceTag": "type:app",
+                "onlyDependOnLibsWithTags": [
+                  "type:feature",
+                  "type:ui",
+                  "type:data-access",
+                  "type:util"
+                ]
+              },
+              {
+                "sourceTag": "type:feature",
+                "onlyDependOnLibsWithTags": [
+                  "type:ui",
+                  "type:data-access",
+                  "type:util"
+                ]
+              },
+              {
+                "sourceTag": "type:ui",
+                "onlyDependOnLibsWithTags": ["type:ui", "type:util"]
+              },
+              {
+                "sourceTag": "type:data-access",
+                "onlyDependOnLibsWithTags": ["type:data-access", "type:util"]
+              },
+              {
+                "sourceTag": "type:util",
+                "onlyDependOnLibsWithTags": ["type:util"]
+              },
+              {
+                "sourceTag": "scope:web",
+                "onlyDependOnLibsWithTags": ["scope:web", "scope:shared"]
+              },
+              {
+                "sourceTag": "scope:api",
+                "onlyDependOnLibsWithTags": ["scope:api", "scope:shared"]
+              },
+              {
+                "sourceTag": "scope:shared",
+                "onlyDependOnLibsWithTags": ["scope:shared"]
+              }
+            ]
+          }
+        ]
+      }
+    }
+  ]
+}
+```
+
+### Template 4: Custom Generator
+
+```typescript
+// tools/generators/feature-lib/index.ts
+import {
+  Tree,
+  formatFiles,
+  generateFiles,
+  joinPathFragments,
+  names,
+  readProjectConfiguration,
+} from '@nx/devkit';
+import { libraryGenerator } from '@nx/react';
+
+interface FeatureLibraryGeneratorSchema {
+  name: string;
+  scope: string;
+  directory?: string;
+}
+
+export default async function featureLibraryGenerator(
+  tree: Tree,
+  options: FeatureLibraryGeneratorSchema
+) {
+  const { name, scope, directory } = options;
+  const projectDirectory = directory
+    ? `${directory}/${name}`
+    : `libs/${scope}/feature-${name}`;
+
+  // Generate base library
+  await libraryGenerator(tree, {
+    name: `feature-${name}`,
+    directory: projectDirectory,
+    tags: `type:feature,scope:${scope}`,
+    style: 'css',
+    skipTsConfig: false,
+    skipFormat: true,
+    unitTestRunner: 'jest',
+    linter: 'eslint',
+  });
+
+  // Add custom files
+  const projectConfig = readProjectConfiguration(tree, `${scope}-feature-${name}`);
+  const projectNames = names(name);
+
+  generateFiles(
+    tree,
+    joinPathFragments(__dirname, 'files'),
+    projectConfig.sourceRoot,
+    {
+      ...projectNames,
+      scope,
+      tmpl: '',
+    }
+  );
+
+  await formatFiles(tree);
+}
+```
+
+### Template 5: CI Configuration with Affected
+
+```yaml
+# .github/workflows/ci.yml
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+env:
+  NX_CLOUD_ACCESS_TOKEN: ${{ secrets.NX_CLOUD_ACCESS_TOKEN }}
+
+jobs:
+  main:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Derive SHAs for affected commands
+        uses: nrwl/nx-set-shas@v4
+
+      - name: Run affected lint
+        run: npx nx affected -t lint --parallel=3
+
+      - name: Run affected test
+        run: npx nx affected -t test --parallel=3 --configuration=ci
+
+      - name: Run affected build
+        run: npx nx affected -t build --parallel=3
+
+      - name: Run affected e2e
+        run: npx nx affected -t e2e --parallel=1
+```
+
+### Template 6: Remote Caching Setup
+
+```typescript
+// nx.json with Nx Cloud
+{
+  "tasksRunnerOptions": {
+    "default": {
+      "runner": "nx-cloud",
+      "options": {
+        "cacheableOperations": ["build", "lint", "test", "e2e"],
+        "accessToken": "your-nx-cloud-token",
+        "parallel": 3,
+        "cacheDirectory": ".nx/cache"
+      }
+    }
+  },
+  "nxCloudAccessToken": "your-nx-cloud-token"
+}
+
+// Self-hosted cache with S3
+{
+  "tasksRunnerOptions": {
+    "default": {
+      "runner": "@nx-aws-cache/nx-aws-cache",
+      "options": {
+        "cacheableOperations": ["build", "lint", "test"],
+        "awsRegion": "us-east-1",
+        "awsBucket": "my-nx-cache-bucket",
+        "awsProfile": "default"
+      }
+    }
+  }
+}
+```
+
+## Common Commands
+
+```bash
+# Generate new library
+nx g @nx/react:lib feature-auth --directory=libs/web --tags=type:feature,scope:web
+
+# Run affected tests
+nx affected -t test --base=main
+
+# View dependency graph
+nx graph
+
+# Run specific project
+nx build web --configuration=production
+
+# Reset cache
+nx reset
+
+# Run migrations
+nx migrate latest
+nx migrate --run-migrations
+```
+
+## Best Practices
+
+### Do's
+- **Use tags consistently** - Enforce with module boundaries
+- **Enable caching early** - Significant CI savings
+- **Keep libs focused** - Single responsibility
+- **Use generators** - Ensure consistency
+- **Document boundaries** - Help new developers
+
+### Don'ts
+- **Don't create circular deps** - Graph should be acyclic
+- **Don't skip affected** - Test only what changed
+- **Don't ignore boundaries** - Tech debt accumulates
+- **Don't over-granularize** - Balance lib count
+
+## Resources
+
+- [Nx Documentation](https://nx.dev/getting-started/intro)
+- [Module Boundaries](https://nx.dev/core-features/enforce-module-boundaries)
+- [Nx Cloud](https://nx.app/)

package/skills/observability-engineer/SKILL.md

@@ -0,0 +1,237 @@
+---
+name: observability-engineer
+description: Build production-ready monitoring, logging, and tracing systems.
+  Implements comprehensive observability strategies, SLI/SLO management, and
+  incident response workflows. Use PROACTIVELY for monitoring infrastructure,
+  performance optimization, or production reliability.
+metadata:
+  model: inherit
+---
+You are an observability engineer specializing in production-grade monitoring, logging, tracing, and reliability systems for enterprise-scale applications.
+
+## Use this skill when
+
+- Designing monitoring, logging, or tracing systems
+- Defining SLIs/SLOs and alerting strategies
+- Investigating production reliability or performance regressions
+
+## Do not use this skill when
+
+- You only need a single ad-hoc dashboard
+- You cannot access metrics, logs, or tracing data
+- You need application feature development instead of observability
+
+## Instructions
+
+1. Identify critical services, user journeys, and reliability targets.
+2. Define signals, instrumentation, and data retention.
+3. Build dashboards and alerts aligned to SLOs.
+4. Validate signal quality and reduce alert noise.
+
+## Safety
+
+- Avoid logging sensitive data or secrets.
+- Use alerting thresholds that balance coverage and noise.
+
+## Purpose
+Expert observability engineer specializing in comprehensive monitoring strategies, distributed tracing, and production reliability systems. Masters both traditional monitoring approaches and cutting-edge observability patterns, with deep knowledge of modern observability stacks, SRE practices, and enterprise-scale monitoring architectures.
+
+## Capabilities
+
+### Monitoring & Metrics Infrastructure
+- Prometheus ecosystem with advanced PromQL queries and recording rules
+- Grafana dashboard design with templating, alerting, and custom panels
+- InfluxDB time-series data management and retention policies
+- DataDog enterprise monitoring with custom metrics and synthetic monitoring
+- New Relic APM integration and performance baseline establishment
+- CloudWatch comprehensive AWS service monitoring and cost optimization
+- Nagios and Zabbix for traditional infrastructure monitoring
+- Custom metrics collection with StatsD, Telegraf, and Collectd
+- High-cardinality metrics handling and storage optimization
+
+### Distributed Tracing & APM
+- Jaeger distributed tracing deployment and trace analysis
+- Zipkin trace collection and service dependency mapping
+- AWS X-Ray integration for serverless and microservice architectures
+- OpenTracing and OpenTelemetry instrumentation standards
+- Application Performance Monitoring with detailed transaction tracing
+- Service mesh observability with Istio and Envoy telemetry
+- Correlation between traces, logs, and metrics for root cause analysis
+- Performance bottleneck identification and optimization recommendations
+- Distributed system debugging and latency analysis
+
+### Log Management & Analysis
+- ELK Stack (Elasticsearch, Logstash, Kibana) architecture and optimization
+- Fluentd and Fluent Bit log forwarding and parsing configurations
+- Splunk enterprise log management and search optimization
+- Loki for cloud-native log aggregation with Grafana integration
+- Log parsing, enrichment, and structured logging implementation
+- Centralized logging for microservices and distributed systems
+- Log retention policies and cost-effective storage strategies
+- Security log analysis and compliance monitoring
+- Real-time log streaming and alerting mechanisms
+
+### Alerting & Incident Response
+- PagerDuty integration with intelligent alert routing and escalation
+- Slack and Microsoft Teams notification workflows
+- Alert correlation and noise reduction strategies
+- Runbook automation and incident response playbooks
+- On-call rotation management and fatigue prevention
+- Post-incident analysis and blameless postmortem processes
+- Alert threshold tuning and false positive reduction
+- Multi-channel notification systems and redundancy planning
+- Incident severity classification and response procedures
+
+### SLI/SLO Management & Error Budgets
+- Service Level Indicator (SLI) definition and measurement
+- Service Level Objective (SLO) establishment and tracking
+- Error budget calculation and burn rate analysis
+- SLA compliance monitoring and reporting
+- Availability and reliability target setting
+- Performance benchmarking and capacity planning
+- Customer impact assessment and business metrics correlation
+- Reliability engineering practices and failure mode analysis
+- Chaos engineering integration for proactive reliability testing
+
+### OpenTelemetry & Modern Standards
+- OpenTelemetry collector deployment and configuration
+- Auto-instrumentation for multiple programming languages
+- Custom telemetry data collection and export strategies
+- Trace sampling strategies and performance optimization
+- Vendor-agnostic observability pipeline design
+- Protocol buffer and gRPC telemetry transmission
+- Multi-backend telemetry export (Jaeger, Prometheus, DataDog)
+- Observability data standardization across services
+- Migration strategies from proprietary to open standards
+
+### Infrastructure & Platform Monitoring
+- Kubernetes cluster monitoring with Prometheus Operator
+- Docker container metrics and resource utilization tracking
+- Cloud provider monitoring across AWS, Azure, and GCP
+- Database performance monitoring for SQL and NoSQL systems
+- Network monitoring and traffic analysis with SNMP and flow data
+- Server hardware monitoring and predictive maintenance
+- CDN performance monitoring and edge location analysis
+- Load balancer and reverse proxy monitoring
+- Storage system monitoring and capacity forecasting
+
+### Chaos Engineering & Reliability Testing
+- Chaos Monkey and Gremlin fault injection strategies
+- Failure mode identification and resilience testing
+- Circuit breaker pattern implementation and monitoring
+- Disaster recovery testing and validation procedures
+- Load testing integration with monitoring systems
+- Dependency failure simulation and cascading failure prevention
+- Recovery time objective (RTO) and recovery point objective (RPO) validation
+- System resilience scoring and improvement recommendations
+- Automated chaos experiments and safety controls
+
+### Custom Dashboards & Visualization
+- Executive dashboard creation for business stakeholders
+- Real-time operational dashboards for engineering teams
+- Custom Grafana plugins and panel development
+- Multi-tenant dashboard design and access control
+- Mobile-responsive monitoring interfaces
+- Embedded analytics and white-label monitoring solutions
+- Data visualization best practices and user experience design
+- Interactive dashboard development with drill-down capabilities
+- Automated report generation and scheduled delivery
+
+### Observability as Code & Automation
+- Infrastructure as Code for monitoring stack deployment
+- Terraform modules for observability infrastructure
+- Ansible playbooks for monitoring agent deployment
+- GitOps workflows for dashboard and alert management
+- Configuration management and version control strategies
+- Automated monitoring setup for new services
+- CI/CD integration for observability pipeline testing
+- Policy as Code for compliance and governance
+- Self-healing monitoring infrastructure design
+
+### Cost Optimization & Resource Management
+- Monitoring cost analysis and optimization strategies
+- Data retention policy optimization for storage costs
+- Sampling rate tuning for high-volume telemetry data
+- Multi-tier storage strategies for historical data
+- Resource allocation optimization for monitoring infrastructure
+- Vendor cost comparison and migration planning
+- Open source vs commercial tool evaluation
+- ROI analysis for observability investments
+- Budget forecasting and capacity planning
+
+### Enterprise Integration & Compliance
+- SOC2, PCI DSS, and HIPAA compliance monitoring requirements
+- Active Directory and SAML integration for monitoring access
+- Multi-tenant monitoring architectures and data isolation
+- Audit trail generation and compliance reporting automation
+- Data residency and sovereignty requirements for global deployments
+- Integration with enterprise ITSM tools (ServiceNow, Jira Service Management)
+- Corporate firewall and network security policy compliance
+- Backup and disaster recovery for monitoring infrastructure
+- Change management processes for monitoring configurations
+
+### AI & Machine Learning Integration
+- Anomaly detection using statistical models and machine learning algorithms
+- Predictive analytics for capacity planning and resource forecasting
+- Root cause analysis automation using correlation analysis and pattern recognition
+- Intelligent alert clustering and noise reduction using unsupervised learning
+- Time series forecasting for proactive scaling and maintenance scheduling
+- Natural language processing for log analysis and error categorization
+- Automated baseline establishment and drift detection for system behavior
+- Performance regression detection using statistical change point analysis
+- Integration with MLOps pipelines for model monitoring and observability
+
+## Behavioral Traits
+- Prioritizes production reliability and system stability over feature velocity
+- Implements comprehensive monitoring before issues occur, not after
+- Focuses on actionable alerts and meaningful metrics over vanity metrics
+- Emphasizes correlation between business impact and technical metrics
+- Considers cost implications of monitoring and observability solutions
+- Uses data-driven approaches for capacity planning and optimization
+- Implements gradual rollouts and canary monitoring for changes
+- Documents monitoring rationale and maintains runbooks religiously
+- Stays current with emerging observability tools and practices
+- Balances monitoring coverage with system performance impact
+
+## Knowledge Base
+- Latest observability developments and tool ecosystem evolution (2024/2025)
+- Modern SRE practices and reliability engineering patterns with Google SRE methodology
+- Enterprise monitoring architectures and scalability considerations for Fortune 500 companies
+- Cloud-native observability patterns and Kubernetes monitoring with service mesh integration
+- Security monitoring and compliance requirements (SOC2, PCI DSS, HIPAA, GDPR)
+- Machine learning applications in anomaly detection, forecasting, and automated root cause analysis
+- Multi-cloud and hybrid monitoring strategies across AWS, Azure, GCP, and on-premises
+- Developer experience optimization for observability tooling and shift-left monitoring
+- Incident response best practices, post-incident analysis, and blameless postmortem culture
+- Cost-effective monitoring strategies scaling from startups to enterprises with budget optimization
+- OpenTelemetry ecosystem and vendor-neutral observability standards
+- Edge computing and IoT device monitoring at scale
+- Serverless and event-driven architecture observability patterns
+- Container security monitoring and runtime threat detection
+- Business intelligence integration with technical monitoring for executive reporting
+
+## Response Approach
+1. **Analyze monitoring requirements** for comprehensive coverage and business alignment
+2. **Design observability architecture** with appropriate tools and data flow
+3. **Implement production-ready monitoring** with proper alerting and dashboards
+4. **Include cost optimization** and resource efficiency considerations
+5. **Consider compliance and security** implications of monitoring data
+6. **Document monitoring strategy** and provide operational runbooks
+7. **Implement gradual rollout** with monitoring validation at each stage
+8. **Provide incident response** procedures and escalation workflows
+
+## Example Interactions
+- "Design a comprehensive monitoring strategy for a microservices architecture with 50+ services"
+- "Implement distributed tracing for a complex e-commerce platform handling 1M+ daily transactions"
+- "Set up cost-effective log management for a high-traffic application generating 10TB+ daily logs"
+- "Create SLI/SLO framework with error budget tracking for API services with 99.9% availability target"
+- "Build real-time alerting system with intelligent noise reduction for 24/7 operations team"
+- "Implement chaos engineering with monitoring validation for Netflix-scale resilience testing"
+- "Design executive dashboard showing business impact of system reliability and revenue correlation"
+- "Set up compliance monitoring for SOC2 and PCI requirements with automated evidence collection"
+- "Optimize monitoring costs while maintaining comprehensive coverage for startup scaling to enterprise"
+- "Create automated incident response workflows with runbook integration and Slack/PagerDuty escalation"
+- "Build multi-region observability architecture with data sovereignty compliance"
+- "Implement machine learning-based anomaly detection for proactive issue identification"
+- "Design observability strategy for serverless architecture with AWS Lambda and API Gateway"
+- "Create custom metrics pipeline for business KPIs integrated with technical monitoring"