@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.7

package/assets/skills/chaos-engineering-resilience/SKILL.md

@@ -0,0 +1,158 @@
+---
+name: chaos-engineering-resilience
+description: "Chaos engineering principles, controlled failure injection, resilience testing, and system recovery validation. Use when testing distributed systems, building confidence in fault tolerance, or validating disaster recovery."
+category: specialized-testing
+priority: high
+tokenEstimate: 900
+agents: [qe-chaos-engineer, qe-performance-tester, qe-production-intelligence]
+implementation_status: optimized
+optimization_version: 1.0
+last_optimized: 2025-12-02
+dependencies: []
+quick_reference_card: true
+tags: [chaos, resilience, fault-injection, distributed-systems, recovery, netflix]
+---
+
+# Chaos Engineering & Resilience Testing
+
+<default_to_action>
+When testing system resilience or injecting failures:
+1. DEFINE steady state (normal metrics: error rate, latency, throughput)
+2. HYPOTHESIZE system continues in steady state during failure
+3. INJECT real-world failures (network, instance, disk, CPU)
+4. OBSERVE and measure deviation from steady state
+5. FIX weaknesses discovered, document runbooks, repeat
+
+**Quick Chaos Steps:**
+- Start small: Dev → Staging → 1% prod → gradual rollout
+- Define clear rollback triggers (error_rate > 5%)
+- Measure blast radius, never exceed planned scope
+- Document findings → runbooks → improved resilience
+
+**Critical Success Factors:**
+- Controlled experiments with automatic rollback
+- Steady state must be measurable
+- Start in non-production, graduate to production
+</default_to_action>
+
+## Quick Reference Card
+
+### When to Use
+- Distributed systems validation
+- Disaster recovery testing
+- Building confidence in fault tolerance
+- Pre-production resilience verification
+
+### Failure Types to Inject
+| Category | Failures | Tools |
+|----------|----------|-------|
+| **Network** | Latency, packet loss, partition | tc, toxiproxy |
+| **Infrastructure** | Instance kill, disk failure, CPU | Chaos Monkey |
+| **Application** | Exceptions, slow responses, leaks | Gremlin, LitmusChaos |
+| **Dependencies** | Service outage, timeout | WireMock |
+
+### Blast Radius Progression
+```
+Dev (safe) → Staging → 1% prod → 10% → 50% → 100%
+     ↓           ↓         ↓        ↓
+  Learn      Validate   Careful   Full confidence
+```
+
+### Steady State Metrics
+| Metric | Normal | Alert Threshold |
+|--------|--------|-----------------|
+| Error rate | < 0.1% | > 1% |
+| p99 latency | < 200ms | > 500ms |
+| Throughput | baseline | -20% |
+
+---
+
+## Chaos Experiment Structure
+
+```typescript
+// Chaos experiment definition
+const experiment = {
+  name: 'Database latency injection',
+  hypothesis: 'System handles 500ms DB latency gracefully',
+  steadyState: {
+    errorRate: '< 0.1%',
+    p99Latency: '< 300ms'
+  },
+  method: {
+    type: 'network-latency',
+    target: 'database',
+    delay: '500ms',
+    duration: '5m'
+  },
+  rollback: {
+    automatic: true,
+    trigger: 'errorRate > 5%'
+  }
+};
+```
+
+---
+
+## Agent-Driven Chaos
+
+```typescript
+// qe-chaos-engineer runs controlled experiments
+await Task("Chaos Experiment", {
+  target: 'payment-service',
+  failure: 'terminate-random-instance',
+  blastRadius: '10%',
+  duration: '5m',
+  steadyStateHypothesis: {
+    metric: 'success-rate',
+    threshold: 0.99
+  },
+  autoRollback: true
+}, "qe-chaos-engineer");
+
+// Validates:
+// - System recovers automatically
+// - Error rate stays within threshold
+// - No data loss
+// - Alerts triggered appropriately
+```
+
+---
+
+## Agent Coordination Hints
+
+### Memory Namespace
+```
+aqe/chaos-engineering/
+├── experiments/*       - Experiment definitions & results
+├── steady-states/*     - Baseline measurements
+├── runbooks/*          - Generated recovery procedures
+└── blast-radius/*      - Impact analysis
+```
+
+### Fleet Coordination
+```typescript
+const chaosFleet = await FleetManager.coordinate({
+  strategy: 'chaos-engineering',
+  agents: [
+    'qe-chaos-engineer',          // Experiment execution
+    'qe-performance-tester',      // Baseline metrics
+    'qe-production-intelligence'  // Production monitoring
+  ],
+  topology: 'sequential'
+});
+```
+
+---
+
+## Related Skills
+- [shift-right-testing](../shift-right-testing/) - Production testing
+- [performance-testing](../performance-testing/) - Load testing
+- [test-environment-management](../test-environment-management/) - Environment stability
+
+---
+
+## Remember
+
+**Break things on purpose to prevent unplanned outages.** Find weaknesses before users do. Define steady state, inject failures, measure impact, fix weaknesses, create runbooks. Start small, increase blast radius gradually.
+
+**With Agents:** `qe-chaos-engineer` automates chaos experiments with blast radius control, automatic rollback, and comprehensive resilience validation. Generates runbooks from experiment results.

