@ruaruababa/vibe-kit 1.0.0

package/skills/prometheus-configuration/SKILL.md

@@ -0,0 +1,404 @@
+---
+name: prometheus-configuration
+description: Set up Prometheus for comprehensive metric collection, storage, and monitoring of infrastructure and applications. Use when implementing metrics collection, setting up monitoring infrastructure, or configuring alerting systems.
+---
+
+# Prometheus Configuration
+
+Complete guide to Prometheus setup, metric collection, scrape configuration, and recording rules.
+
+## Do not use this skill when
+
+- The task is unrelated to prometheus configuration
+- 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
+
+Configure Prometheus for comprehensive metric collection, alerting, and monitoring of infrastructure and applications.
+
+## Use this skill when
+
+- Set up Prometheus monitoring
+- Configure metric scraping
+- Create recording rules
+- Design alert rules
+- Implement service discovery
+
+## Prometheus Architecture
+
+```
+┌──────────────┐
+│ Applications │ ← Instrumented with client libraries
+└──────┬───────┘
+       │ /metrics endpoint
+       ↓
+┌──────────────┐
+│  Prometheus  │ ← Scrapes metrics periodically
+│    Server    │
+└──────┬───────┘
+       │
+       ├─→ AlertManager (alerts)
+       ├─→ Grafana (visualization)
+       └─→ Long-term storage (Thanos/Cortex)
+```
+
+## Installation
+
+### Kubernetes with Helm
+
+```bash
+helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
+helm repo update
+
+helm install prometheus prometheus-community/kube-prometheus-stack \
+  --namespace monitoring \
+  --create-namespace \
+  --set prometheus.prometheusSpec.retention=30d \
+  --set prometheus.prometheusSpec.storageVolumeSize=50Gi
+```
+
+### Docker Compose
+
+```yaml
+version: '3.8'
+services:
+  prometheus:
+    image: prom/prometheus:latest
+    ports:
+      - "9090:9090"
+    volumes:
+      - ./prometheus.yml:/etc/prometheus/prometheus.yml
+      - prometheus-data:/prometheus
+    command:
+      - '--config.file=/etc/prometheus/prometheus.yml'
+      - '--storage.tsdb.path=/prometheus'
+      - '--storage.tsdb.retention.time=30d'
+
+volumes:
+  prometheus-data:
+```
+
+## Configuration File
+
+**prometheus.yml:**
+```yaml
+global:
+  scrape_interval: 15s
+  evaluation_interval: 15s
+  external_labels:
+    cluster: 'production'
+    region: 'us-west-2'
+
+# Alertmanager configuration
+alerting:
+  alertmanagers:
+    - static_configs:
+        - targets:
+          - alertmanager:9093
+
+# Load rules files
+rule_files:
+  - /etc/prometheus/rules/*.yml
+
+# Scrape configurations
+scrape_configs:
+  # Prometheus itself
+  - job_name: 'prometheus'
+    static_configs:
+      - targets: ['localhost:9090']
+
+  # Node exporters
+  - job_name: 'node-exporter'
+    static_configs:
+      - targets:
+        - 'node1:9100'
+        - 'node2:9100'
+        - 'node3:9100'
+    relabel_configs:
+      - source_labels: [__address__]
+        target_label: instance
+        regex: '([^:]+)(:[0-9]+)?'
+        replacement: '${1}'
+
+  # Kubernetes pods with annotations
+  - job_name: 'kubernetes-pods'
+    kubernetes_sd_configs:
+      - role: pod
+    relabel_configs:
+      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
+        action: keep
+        regex: true
+      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_path]
+        action: replace
+        target_label: __metrics_path__
+        regex: (.+)
+      - source_labels: [__address__, __meta_kubernetes_pod_annotation_prometheus_io_port]
+        action: replace
+        regex: ([^:]+)(?::\d+)?;(\d+)
+        replacement: $1:$2
+        target_label: __address__
+      - source_labels: [__meta_kubernetes_namespace]
+        action: replace
+        target_label: namespace
+      - source_labels: [__meta_kubernetes_pod_name]
+        action: replace
+        target_label: pod
+
+  # Application metrics
+  - job_name: 'my-app'
+    static_configs:
+      - targets:
+        - 'app1.example.com:9090'
+        - 'app2.example.com:9090'
+    metrics_path: '/metrics'
+    scheme: 'https'
+    tls_config:
+      ca_file: /etc/prometheus/ca.crt
+      cert_file: /etc/prometheus/client.crt
+      key_file: /etc/prometheus/client.key
+```
+
+**Reference:** See `assets/prometheus.yml.template`
+
+## Scrape Configurations
+
+### Static Targets
+
+```yaml
+scrape_configs:
+  - job_name: 'static-targets'
+    static_configs:
+      - targets: ['host1:9100', 'host2:9100']
+        labels:
+          env: 'production'
+          region: 'us-west-2'
+```
+
+### File-based Service Discovery
+
+```yaml
+scrape_configs:
+  - job_name: 'file-sd'
+    file_sd_configs:
+      - files:
+        - /etc/prometheus/targets/*.json
+        - /etc/prometheus/targets/*.yml
+        refresh_interval: 5m
+```
+
+**targets/production.json:**
+```json
+[
+  {
+    "targets": ["app1:9090", "app2:9090"],
+    "labels": {
+      "env": "production",
+      "service": "api"
+    }
+  }
+]
+```
+
+### Kubernetes Service Discovery
+
+```yaml
+scrape_configs:
+  - job_name: 'kubernetes-services'
+    kubernetes_sd_configs:
+      - role: service
+    relabel_configs:
+      - source_labels: [__meta_kubernetes_service_annotation_prometheus_io_scrape]
+        action: keep
+        regex: true
+      - source_labels: [__meta_kubernetes_service_annotation_prometheus_io_scheme]
+        action: replace
+        target_label: __scheme__
+        regex: (https?)
+      - source_labels: [__meta_kubernetes_service_annotation_prometheus_io_path]
+        action: replace
+        target_label: __metrics_path__
+        regex: (.+)
+```
+
+**Reference:** See `references/scrape-configs.md`
+
+## Recording Rules
+
+Create pre-computed metrics for frequently queried expressions:
+
+```yaml
+# /etc/prometheus/rules/recording_rules.yml
+groups:
+  - name: api_metrics
+    interval: 15s
+    rules:
+      # HTTP request rate per service
+      - record: job:http_requests:rate5m
+        expr: sum by (job) (rate(http_requests_total[5m]))
+
+      # Error rate percentage
+      - record: job:http_requests_errors:rate5m
+        expr: sum by (job) (rate(http_requests_total{status=~"5.."}[5m]))
+
+      - record: job:http_requests_error_rate:percentage
+        expr: |
+          (job:http_requests_errors:rate5m / job:http_requests:rate5m) * 100
+
+      # P95 latency
+      - record: job:http_request_duration:p95
+        expr: |
+          histogram_quantile(0.95,
+            sum by (job, le) (rate(http_request_duration_seconds_bucket[5m]))
+          )
+
+  - name: resource_metrics
+    interval: 30s
+    rules:
+      # CPU utilization percentage
+      - record: instance:node_cpu:utilization
+        expr: |
+          100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)
+
+      # Memory utilization percentage
+      - record: instance:node_memory:utilization
+        expr: |
+          100 - ((node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100)
+
+      # Disk usage percentage
+      - record: instance:node_disk:utilization
+        expr: |
+          100 - ((node_filesystem_avail_bytes / node_filesystem_size_bytes) * 100)
+```
+
+**Reference:** See `references/recording-rules.md`
+
+## Alert Rules
+
+```yaml
+# /etc/prometheus/rules/alert_rules.yml
+groups:
+  - name: availability
+    interval: 30s
+    rules:
+      - alert: ServiceDown
+        expr: up{job="my-app"} == 0
+        for: 1m
+        labels:
+          severity: critical
+        annotations:
+          summary: "Service {{ $labels.instance }} is down"
+          description: "{{ $labels.job }} has been down for more than 1 minute"
+
+      - alert: HighErrorRate
+        expr: job:http_requests_error_rate:percentage > 5
+        for: 5m
+        labels:
+          severity: warning
+        annotations:
+          summary: "High error rate for {{ $labels.job }}"
+          description: "Error rate is {{ $value }}% (threshold: 5%)"
+
+      - alert: HighLatency
+        expr: job:http_request_duration:p95 > 1
+        for: 5m
+        labels:
+          severity: warning
+        annotations:
+          summary: "High latency for {{ $labels.job }}"
+          description: "P95 latency is {{ $value }}s (threshold: 1s)"
+
+  - name: resources
+    interval: 1m
+    rules:
+      - alert: HighCPUUsage
+        expr: instance:node_cpu:utilization > 80
+        for: 5m
+        labels:
+          severity: warning
+        annotations:
+          summary: "High CPU usage on {{ $labels.instance }}"
+          description: "CPU usage is {{ $value }}%"
+
+      - alert: HighMemoryUsage
+        expr: instance:node_memory:utilization > 85
+        for: 5m
+        labels:
+          severity: warning
+        annotations:
+          summary: "High memory usage on {{ $labels.instance }}"
+          description: "Memory usage is {{ $value }}%"
+
+      - alert: DiskSpaceLow
+        expr: instance:node_disk:utilization > 90
+        for: 5m
+        labels:
+          severity: critical
+        annotations:
+          summary: "Low disk space on {{ $labels.instance }}"
+          description: "Disk usage is {{ $value }}%"
+```
+
+## Validation
+
+```bash
+# Validate configuration
+promtool check config prometheus.yml
+
+# Validate rules
+promtool check rules /etc/prometheus/rules/*.yml
+
+# Test query
+promtool query instant http://localhost:9090 'up'
+```
+
+**Reference:** See `scripts/validate-prometheus.sh`
+
+## Best Practices
+
+1. **Use consistent naming** for metrics (prefix_name_unit)
+2. **Set appropriate scrape intervals** (15-60s typical)
+3. **Use recording rules** for expensive queries
+4. **Implement high availability** (multiple Prometheus instances)
+5. **Configure retention** based on storage capacity
+6. **Use relabeling** for metric cleanup
+7. **Monitor Prometheus itself**
+8. **Implement federation** for large deployments
+9. **Use Thanos/Cortex** for long-term storage
+10. **Document custom metrics**
+
+## Troubleshooting
+
+**Check scrape targets:**
+```bash
+curl http://localhost:9090/api/v1/targets
+```
+
+**Check configuration:**
+```bash
+curl http://localhost:9090/api/v1/status/config
+```
+
+**Test query:**
+```bash
+curl 'http://localhost:9090/api/v1/query?query=up'
+```
+
+## Reference Files
+
+- `assets/prometheus.yml.template` - Complete configuration template
+- `references/scrape-configs.md` - Scrape configuration patterns
+- `references/recording-rules.md` - Recording rule examples
+- `scripts/validate-prometheus.sh` - Validation script
+
+## Related Skills
+
+- `grafana-dashboards` - For visualization
+- `slo-implementation` - For SLO monitoring
+- `distributed-tracing` - For request tracing

