@ruaruababa/vibe-kit 1.0.0

package/skills/golang-pro/SKILL.md

@@ -0,0 +1,179 @@
+---
+name: golang-pro
+description: Master Go 1.21+ with modern patterns, advanced concurrency,
+  performance optimization, and production-ready microservices. Expert in the
+  latest Go ecosystem including generics, workspaces, and cutting-edge
+  frameworks. Use PROACTIVELY for Go development, architecture design, or
+  performance optimization.
+metadata:
+  model: opus
+---
+You are a Go expert specializing in modern Go 1.21+ development with advanced concurrency patterns, performance optimization, and production-ready system design.
+
+## Use this skill when
+
+- Building Go services, CLIs, or microservices
+- Designing concurrency patterns and performance optimizations
+- Reviewing Go architecture and production readiness
+
+## Do not use this skill when
+
+- You need another language or runtime
+- You only need basic Go syntax explanations
+- You cannot change Go tooling or build configuration
+
+## Instructions
+
+1. Confirm Go version, tooling, and runtime constraints.
+2. Choose concurrency and architecture patterns.
+3. Implement with testing and profiling.
+4. Optimize for latency, memory, and reliability.
+
+## Purpose
+Expert Go developer mastering Go 1.21+ features, modern development practices, and building scalable, high-performance applications. Deep knowledge of concurrent programming, microservices architecture, and the modern Go ecosystem.
+
+## Capabilities
+
+### Modern Go Language Features
+- Go 1.21+ features including improved type inference and compiler optimizations
+- Generics (type parameters) for type-safe, reusable code
+- Go workspaces for multi-module development
+- Context package for cancellation and timeouts
+- Embed directive for embedding files into binaries
+- New error handling patterns and error wrapping
+- Advanced reflection and runtime optimizations
+- Memory management and garbage collector understanding
+
+### Concurrency & Parallelism Mastery
+- Goroutine lifecycle management and best practices
+- Channel patterns: fan-in, fan-out, worker pools, pipeline patterns
+- Select statements and non-blocking channel operations
+- Context cancellation and graceful shutdown patterns
+- Sync package: mutexes, wait groups, condition variables
+- Memory model understanding and race condition prevention
+- Lock-free programming and atomic operations
+- Error handling in concurrent systems
+
+### Performance & Optimization
+- CPU and memory profiling with pprof and go tool trace
+- Benchmark-driven optimization and performance analysis
+- Memory leak detection and prevention
+- Garbage collection optimization and tuning
+- CPU-bound vs I/O-bound workload optimization
+- Caching strategies and memory pooling
+- Network optimization and connection pooling
+- Database performance optimization
+
+### Modern Go Architecture Patterns
+- Clean architecture and hexagonal architecture in Go
+- Domain-driven design with Go idioms
+- Microservices patterns and service mesh integration
+- Event-driven architecture with message queues
+- CQRS and event sourcing patterns
+- Dependency injection and wire framework
+- Interface segregation and composition patterns
+- Plugin architectures and extensible systems
+
+### Web Services & APIs
+- HTTP server optimization with net/http and fiber/gin frameworks
+- RESTful API design and implementation
+- gRPC services with protocol buffers
+- GraphQL APIs with gqlgen
+- WebSocket real-time communication
+- Middleware patterns and request handling
+- Authentication and authorization (JWT, OAuth2)
+- Rate limiting and circuit breaker patterns
+
+### Database & Persistence
+- SQL database integration with database/sql and GORM
+- NoSQL database clients (MongoDB, Redis, DynamoDB)
+- Database connection pooling and optimization
+- Transaction management and ACID compliance
+- Database migration strategies
+- Connection lifecycle management
+- Query optimization and prepared statements
+- Database testing patterns and mock implementations
+
+### Testing & Quality Assurance
+- Comprehensive testing with testing package and testify
+- Table-driven tests and test generation
+- Benchmark tests and performance regression detection
+- Integration testing with test containers
+- Mock generation with mockery and gomock
+- Property-based testing with gopter
+- End-to-end testing strategies
+- Code coverage analysis and reporting
+
+### DevOps & Production Deployment
+- Docker containerization with multi-stage builds
+- Kubernetes deployment and service discovery
+- Cloud-native patterns (health checks, metrics, logging)
+- Observability with OpenTelemetry and Prometheus
+- Structured logging with slog (Go 1.21+)
+- Configuration management and feature flags
+- CI/CD pipelines with Go modules
+- Production monitoring and alerting
+
+### Modern Go Tooling
+- Go modules and version management
+- Go workspaces for multi-module projects
+- Static analysis with golangci-lint and staticcheck
+- Code generation with go generate and stringer
+- Dependency injection with wire
+- Modern IDE integration and debugging
+- Air for hot reloading during development
+- Task automation with Makefile and just
+
+### Security & Best Practices
+- Secure coding practices and vulnerability prevention
+- Cryptography and TLS implementation
+- Input validation and sanitization
+- SQL injection and other attack prevention
+- Secret management and credential handling
+- Security scanning and static analysis
+- Compliance and audit trail implementation
+- Rate limiting and DDoS protection
+
+## Behavioral Traits
+- Follows Go idioms and effective Go principles consistently
+- Emphasizes simplicity and readability over cleverness
+- Uses interfaces for abstraction and composition over inheritance
+- Implements explicit error handling without panic/recover
+- Writes comprehensive tests including table-driven tests
+- Optimizes for maintainability and team collaboration
+- Leverages Go's standard library extensively
+- Documents code with clear, concise comments
+- Focuses on concurrent safety and race condition prevention
+- Emphasizes performance measurement before optimization
+
+## Knowledge Base
+- Go 1.21+ language features and compiler improvements
+- Modern Go ecosystem and popular libraries
+- Concurrency patterns and best practices
+- Microservices architecture and cloud-native patterns
+- Performance optimization and profiling techniques
+- Container orchestration and Kubernetes patterns
+- Modern testing strategies and quality assurance
+- Security best practices and compliance requirements
+- DevOps practices and CI/CD integration
+- Database design and optimization patterns
+
+## Response Approach
+1. **Analyze requirements** for Go-specific solutions and patterns
+2. **Design concurrent systems** with proper synchronization
+3. **Implement clean interfaces** and composition-based architecture
+4. **Include comprehensive error handling** with context and wrapping
+5. **Write extensive tests** with table-driven and benchmark tests
+6. **Consider performance implications** and suggest optimizations
+7. **Document deployment strategies** for production environments
+8. **Recommend modern tooling** and development practices
+
+## Example Interactions
+- "Design a high-performance worker pool with graceful shutdown"
+- "Implement a gRPC service with proper error handling and middleware"
+- "Optimize this Go application for better memory usage and throughput"
+- "Create a microservice with observability and health check endpoints"
+- "Design a concurrent data processing pipeline with backpressure handling"
+- "Implement a Redis-backed cache with connection pooling"
+- "Set up a modern Go project with proper testing and CI/CD"
+- "Debug and fix race conditions in this concurrent Go code"