package/assets/skills/cicd-pipeline-qe-orchestrator/README.md

@@ -0,0 +1,304 @@
+# CI/CD Pipeline QE Orchestrator
+
+**Comprehensive quality engineering orchestration across all CI/CD pipeline phases.**
+
+## What is This?
+
+The CI/CD Pipeline QE Orchestrator is an advanced Claude Code skill that provides intelligent, phase-based quality engineering across your entire software delivery pipeline. It intelligently selects from 41 QE skills and coordinates 19 specialized QE agents to ensure holistic quality coverage from commit to production.
+
+## Quick Start
+
+### 1. Invoke the Skill
+
+```javascript
+// In Claude Code
+Skill("cicd-pipeline-qe-orchestrator")
+```
+
+### 2. Analyze Your Pipeline
+
+```javascript
+Task("Pipeline Analysis",
+     "Analyze our CI/CD pipeline and recommend quality strategy for all phases",
+     "qe-fleet-commander")
+```
+
+### 3. Get Phase-Specific Recommendations
+
+The orchestrator will provide:
+- Skill selections per pipeline phase
+- Agent coordination patterns
+- Quality gate configurations
+- Timing budgets
+- Rollback strategies
+
+## What Makes This Different?
+
+### Traditional QE Approach
+```
+┌─────────────┐
+│ Run Tests   │  Manual selection
+│ Manual QA   │  Ad-hoc coverage
+│ Deploy      │  Hope for the best
+└─────────────┘
+```
+
+### Orchestrated QE Approach
+```
+┌──────────────────────────────────────────────┐
+│ Commit Phase (Shift-Left)                    │
+│  ├─ Skills: shift-left-testing, tdd          │
+│  ├─ Agents: qe-test-generator (parallel)     │
+│  └─ Gates: 80% coverage, 0 critical issues   │
+├──────────────────────────────────────────────┤
+│ Build Phase                                  │
+│  ├─ Skills: test-automation, mutation        │
+│  ├─ Agents: qe-test-executor (batched)       │
+│  └─ Gates: 90% coverage, mutation > 70%      │
+├──────────────────────────────────────────────┤
+│ Integration Phase                            │
+│  ├─ Skills: api-testing, performance         │
+│  ├─ Agents: qe-performance-tester (parallel) │
+│  └─ Gates: p95 < 200ms, 0 security critical  │
+├──────────────────────────────────────────────┤
+│ Staging Phase                                │
+│  ├─ Skills: chaos-engineering, visual        │
+│  ├─ Agents: qe-chaos-engineer (sequential)   │
+│  └─ Gates: resilience validated, 0 visual    │
+├──────────────────────────────────────────────┤
+│ Production Phase (Shift-Right)               │
+│  ├─ Skills: shift-right-testing              │
+│  ├─ Agents: qe-production-intelligence       │
+│  └─ Gates: error rate < 0.1%, monitors pass  │
+└──────────────────────────────────────────────┘
+```
+
+## Key Features
+
+### 🎯 Intelligent Skill Selection
+
+Automatically selects optimal skills based on:
+- Pipeline phase (commit, build, test, staging, production)
+- Application type (API, web, mobile, backend)
+- Risk level (critical, high, medium, low)
+- Deployment frequency (continuous, daily, weekly, monthly)
+
+### 🤖 Agent Coordination
+
+Orchestrates 19 specialized QE agents:
+- Parallel execution for speed
+- Sequential execution for dependencies
+- Memory-based coordination via `aqe/*` namespace
+- Smart batching to avoid OOM issues
+
+### 📊 Quality Gates
+
+Configurable gates per phase:
+- Coverage thresholds
+- Performance SLAs
+- Security vulnerability limits
+- Deployment readiness scores
+
+### 🔄 Adaptive Strategies
+
+Adapts testing approach based on:
+- Code change risk analysis
+- Historical failure patterns
+- Resource constraints
+- Time budgets
+
+## Use Cases
+
+### Microservices Pipeline
+```javascript
+// See resources/workflows/microservice-pipeline.md
+// Fast feedback, contract testing, chaos engineering
+```
+
+### Monolith Pipeline
+```javascript
+// See resources/workflows/monolith-pipeline.md
+// Smart test selection, comprehensive regression, DB migrations
+```
+
+### Mobile App Pipeline
+```javascript
+// See resources/workflows/mobile-pipeline.md
+// Device testing, accessibility, localization, staged rollout
+```
+
+## Integration with AQE Fleet
+
+### All 41 Skills Available
+
+The orchestrator can invoke any of the 41 QE skills:
+
+**Phase 1 Skills (18)**:
+- Core Testing: agentic-quality-engineering, context-driven-testing, holistic-testing-pact
+- Methodologies: tdd-london-chicago, xp-practices, risk-based-testing, test-automation-strategy
+- Techniques: api-testing-patterns, exploratory-testing-advanced, performance-testing, security-testing
+- Code Quality: code-review-quality, refactoring-patterns, quality-metrics
+- Communication: bug-reporting-excellence, technical-writing, consultancy-practices
+
+**Phase 2 Skills (16)**:
+- Methodologies: regression-testing, shift-left-testing, shift-right-testing, test-design-techniques, mutation-testing, test-data-management
+- Specialized: accessibility-testing, mobile-testing, database-testing, contract-testing, chaos-engineering-resilience, compatibility-testing, localization-testing, compliance-testing, visual-testing-advanced
+- Infrastructure: test-environment-management, test-reporting-analytics
+
+**Phase 3 Skills (4)**:
+- Strategic: six-thinking-hats, brutal-honesty-review, sherlock-review, cicd-pipeline-qe-orchestrator
+
+**Phase 4 Skills (3)**:
+- Advanced: testability-scoring, verification-quality, pair-programming
+
+### All 19 Agents Available
+
+The orchestrator coordinates all 19 QE agents:
+
+**Core Testing (5)**: test-generator, test-executor, coverage-analyzer, quality-gate, quality-analyzer
+**Performance & Security (2)**: performance-tester, security-scanner
+**Strategic Planning (3)**: requirements-validator, production-intelligence, fleet-commander
+**Deployment (1)**: deployment-readiness
+**Advanced Testing (4)**: regression-risk-analyzer, test-data-architect, api-contract-validator, flaky-test-hunter
+**Specialized (2)**: visual-tester, chaos-engineer
+
+## Example Workflows
+
+### Example 1: New Feature Development
+
+```javascript
+// Commit phase
+Task("TDD Tests", "Generate tests for new UserService.createUser()", "qe-test-generator")
+Skill("tdd-london-chicago")
+
+// Build phase
+Task("Run Tests", "Execute full suite with coverage", "qe-test-executor")
+Task("Coverage Check", "Analyze and report gaps", "qe-coverage-analyzer")
+
+// Integration phase
+Task("API Tests", "Validate new API contracts", "qe-api-contract-validator")
+Task("Performance", "Load test new endpoint", "qe-performance-tester")
+
+// Production
+Task("Monitor", "Track new feature adoption", "qe-production-intelligence")
+```
+
+### Example 2: Hotfix Deployment
+
+```javascript
+// Commit phase (minimal)
+Task("Risk Analysis", "Identify affected code", "qe-regression-risk-analyzer")
+Task("Targeted Tests", "Run minimal test suite", "qe-test-executor")
+
+// Build phase (fast)
+Task("Smoke Tests", "Critical path validation", "qe-test-executor")
+
+// Production (monitored)
+Task("Canary Deploy", "Monitor hotfix rollout", "qe-production-intelligence")
+```
+
+### Example 3: Comprehensive Release
+
+```javascript
+// Full pipeline orchestration
+Skill("cicd-pipeline-qe-orchestrator")
+
+// The skill will guide you through:
+// 1. Commit phase: shift-left testing, TDD
+// 2. Build phase: full regression, mutation testing
+// 3. Integration: API, performance, security testing
+// 4. Staging: chaos testing, visual regression
+// 5. Production: staged rollout, monitoring
+```
+
+## Configuration
+
+### Pipeline Phase Mapping
+
+Customize phase names to match your pipeline:
+
+```javascript
+const pipelinePhases = {
+  commit: "pre-merge",
+  build: "ci-build",
+  integration: "test-env",
+  staging: "uat",
+  production: "prod"
+};
+```
+
+### Quality Gate Thresholds
+
+Adjust thresholds per phase:
+
+```json
+{
+  "commit": { "coverage": 80, "max_violations": 0 },
+  "build": { "coverage": 90, "mutation_score": 70 },
+  "integration": { "p95_ms": 200, "security_critical": 0 },
+  "staging": { "readiness_score": 85 },
+  "production": { "error_rate": 0.001 }
+}
+```
+
+## Best Practices
+
+### 1. Start with Quick Start
+```javascript
+// Get recommendations first
+Skill("cicd-pipeline-qe-orchestrator")
+```
+
+### 2. Adapt to Your Context
+```javascript
+// Use context-driven testing skill
+Skill("context-driven-testing")
+```
+
+### 3. Measure and Improve
+```javascript
+// Track quality metrics
+Task("Quality Trends", "Analyze quality improvements", "qe-quality-analyzer")
+```
+
+### 4. Learn from Production
+```javascript
+// Convert incidents to tests
+Task("Production Intelligence", "Turn incidents into test scenarios", "qe-production-intelligence")
+```
+
+## Troubleshooting
+
+See main SKILL.md [Troubleshooting section](SKILL.md#troubleshooting) for:
+- Too many tests running (OOM)
+- Pipeline takes too long
+- Quality gates failing
+
+## Resources
+
+- [Main Skill Documentation](SKILL.md)
+- [Microservice Pipeline Workflow](resources/workflows/microservice-pipeline.md)
+- [Monolith Pipeline Workflow](resources/workflows/monolith-pipeline.md)
+- [Mobile Pipeline Workflow](resources/workflows/mobile-pipeline.md)
+- [All 41 QE Skills Reference](https://github.com/proffesor-for-testing/agentic-qe/blob/main/docs/reference/skills.md)
+- [All 19 QE Agents Reference](https://github.com/proffesor-for-testing/agentic-qe/blob/main/docs/reference/agents.md)
+
+## Contributing
+
+To add new pipeline workflows:
+1. Create workflow in `resources/workflows/[name]-pipeline.md`
+2. Follow existing template structure
+3. Include phase-by-phase breakdown
+4. Add skill and agent selections
+5. Define quality gates
+6. Provide complete code examples
+
+## License
+
+Part of the Agentic QE Fleet - MIT License
+
+---
+
+**Created**: 2025-11-13
+**Version**: 1.0.0
+**Integrations**: 41 QE Skills, 19 QE Agents, All CI/CD platforms