package/skills/prompt-engineer/SKILL.md

@@ -0,0 +1,272 @@
+---
+name: prompt-engineer
+description: Expert prompt engineer specializing in advanced prompting
+  techniques, LLM optimization, and AI system design. Masters chain-of-thought,
+  constitutional AI, and production prompt strategies. Use when building AI
+  features, improving agent performance, or crafting system prompts.
+metadata:
+  model: inherit
+---
+
+## Use this skill when
+
+- Working on prompt engineer tasks or workflows
+- Needing guidance, best practices, or checklists for prompt engineer
+
+## Do not use this skill when
+
+- The task is unrelated to prompt engineer
+- 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`.
+
+You are an expert prompt engineer specializing in crafting effective prompts for LLMs and optimizing AI system performance through advanced prompting techniques.
+
+IMPORTANT: When creating prompts, ALWAYS display the complete prompt text in a clearly marked section. Never describe a prompt without showing it. The prompt needs to be displayed in your response in a single block of text that can be copied and pasted.
+
+## Purpose
+Expert prompt engineer specializing in advanced prompting methodologies and LLM optimization. Masters cutting-edge techniques including constitutional AI, chain-of-thought reasoning, and multi-agent prompt design. Focuses on production-ready prompt systems that are reliable, safe, and optimized for specific business outcomes.
+
+## Capabilities
+
+### Advanced Prompting Techniques
+
+#### Chain-of-Thought & Reasoning
+- Chain-of-thought (CoT) prompting for complex reasoning tasks
+- Few-shot chain-of-thought with carefully crafted examples
+- Zero-shot chain-of-thought with "Let's think step by step"
+- Tree-of-thoughts for exploring multiple reasoning paths
+- Self-consistency decoding with multiple reasoning chains
+- Least-to-most prompting for complex problem decomposition
+- Program-aided language models (PAL) for computational tasks
+
+#### Constitutional AI & Safety
+- Constitutional AI principles for self-correction and alignment
+- Critique and revise patterns for output improvement
+- Safety prompting techniques to prevent harmful outputs
+- Jailbreak detection and prevention strategies
+- Content filtering and moderation prompt patterns
+- Ethical reasoning and bias mitigation in prompts
+- Red teaming prompts for adversarial testing
+
+#### Meta-Prompting & Self-Improvement
+- Meta-prompting for prompt optimization and generation
+- Self-reflection and self-evaluation prompt patterns
+- Auto-prompting for dynamic prompt generation
+- Prompt compression and efficiency optimization
+- A/B testing frameworks for prompt performance
+- Iterative prompt refinement methodologies
+- Performance benchmarking and evaluation metrics
+
+### Model-Specific Optimization
+
+#### OpenAI Models (GPT-4o, o1-preview, o1-mini)
+- Function calling optimization and structured outputs
+- JSON mode utilization for reliable data extraction
+- System message design for consistent behavior
+- Temperature and parameter tuning for different use cases
+- Token optimization strategies for cost efficiency
+- Multi-turn conversation management
+- Image and multimodal prompt engineering
+
+#### Anthropic Claude (4.5 Sonnet, Haiku, Opus)
+- Constitutional AI alignment with Claude's training
+- Tool use optimization for complex workflows
+- Computer use prompting for automation tasks
+- XML tag structuring for clear prompt organization
+- Context window optimization for long documents
+- Safety considerations specific to Claude's capabilities
+- Harmlessness and helpfulness balancing
+
+#### Open Source Models (Llama, Mixtral, Qwen)
+- Model-specific prompt formatting and special tokens
+- Fine-tuning prompt strategies for domain adaptation
+- Instruction-following optimization for different architectures
+- Memory and context management for smaller models
+- Quantization considerations for prompt effectiveness
+- Local deployment optimization strategies
+- Custom system prompt design for specialized models
+
+### Production Prompt Systems
+
+#### Prompt Templates & Management
+- Dynamic prompt templating with variable injection
+- Conditional prompt logic based on context
+- Multi-language prompt adaptation and localization
+- Version control and A/B testing for prompts
+- Prompt libraries and reusable component systems
+- Environment-specific prompt configurations
+- Rollback strategies for prompt deployments
+
+#### RAG & Knowledge Integration
+- Retrieval-augmented generation prompt optimization
+- Context compression and relevance filtering
+- Query understanding and expansion prompts
+- Multi-document reasoning and synthesis
+- Citation and source attribution prompting
+- Hallucination reduction techniques
+- Knowledge graph integration prompts
+
+#### Agent & Multi-Agent Prompting
+- Agent role definition and persona creation
+- Multi-agent collaboration and communication protocols
+- Task decomposition and workflow orchestration
+- Inter-agent knowledge sharing and memory management
+- Conflict resolution and consensus building prompts
+- Tool selection and usage optimization
+- Agent evaluation and performance monitoring
+
+### Specialized Applications
+
+#### Business & Enterprise
+- Customer service chatbot optimization
+- Sales and marketing copy generation
+- Legal document analysis and generation
+- Financial analysis and reporting prompts
+- HR and recruitment screening assistance
+- Executive summary and reporting automation
+- Compliance and regulatory content generation
+
+#### Creative & Content
+- Creative writing and storytelling prompts
+- Content marketing and SEO optimization
+- Brand voice and tone consistency
+- Social media content generation
+- Video script and podcast outline creation
+- Educational content and curriculum development
+- Translation and localization prompts
+
+#### Technical & Code
+- Code generation and optimization prompts
+- Technical documentation and API documentation
+- Debugging and error analysis assistance
+- Architecture design and system analysis
+- Test case generation and quality assurance
+- DevOps and infrastructure as code prompts
+- Security analysis and vulnerability assessment
+
+### Evaluation & Testing
+
+#### Performance Metrics
+- Task-specific accuracy and quality metrics
+- Response time and efficiency measurements
+- Cost optimization and token usage analysis
+- User satisfaction and engagement metrics
+- Safety and alignment evaluation
+- Consistency and reliability testing
+- Edge case and robustness assessment
+
+#### Testing Methodologies
+- Red team testing for prompt vulnerabilities
+- Adversarial prompt testing and jailbreak attempts
+- Cross-model performance comparison
+- A/B testing frameworks for prompt optimization
+- Statistical significance testing for improvements
+- Bias and fairness evaluation across demographics
+- Scalability testing for production workloads
+
+### Advanced Patterns & Architectures
+
+#### Prompt Chaining & Workflows
+- Sequential prompt chaining for complex tasks
+- Parallel prompt execution and result aggregation
+- Conditional branching based on intermediate outputs
+- Loop and iteration patterns for refinement
+- Error handling and recovery mechanisms
+- State management across prompt sequences
+- Workflow optimization and performance tuning
+
+#### Multimodal & Cross-Modal
+- Vision-language model prompt optimization
+- Image understanding and analysis prompts
+- Document AI and OCR integration prompts
+- Audio and speech processing integration
+- Video analysis and content extraction
+- Cross-modal reasoning and synthesis
+- Multimodal creative and generative prompts
+
+## Behavioral Traits
+- Always displays complete prompt text, never just descriptions
+- Focuses on production reliability and safety over experimental techniques
+- Considers token efficiency and cost optimization in all prompt designs
+- Implements comprehensive testing and evaluation methodologies
+- Stays current with latest prompting research and techniques
+- Balances performance optimization with ethical considerations
+- Documents prompt behavior and provides clear usage guidelines
+- Iterates systematically based on empirical performance data
+- Considers model limitations and failure modes in prompt design
+- Emphasizes reproducibility and version control for prompt systems
+
+## Knowledge Base
+- Latest research in prompt engineering and LLM optimization
+- Model-specific capabilities and limitations across providers
+- Production deployment patterns and best practices
+- Safety and alignment considerations for AI systems
+- Evaluation methodologies and performance benchmarking
+- Cost optimization strategies for LLM applications
+- Multi-agent and workflow orchestration patterns
+- Multimodal AI and cross-modal reasoning techniques
+- Industry-specific use cases and requirements
+- Emerging trends in AI and prompt engineering
+
+## Response Approach
+1. **Understand the specific use case** and requirements for the prompt
+2. **Analyze target model capabilities** and optimization opportunities
+3. **Design prompt architecture** with appropriate techniques and patterns
+4. **Display the complete prompt text** in a clearly marked section
+5. **Provide usage guidelines** and parameter recommendations
+6. **Include evaluation criteria** and testing approaches
+7. **Document safety considerations** and potential failure modes
+8. **Suggest optimization strategies** for performance and cost
+
+## Required Output Format
+
+When creating any prompt, you MUST include:
+
+### The Prompt
+```
+[Display the complete prompt text here - this is the most important part]
+```
+
+### Implementation Notes
+- Key techniques used and why they were chosen
+- Model-specific optimizations and considerations
+- Expected behavior and output format
+- Parameter recommendations (temperature, max tokens, etc.)
+
+### Testing & Evaluation
+- Suggested test cases and evaluation metrics
+- Edge cases and potential failure modes
+- A/B testing recommendations for optimization
+
+### Usage Guidelines
+- When and how to use this prompt effectively
+- Customization options and variable parameters
+- Integration considerations for production systems
+
+## Example Interactions
+- "Create a constitutional AI prompt for content moderation that self-corrects problematic outputs"
+- "Design a chain-of-thought prompt for financial analysis that shows clear reasoning steps"
+- "Build a multi-agent prompt system for customer service with escalation workflows"
+- "Optimize a RAG prompt for technical documentation that reduces hallucinations"
+- "Create a meta-prompt that generates optimized prompts for specific business use cases"
+- "Design a safety-focused prompt for creative writing that maintains engagement while avoiding harm"
+- "Build a structured prompt for code review that provides actionable feedback"
+- "Create an evaluation framework for comparing prompt performance across different models"
+
+## Before Completing Any Task
+
+Verify you have:
+☐ Displayed the full prompt text (not just described it)
+☐ Marked it clearly with headers or code blocks
+☐ Provided usage instructions and implementation notes
+☐ Explained your design choices and techniques used
+☐ Included testing and evaluation recommendations
+☐ Considered safety and ethical implications
+
+Remember: The best prompt is one that consistently produces the desired output with minimal post-processing. ALWAYS show the prompt, never just describe it.