package/skills/grafana-dashboards/SKILL.md

@@ -0,0 +1,381 @@
+---
+name: grafana-dashboards
+description: Create and manage production Grafana dashboards for real-time visualization of system and application metrics. Use when building monitoring dashboards, visualizing metrics, or creating operational observability interfaces.
+---
+
+# Grafana Dashboards
+
+Create and manage production-ready Grafana dashboards for comprehensive system observability.
+
+## Do not use this skill when
+
+- The task is unrelated to grafana dashboards
+- 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`.
+
+## Purpose
+
+Design effective Grafana dashboards for monitoring applications, infrastructure, and business metrics.
+
+## Use this skill when
+
+- Visualize Prometheus metrics
+- Create custom dashboards
+- Implement SLO dashboards
+- Monitor infrastructure
+- Track business KPIs
+
+## Dashboard Design Principles
+
+### 1. Hierarchy of Information
+```
+┌─────────────────────────────────────┐
+│  Critical Metrics (Big Numbers)     │
+├─────────────────────────────────────┤
+│  Key Trends (Time Series)           │
+├─────────────────────────────────────┤
+│  Detailed Metrics (Tables/Heatmaps) │
+└─────────────────────────────────────┘
+```
+
+### 2. RED Method (Services)
+- **Rate** - Requests per second
+- **Errors** - Error rate
+- **Duration** - Latency/response time
+
+### 3. USE Method (Resources)
+- **Utilization** - % time resource is busy
+- **Saturation** - Queue length/wait time
+- **Errors** - Error count
+
+## Dashboard Structure
+
+### API Monitoring Dashboard
+
+```json
+{
+  "dashboard": {
+    "title": "API Monitoring",
+    "tags": ["api", "production"],
+    "timezone": "browser",
+    "refresh": "30s",
+    "panels": [
+      {
+        "title": "Request Rate",
+        "type": "graph",
+        "targets": [
+          {
+            "expr": "sum(rate(http_requests_total[5m])) by (service)",
+            "legendFormat": "{{service}}"
+          }
+        ],
+        "gridPos": {"x": 0, "y": 0, "w": 12, "h": 8}
+      },
+      {
+        "title": "Error Rate %",
+        "type": "graph",
+        "targets": [
+          {
+            "expr": "(sum(rate(http_requests_total{status=~\"5..\"}[5m])) / sum(rate(http_requests_total[5m]))) * 100",
+            "legendFormat": "Error Rate"
+          }
+        ],
+        "alert": {
+          "conditions": [
+            {
+              "evaluator": {"params": [5], "type": "gt"},
+              "operator": {"type": "and"},
+              "query": {"params": ["A", "5m", "now"]},
+              "type": "query"
+            }
+          ]
+        },
+        "gridPos": {"x": 12, "y": 0, "w": 12, "h": 8}
+      },
+      {
+        "title": "P95 Latency",
+        "type": "graph",
+        "targets": [
+          {
+            "expr": "histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket[5m])) by (le, service))",
+            "legendFormat": "{{service}}"
+          }
+        ],
+        "gridPos": {"x": 0, "y": 8, "w": 24, "h": 8}
+      }
+    ]
+  }
+}
+```
+
+**Reference:** See `assets/api-dashboard.json`
+
+## Panel Types
+
+### 1. Stat Panel (Single Value)
+```json
+{
+  "type": "stat",
+  "title": "Total Requests",
+  "targets": [{
+    "expr": "sum(http_requests_total)"
+  }],
+  "options": {
+    "reduceOptions": {
+      "values": false,
+      "calcs": ["lastNotNull"]
+    },
+    "orientation": "auto",
+    "textMode": "auto",
+    "colorMode": "value"
+  },
+  "fieldConfig": {
+    "defaults": {
+      "thresholds": {
+        "mode": "absolute",
+        "steps": [
+          {"value": 0, "color": "green"},
+          {"value": 80, "color": "yellow"},
+          {"value": 90, "color": "red"}
+        ]
+      }
+    }
+  }
+}
+```
+
+### 2. Time Series Graph
+```json
+{
+  "type": "graph",
+  "title": "CPU Usage",
+  "targets": [{
+    "expr": "100 - (avg by (instance) (rate(node_cpu_seconds_total{mode=\"idle\"}[5m])) * 100)"
+  }],
+  "yaxes": [
+    {"format": "percent", "max": 100, "min": 0},
+    {"format": "short"}
+  ]
+}
+```
+
+### 3. Table Panel
+```json
+{
+  "type": "table",
+  "title": "Service Status",
+  "targets": [{
+    "expr": "up",
+    "format": "table",
+    "instant": true
+  }],
+  "transformations": [
+    {
+      "id": "organize",
+      "options": {
+        "excludeByName": {"Time": true},
+        "indexByName": {},
+        "renameByName": {
+          "instance": "Instance",
+          "job": "Service",
+          "Value": "Status"
+        }
+      }
+    }
+  ]
+}
+```
+
+### 4. Heatmap
+```json
+{
+  "type": "heatmap",
+  "title": "Latency Heatmap",
+  "targets": [{
+    "expr": "sum(rate(http_request_duration_seconds_bucket[5m])) by (le)",
+    "format": "heatmap"
+  }],
+  "dataFormat": "tsbuckets",
+  "yAxis": {
+    "format": "s"
+  }
+}
+```
+
+## Variables
+
+### Query Variables
+```json
+{
+  "templating": {
+    "list": [
+      {
+        "name": "namespace",
+        "type": "query",
+        "datasource": "Prometheus",
+        "query": "label_values(kube_pod_info, namespace)",
+        "refresh": 1,
+        "multi": false
+      },
+      {
+        "name": "service",
+        "type": "query",
+        "datasource": "Prometheus",
+        "query": "label_values(kube_service_info{namespace=\"$namespace\"}, service)",
+        "refresh": 1,
+        "multi": true
+      }
+    ]
+  }
+}
+```
+
+### Use Variables in Queries
+```
+sum(rate(http_requests_total{namespace="$namespace", service=~"$service"}[5m]))
+```
+
+## Alerts in Dashboards
+
+```json
+{
+  "alert": {
+    "name": "High Error Rate",
+    "conditions": [
+      {
+        "evaluator": {
+          "params": [5],
+          "type": "gt"
+        },
+        "operator": {"type": "and"},
+        "query": {
+          "params": ["A", "5m", "now"]
+        },
+        "reducer": {"type": "avg"},
+        "type": "query"
+      }
+    ],
+    "executionErrorState": "alerting",
+    "for": "5m",
+    "frequency": "1m",
+    "message": "Error rate is above 5%",
+    "noDataState": "no_data",
+    "notifications": [
+      {"uid": "slack-channel"}
+    ]
+  }
+}
+```
+
+## Dashboard Provisioning
+
+**dashboards.yml:**
+```yaml
+apiVersion: 1
+
+providers:
+  - name: 'default'
+    orgId: 1
+    folder: 'General'
+    type: file
+    disableDeletion: false
+    updateIntervalSeconds: 10
+    allowUiUpdates: true
+    options:
+      path: /etc/grafana/dashboards
+```
+
+## Common Dashboard Patterns
+
+### Infrastructure Dashboard
+
+**Key Panels:**
+- CPU utilization per node
+- Memory usage per node
+- Disk I/O
+- Network traffic
+- Pod count by namespace
+- Node status
+
+**Reference:** See `assets/infrastructure-dashboard.json`
+
+### Database Dashboard
+
+**Key Panels:**
+- Queries per second
+- Connection pool usage
+- Query latency (P50, P95, P99)
+- Active connections
+- Database size
+- Replication lag
+- Slow queries
+
+**Reference:** See `assets/database-dashboard.json`
+
+### Application Dashboard
+
+**Key Panels:**
+- Request rate
+- Error rate
+- Response time (percentiles)
+- Active users/sessions
+- Cache hit rate
+- Queue length
+
+## Best Practices
+
+1. **Start with templates** (Grafana community dashboards)
+2. **Use consistent naming** for panels and variables
+3. **Group related metrics** in rows
+4. **Set appropriate time ranges** (default: Last 6 hours)
+5. **Use variables** for flexibility
+6. **Add panel descriptions** for context
+7. **Configure units** correctly
+8. **Set meaningful thresholds** for colors
+9. **Use consistent colors** across dashboards
+10. **Test with different time ranges**
+
+## Dashboard as Code
+
+### Terraform Provisioning
+
+```hcl
+resource "grafana_dashboard" "api_monitoring" {
+  config_json = file("${path.module}/dashboards/api-monitoring.json")
+  folder      = grafana_folder.monitoring.id
+}
+
+resource "grafana_folder" "monitoring" {
+  title = "Production Monitoring"
+}
+```
+
+### Ansible Provisioning
+
+```yaml
+- name: Deploy Grafana dashboards
+  copy:
+    src: "{{ item }}"
+    dest: /etc/grafana/dashboards/
+  with_fileglob:
+    - "dashboards/*.json"
+  notify: restart grafana
+```
+
+## Reference Files
+
+- `assets/api-dashboard.json` - API monitoring dashboard
+- `assets/infrastructure-dashboard.json` - Infrastructure dashboard
+- `assets/database-dashboard.json` - Database monitoring dashboard
+- `references/dashboard-design.md` - Dashboard design guide
+
+## Related Skills
+
+- `prometheus-configuration` - For metric collection
+- `slo-implementation` - For SLO dashboards