@ngxtm/devkit 3.0.2 → 3.1.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/iterate-pr/SKILL.md

@@ -0,0 +1,150 @@
+---
+name: iterate-pr
+description: "Iterate on a PR until CI passes. Use when you need to fix CI failures, address review feedback, or continuously push fixes until all checks are green. Automates the feedback-fix-push-wait cycle."
+source: "https://github.com/getsentry/skills/tree/main/plugins/sentry-skills/skills/iterate-pr"
+risk: safe
+---
+
+# Iterate on PR Until CI Passes
+
+Continuously iterate on the current branch until all CI checks pass and review feedback is addressed.
+
+## When to Use This Skill
+
+Use this skill when:
+- Fixing CI failures
+- Addressing review feedback
+- Continuously pushing fixes until all checks are green
+- Automating the feedback-fix-push-wait cycle
+- Ensuring PR meets all quality gates
+
+**Requires**: GitHub CLI (`gh`) authenticated and available.
+
+## Process
+
+### Step 1: Identify the PR
+
+```bash
+gh pr view --json number,url,headRefName,baseRefName
+```
+
+If no PR exists for the current branch, stop and inform the user.
+
+### Step 2: Check CI Status First
+
+Always check CI/GitHub Actions status before looking at review feedback:
+
+```bash
+gh pr checks --json name,state,bucket,link,workflow
+```
+
+The `bucket` field categorizes state into: `pass`, `fail`, `pending`, `skipping`, or `cancel`.
+
+**Important:** If any of these checks are still `pending`, wait before proceeding:
+- `sentry` / `sentry-io`
+- `codecov`
+- `cursor` / `bugbot` / `seer`
+- Any linter or code analysis checks
+
+These bots may post additional feedback comments once their checks complete. Waiting avoids duplicate work.
+
+### Step 3: Gather Review Feedback
+
+Once CI checks have completed (or at least the bot-related checks), gather human and bot feedback:
+
+**Review Comments and Status:**
+```bash
+gh pr view --json reviews,comments,reviewDecision
+```
+
+**Inline Code Review Comments:**
+```bash
+gh api repos/{owner}/{repo}/pulls/{pr_number}/comments
+```
+
+**PR Conversation Comments (includes bot comments):**
+```bash
+gh api repos/{owner}/{repo}/issues/{pr_number}/comments
+```
+
+Look for bot comments from: Sentry, Codecov, Cursor, Bugbot, Seer, and other automated tools.
+
+### Step 4: Investigate Failures
+
+For each CI failure, get the actual logs:
+
+```bash
+# List recent runs for this branch
+gh run list --branch $(git branch --show-current) --limit 5 --json databaseId,name,status,conclusion
+
+# View failed logs for a specific run
+gh run view <run-id> --log-failed
+```
+
+Do NOT assume what failed based on the check name alone. Always read the actual logs.
+
+### Step 5: Validate Feedback
+
+For each piece of feedback (CI failure or review comment):
+
+1. **Read the relevant code** - Understand the context before making changes
+2. **Verify the issue is real** - Not all feedback is correct; reviewers and bots can be wrong
+3. **Check if already addressed** - The issue may have been fixed in a subsequent commit
+4. **Skip invalid feedback** - If the concern is not legitimate, move on
+
+### Step 6: Address Valid Issues
+
+Make minimal, targeted code changes. Only fix what is actually broken.
+
+### Step 7: Commit and Push
+
+```bash
+git add -A
+git commit -m "fix: <descriptive message of what was fixed>"
+git push origin $(git branch --show-current)
+```
+
+### Step 8: Wait for CI
+
+Use the built-in watch functionality:
+
+```bash
+gh pr checks --watch --interval 30
+```
+
+This waits until all checks complete. Exit code 0 means all passed, exit code 1 means failures.
+
+Alternatively, poll manually if you need more control:
+
+```bash
+gh pr checks --json name,state,bucket | jq '.[] | select(.bucket != "pass")'
+```
+
+### Step 9: Repeat
+
+Return to Step 2 if:
+- Any CI checks failed
+- New review feedback appeared
+
+Continue until all checks pass and no unaddressed feedback remains.
+
+## Exit Conditions
+
+**Success:**
+- All CI checks are green (`bucket: pass`)
+- No unaddressed human review feedback
+
+**Ask for Help:**
+- Same failure persists after 3 attempts (likely a flaky test or deeper issue)
+- Review feedback requires clarification or decision from the user
+- CI failure is unrelated to branch changes (infrastructure issue)
+
+**Stop Immediately:**
+- No PR exists for the current branch
+- Branch is out of sync and needs rebase (inform user)
+
+## Tips
+
+- Use `gh pr checks --required` to focus only on required checks
+- Use `gh run view <run-id> --verbose` to see all job steps, not just failures
+- If a check is from an external service, the `link` field in checks JSON provides the URL to investigate

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"