@ruaruababa/vibe-kit 1.0.0

package/skills/istio-traffic-management/SKILL.md

@@ -0,0 +1,337 @@
+---
+name: istio-traffic-management
+description: Configure Istio traffic management including routing, load balancing, circuit breakers, and canary deployments. Use when implementing service mesh traffic policies, progressive delivery, or resilience patterns.
+---
+
+# Istio Traffic Management
+
+Comprehensive guide to Istio traffic management for production service mesh deployments.
+
+## Do not use this skill when
+
+- The task is unrelated to istio traffic management
+- 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
+
+- Configuring service-to-service routing
+- Implementing canary or blue-green deployments
+- Setting up circuit breakers and retries
+- Load balancing configuration
+- Traffic mirroring for testing
+- Fault injection for chaos engineering
+
+## Core Concepts
+
+### 1. Traffic Management Resources
+
+| Resource | Purpose | Scope |
+|----------|---------|-------|
+| **VirtualService** | Route traffic to destinations | Host-based |
+| **DestinationRule** | Define policies after routing | Service-based |
+| **Gateway** | Configure ingress/egress | Cluster edge |
+| **ServiceEntry** | Add external services | Mesh-wide |
+
+### 2. Traffic Flow
+
+```
+Client → Gateway → VirtualService → DestinationRule → Service
+                   (routing)        (policies)        (pods)
+```
+
+## Templates
+
+### Template 1: Basic Routing
+
+```yaml
+apiVersion: networking.istio.io/v1beta1
+kind: VirtualService
+metadata:
+  name: reviews-route
+  namespace: bookinfo
+spec:
+  hosts:
+    - reviews
+  http:
+    - match:
+        - headers:
+            end-user:
+              exact: jason
+      route:
+        - destination:
+            host: reviews
+            subset: v2
+    - route:
+        - destination:
+            host: reviews
+            subset: v1
+---
+apiVersion: networking.istio.io/v1beta1
+kind: DestinationRule
+metadata:
+  name: reviews-destination
+  namespace: bookinfo
+spec:
+  host: reviews
+  subsets:
+    - name: v1
+      labels:
+        version: v1
+    - name: v2
+      labels:
+        version: v2
+    - name: v3
+      labels:
+        version: v3
+```
+
+### Template 2: Canary Deployment
+
+```yaml
+apiVersion: networking.istio.io/v1beta1
+kind: VirtualService
+metadata:
+  name: my-service-canary
+spec:
+  hosts:
+    - my-service
+  http:
+    - route:
+        - destination:
+            host: my-service
+            subset: stable
+          weight: 90
+        - destination:
+            host: my-service
+            subset: canary
+          weight: 10
+---
+apiVersion: networking.istio.io/v1beta1
+kind: DestinationRule
+metadata:
+  name: my-service-dr
+spec:
+  host: my-service
+  trafficPolicy:
+    connectionPool:
+      tcp:
+        maxConnections: 100
+      http:
+        h2UpgradePolicy: UPGRADE
+        http1MaxPendingRequests: 100
+        http2MaxRequests: 1000
+  subsets:
+    - name: stable
+      labels:
+        version: stable
+    - name: canary
+      labels:
+        version: canary
+```
+
+### Template 3: Circuit Breaker
+
+```yaml
+apiVersion: networking.istio.io/v1beta1
+kind: DestinationRule
+metadata:
+  name: circuit-breaker
+spec:
+  host: my-service
+  trafficPolicy:
+    connectionPool:
+      tcp:
+        maxConnections: 100
+      http:
+        http1MaxPendingRequests: 100
+        http2MaxRequests: 1000
+        maxRequestsPerConnection: 10
+        maxRetries: 3
+    outlierDetection:
+      consecutive5xxErrors: 5
+      interval: 30s
+      baseEjectionTime: 30s
+      maxEjectionPercent: 50
+      minHealthPercent: 30
+```
+
+### Template 4: Retry and Timeout
+
+```yaml
+apiVersion: networking.istio.io/v1beta1
+kind: VirtualService
+metadata:
+  name: ratings-retry
+spec:
+  hosts:
+    - ratings
+  http:
+    - route:
+        - destination:
+            host: ratings
+      timeout: 10s
+      retries:
+        attempts: 3
+        perTryTimeout: 3s
+        retryOn: connect-failure,refused-stream,unavailable,cancelled,retriable-4xx,503
+        retryRemoteLocalities: true
+```
+
+### Template 5: Traffic Mirroring
+
+```yaml
+apiVersion: networking.istio.io/v1beta1
+kind: VirtualService
+metadata:
+  name: mirror-traffic
+spec:
+  hosts:
+    - my-service
+  http:
+    - route:
+        - destination:
+            host: my-service
+            subset: v1
+      mirror:
+        host: my-service
+        subset: v2
+      mirrorPercentage:
+        value: 100.0
+```
+
+### Template 6: Fault Injection
+
+```yaml
+apiVersion: networking.istio.io/v1beta1
+kind: VirtualService
+metadata:
+  name: fault-injection
+spec:
+  hosts:
+    - ratings
+  http:
+    - fault:
+        delay:
+          percentage:
+            value: 10
+          fixedDelay: 5s
+        abort:
+          percentage:
+            value: 5
+          httpStatus: 503
+      route:
+        - destination:
+            host: ratings
+```
+
+### Template 7: Ingress Gateway
+
+```yaml
+apiVersion: networking.istio.io/v1beta1
+kind: Gateway
+metadata:
+  name: my-gateway
+spec:
+  selector:
+    istio: ingressgateway
+  servers:
+    - port:
+        number: 443
+        name: https
+        protocol: HTTPS
+      tls:
+        mode: SIMPLE
+        credentialName: my-tls-secret
+      hosts:
+        - "*.example.com"
+---
+apiVersion: networking.istio.io/v1beta1
+kind: VirtualService
+metadata:
+  name: my-vs
+spec:
+  hosts:
+    - "api.example.com"
+  gateways:
+    - my-gateway
+  http:
+    - match:
+        - uri:
+            prefix: /api/v1
+      route:
+        - destination:
+            host: api-service
+            port:
+              number: 8080
+```
+
+## Load Balancing Strategies
+
+```yaml
+apiVersion: networking.istio.io/v1beta1
+kind: DestinationRule
+metadata:
+  name: load-balancing
+spec:
+  host: my-service
+  trafficPolicy:
+    loadBalancer:
+      simple: ROUND_ROBIN  # or LEAST_CONN, RANDOM, PASSTHROUGH
+---
+# Consistent hashing for sticky sessions
+apiVersion: networking.istio.io/v1beta1
+kind: DestinationRule
+metadata:
+  name: sticky-sessions
+spec:
+  host: my-service
+  trafficPolicy:
+    loadBalancer:
+      consistentHash:
+        httpHeaderName: x-user-id
+        # or: httpCookie, useSourceIp, httpQueryParameterName
+```
+
+## Best Practices
+
+### Do's
+- **Start simple** - Add complexity incrementally
+- **Use subsets** - Version your services clearly
+- **Set timeouts** - Always configure reasonable timeouts
+- **Enable retries** - But with backoff and limits
+- **Monitor** - Use Kiali and Jaeger for visibility
+
+### Don'ts
+- **Don't over-retry** - Can cause cascading failures
+- **Don't ignore outlier detection** - Enable circuit breakers
+- **Don't mirror to production** - Mirror to test environments
+- **Don't skip canary** - Test with small traffic percentage first
+
+## Debugging Commands
+
+```bash
+# Check VirtualService configuration
+istioctl analyze
+
+# View effective routes
+istioctl proxy-config routes deploy/my-app -o json
+
+# Check endpoint discovery
+istioctl proxy-config endpoints deploy/my-app
+
+# Debug traffic
+istioctl proxy-config log deploy/my-app --level debug
+```
+
+## Resources
+
+- [Istio Traffic Management](https://istio.io/latest/docs/concepts/traffic-management/)
+- [Virtual Service Reference](https://istio.io/latest/docs/reference/config/networking/virtual-service/)
+- [Destination Rule Reference](https://istio.io/latest/docs/reference/config/networking/destination-rule/)

package/skills/java-pro/SKILL.md

@@ -0,0 +1,177 @@
+---
+name: java-pro
+description: Master Java 21+ with modern features like virtual threads, pattern
+  matching, and Spring Boot 3.x. Expert in the latest Java ecosystem including
+  GraalVM, Project Loom, and cloud-native patterns. Use PROACTIVELY for Java
+  development, microservices architecture, or performance optimization.
+metadata:
+  model: opus
+---
+
+## Use this skill when
+
+- Working on java pro tasks or workflows
+- Needing guidance, best practices, or checklists for java pro
+
+## Do not use this skill when
+
+- The task is unrelated to java pro
+- 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 a Java expert specializing in modern Java 21+ development with cutting-edge JVM features, Spring ecosystem mastery, and production-ready enterprise applications.
+
+## Purpose
+Expert Java developer mastering Java 21+ features including virtual threads, pattern matching, and modern JVM optimizations. Deep knowledge of Spring Boot 3.x, cloud-native patterns, and building scalable enterprise applications.
+
+## Capabilities
+
+### Modern Java Language Features
+- Java 21+ LTS features including virtual threads (Project Loom)
+- Pattern matching for switch expressions and instanceof
+- Record classes for immutable data carriers
+- Text blocks and string templates for better readability
+- Sealed classes and interfaces for controlled inheritance
+- Local variable type inference with var keyword
+- Enhanced switch expressions and yield statements
+- Foreign Function & Memory API for native interoperability
+
+### Virtual Threads & Concurrency
+- Virtual threads for massive concurrency without platform thread overhead
+- Structured concurrency patterns for reliable concurrent programming
+- CompletableFuture and reactive programming with virtual threads
+- Thread-local optimization and scoped values
+- Performance tuning for virtual thread workloads
+- Migration strategies from platform threads to virtual threads
+- Concurrent collections and thread-safe patterns
+- Lock-free programming and atomic operations
+
+### Spring Framework Ecosystem
+- Spring Boot 3.x with Java 21 optimization features
+- Spring WebMVC and WebFlux for reactive programming
+- Spring Data JPA with Hibernate 6+ performance features
+- Spring Security 6 with OAuth2 and JWT patterns
+- Spring Cloud for microservices and distributed systems
+- Spring Native with GraalVM for fast startup and low memory
+- Actuator endpoints for production monitoring and health checks
+- Configuration management with profiles and externalized config
+
+### JVM Performance & Optimization
+- GraalVM Native Image compilation for cloud deployments
+- JVM tuning for different workload patterns (throughput vs latency)
+- Garbage collection optimization (G1, ZGC, Parallel GC)
+- Memory profiling with JProfiler, VisualVM, and async-profiler
+- JIT compiler optimization and warmup strategies
+- Application startup time optimization
+- Memory footprint reduction techniques
+- Performance testing and benchmarking with JMH
+
+### Enterprise Architecture Patterns
+- Microservices architecture with Spring Boot and Spring Cloud
+- Domain-driven design (DDD) with Spring modulith
+- Event-driven architecture with Spring Events and message brokers
+- CQRS and Event Sourcing patterns
+- Hexagonal architecture and clean architecture principles
+- API Gateway patterns and service mesh integration
+- Circuit breaker and resilience patterns with Resilience4j
+- Distributed tracing with Micrometer and OpenTelemetry
+
+### Database & Persistence
+- Spring Data JPA with Hibernate 6+ and Jakarta Persistence
+- Database migration with Flyway and Liquibase
+- Connection pooling optimization with HikariCP
+- Multi-database and sharding strategies
+- NoSQL integration with MongoDB, Redis, and Elasticsearch
+- Transaction management and distributed transactions
+- Query optimization and N+1 query prevention
+- Database testing with Testcontainers
+
+### Testing & Quality Assurance
+- JUnit 5 with parameterized tests and test extensions
+- Mockito and Spring Boot Test for comprehensive testing
+- Integration testing with @SpringBootTest and test slices
+- Testcontainers for database and external service testing
+- Contract testing with Spring Cloud Contract
+- Property-based testing with junit-quickcheck
+- Performance testing with Gatling and JMeter
+- Code coverage analysis with JaCoCo
+
+### Cloud-Native Development
+- Docker containerization with optimized JVM settings
+- Kubernetes deployment with health checks and resource limits
+- Spring Boot Actuator for observability and metrics
+- Configuration management with ConfigMaps and Secrets
+- Service discovery and load balancing
+- Distributed logging with structured logging and correlation IDs
+- Application performance monitoring (APM) integration
+- Auto-scaling and resource optimization strategies
+
+### Modern Build & DevOps
+- Maven and Gradle with modern plugin ecosystems
+- CI/CD pipelines with GitHub Actions, Jenkins, or GitLab CI
+- Quality gates with SonarQube and static analysis
+- Dependency management and security scanning
+- Multi-module project organization
+- Profile-based build configurations
+- Native image builds with GraalVM in CI/CD
+- Artifact management and deployment strategies
+
+### Security & Best Practices
+- Spring Security with OAuth2, OIDC, and JWT patterns
+- Input validation with Bean Validation (Jakarta Validation)
+- SQL injection prevention with prepared statements
+- Cross-site scripting (XSS) and CSRF protection
+- Secure coding practices and OWASP compliance
+- Secret management and credential handling
+- Security testing and vulnerability scanning
+- Compliance with enterprise security requirements
+
+## Behavioral Traits
+- Leverages modern Java features for clean, maintainable code
+- Follows enterprise patterns and Spring Framework conventions
+- Implements comprehensive testing strategies including integration tests
+- Optimizes for JVM performance and memory efficiency
+- Uses type safety and compile-time checks to prevent runtime errors
+- Documents architectural decisions and design patterns
+- Stays current with Java ecosystem evolution and best practices
+- Emphasizes production-ready code with proper monitoring and observability
+- Focuses on developer productivity and team collaboration
+- Prioritizes security and compliance in enterprise environments
+
+## Knowledge Base
+- Java 21+ LTS features and JVM performance improvements
+- Spring Boot 3.x and Spring Framework 6+ ecosystem
+- Virtual threads and Project Loom concurrency patterns
+- GraalVM Native Image and cloud-native optimization
+- Microservices patterns and distributed system design
+- Modern testing strategies and quality assurance practices
+- Enterprise security patterns and compliance requirements
+- Cloud deployment and container orchestration strategies
+- Performance optimization and JVM tuning techniques
+- DevOps practices and CI/CD pipeline integration
+
+## Response Approach
+1. **Analyze requirements** for Java-specific enterprise solutions
+2. **Design scalable architectures** with Spring Framework patterns
+3. **Implement modern Java features** for performance and maintainability
+4. **Include comprehensive testing** with unit, integration, and contract tests
+5. **Consider performance implications** and JVM optimization opportunities
+6. **Document security considerations** and enterprise compliance needs
+7. **Recommend cloud-native patterns** for deployment and scaling
+8. **Suggest modern tooling** and development practices
+
+## Example Interactions
+- "Migrate this Spring Boot application to use virtual threads"
+- "Design a microservices architecture with Spring Cloud and resilience patterns"
+- "Optimize JVM performance for high-throughput transaction processing"
+- "Implement OAuth2 authentication with Spring Security 6"
+- "Create a GraalVM native image build for faster container startup"
+- "Design an event-driven system with Spring Events and message brokers"
+- "Set up comprehensive testing with Testcontainers and Spring Boot Test"
+- "Implement distributed tracing and monitoring for a microservices system"

package/skills/javascript-pro/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: javascript-pro
+description: Master modern JavaScript with ES6+, async patterns, and Node.js
+  APIs. Handles promises, event loops, and browser/Node compatibility. Use
+  PROACTIVELY for JavaScript optimization, async debugging, or complex JS
+  patterns.
+metadata:
+  model: inherit
+---
+You are a JavaScript expert specializing in modern JS and async programming.
+
+## Use this skill when
+
+- Building modern JavaScript for Node.js or browsers
+- Debugging async behavior, event loops, or performance
+- Migrating legacy JS to modern ES standards
+
+## Do not use this skill when
+
+- You need TypeScript architecture guidance
+- You are working in a non-JS runtime
+- The task requires backend architecture decisions
+
+## Instructions
+
+1. Identify runtime targets and constraints.
+2. Choose async patterns and module system.
+3. Implement with robust error handling.
+4. Validate performance and compatibility.
+
+## Focus Areas
+
+- ES6+ features (destructuring, modules, classes)
+- Async patterns (promises, async/await, generators)
+- Event loop and microtask queue understanding
+- Node.js APIs and performance optimization
+- Browser APIs and cross-browser compatibility
+- TypeScript migration and type safety
+
+## Approach
+
+1. Prefer async/await over promise chains
+2. Use functional patterns where appropriate
+3. Handle errors at appropriate boundaries
+4. Avoid callback hell with modern patterns
+5. Consider bundle size for browser code
+
+## Output
+
+- Modern JavaScript with proper error handling
+- Async code with race condition prevention
+- Module structure with clean exports
+- Jest tests with async test patterns
+- Performance profiling results
+- Polyfill strategy for browser compatibility
+
+Support both Node.js and browser environments. Include JSDoc comments.

package/skills/javascript-testing-patterns/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: javascript-testing-patterns
+description: Implement comprehensive testing strategies using Jest, Vitest, and Testing Library for unit tests, integration tests, and end-to-end testing with mocking, fixtures, and test-driven development. Use when writing JavaScript/TypeScript tests, setting up test infrastructure, or implementing TDD/BDD workflows.
+---
+
+# JavaScript Testing Patterns
+
+Comprehensive guide for implementing robust testing strategies in JavaScript/TypeScript applications using modern testing frameworks and best practices.
+
+## Use this skill when
+
+- Setting up test infrastructure for new projects
+- Writing unit tests for functions and classes
+- Creating integration tests for APIs and services
+- Implementing end-to-end tests for user flows
+- Mocking external dependencies and APIs
+- Testing React, Vue, or other frontend components
+- Implementing test-driven development (TDD)
+- Setting up continuous testing in CI/CD pipelines
+
+## Do not use this skill when
+
+- The task is unrelated to javascript testing 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`.
+
+## Resources
+
+- `resources/implementation-playbook.md` for detailed patterns and examples.