agentic-qe 1.6.0 → 1.6.1

package/.claude/skills/brutal-honesty-review/scripts/assess-tests.sh

@@ -0,0 +1,223 @@
+#!/bin/bash
+# Brutal Honesty Test Assessment Script (Ramsay Mode)
+
+set -e
+
+# Colors
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+GREEN='\033[0;32m'
+NC='\033[0m' # No Color
+
+echo "👨‍🍳 BRUTAL HONESTY TEST ASSESSMENT (Ramsay Mode)"
+echo "=================================================="
+echo ""
+
+# Check if test directory argument provided
+if [ -z "$1" ]; then
+    echo "Usage: $0 <test-directory>"
+    exit 1
+fi
+
+TEST_DIR="$1"
+
+# Check if test directory exists
+if [ ! -d "$TEST_DIR" ]; then
+    echo -e "${RED}🔴 FAILING: Test directory '$TEST_DIR' doesn't exist${NC}"
+    echo "   → Where are the tests? Did you even write any?"
+    exit 1
+fi
+
+# Function to assess coverage
+assess_coverage() {
+    echo "📊 COVERAGE CHECK"
+    echo "----------------"
+
+    # Run coverage if npm test with coverage exists
+    if [ -f "package.json" ] && grep -q "test:coverage" package.json; then
+        echo "Running coverage analysis..."
+        npm run test:coverage 2>/dev/null || true
+
+        # Extract coverage percentage
+        coverage=$(npm run test:coverage 2>&1 | grep -oP '\d+\.\d+(?=%)' | head -1 || echo "0")
+
+        if (( $(echo "$coverage < 50" | bc -l) )); then
+            echo -e "${RED}🔴 RAW: ${coverage}% coverage${NC}"
+            echo "   → This is embarrassing. You're barely testing anything."
+        elif (( $(echo "$coverage < 80" | bc -l) )); then
+            echo -e "${YELLOW}🟡 ACCEPTABLE: ${coverage}% coverage${NC}"
+            echo "   → Minimum is 80%. You're not there yet."
+        else
+            echo -e "${GREEN}🟢 MICHELIN STAR: ${coverage}% coverage${NC}"
+        fi
+    else
+        echo -e "${YELLOW}⚠️  No coverage command found${NC}"
+        echo "   → Add 'test:coverage' script to package.json"
+    fi
+}
+
+# Function to assess edge cases
+assess_edge_cases() {
+    echo ""
+    echo "🎯 EDGE CASE CHECK"
+    echo "-----------------"
+
+    # Check for common edge case patterns
+    edge_case_patterns=(
+        "null"
+        "undefined"
+        "empty"
+        "zero"
+        "negative"
+        "max"
+        "min"
+        "overflow"
+        "boundary"
+    )
+
+    found_count=0
+    for pattern in "${edge_case_patterns[@]}"; do
+        if grep -ri "$pattern" "$TEST_DIR" > /dev/null 2>&1; then
+            ((found_count++))
+        fi
+    done
+
+    if [ "$found_count" -eq 0 ]; then
+        echo -e "${RED}🔴 RAW: No edge cases tested${NC}"
+        echo "   → You're only testing the happy path. That's not testing."
+    elif [ "$found_count" -lt 3 ]; then
+        echo -e "${YELLOW}🟡 ACCEPTABLE: Found $found_count edge case patterns${NC}"
+        echo "   → Test more: null, empty, boundaries, overflow"
+    else
+        echo -e "${GREEN}🟢 MICHELIN STAR: Found $found_count edge case patterns${NC}"
+    fi
+}
+
+# Function to assess test clarity
+assess_clarity() {
+    echo ""
+    echo "📖 CLARITY CHECK"
+    echo "---------------"
+
+    # Check for descriptive test names
+    unclear_tests=$(grep -r "test('test" "$TEST_DIR" 2>/dev/null | wc -l)
+    if [ "$unclear_tests" -gt 0 ]; then
+        echo -e "${RED}🔴 RAW: Found $unclear_tests unclear test names${NC}"
+        echo "   → 'test1', 'test2' - What are you testing? Use descriptive names."
+    fi
+
+    # Check for describe/it blocks
+    if grep -r "describe\|it\|test" "$TEST_DIR" > /dev/null 2>&1; then
+        echo -e "${GREEN}✓ Tests have structure${NC}"
+    else
+        echo -e "${YELLOW}⚠️  No test framework patterns detected${NC}"
+    fi
+}
+
+# Function to assess test speed
+assess_speed() {
+    echo ""
+    echo "⚡ SPEED CHECK"
+    echo "-------------"
+
+    echo "Running tests..."
+    start_time=$(date +%s)
+
+    # Run tests (suppress output)
+    if npm test > /dev/null 2>&1; then
+        end_time=$(date +%s)
+        duration=$((end_time - start_time))
+
+        if [ "$duration" -gt 60 ]; then
+            echo -e "${RED}🔴 RAW: Tests took ${duration}s${NC}"
+            echo "   → Unit tests should run in seconds, not minutes."
+            echo "   → Are you calling real databases/networks?"
+        elif [ "$duration" -gt 10 ]; then
+            echo -e "${YELLOW}🟡 ACCEPTABLE: Tests took ${duration}s${NC}"
+            echo "   → Aim for <10s. Use mocks and in-memory operations."
+        else
+            echo -e "${GREEN}🟢 MICHELIN STAR: Tests took ${duration}s${NC}"
+        fi
+    else
+        echo -e "${RED}🔴 FAILING: Tests don't even pass${NC}"
+        echo "   → Fix your broken tests before worrying about speed."
+    fi
+}
+
+# Function to assess stability
+assess_stability() {
+    echo ""
+    echo "🎲 STABILITY CHECK"
+    echo "-----------------"
+
+    # Check for flaky patterns
+    if grep -ri "setTimeout\|sleep\|wait" "$TEST_DIR" > /dev/null 2>&1; then
+        echo -e "${RED}🔴 RAW: Timing-based tests detected${NC}"
+        echo "   → You're creating flaky tests. Use proper async/await."
+    fi
+
+    # Run tests multiple times to detect flakes
+    echo "Running tests 3x to detect flakes..."
+    failures=0
+    for i in {1..3}; do
+        if ! npm test > /dev/null 2>&1; then
+            ((failures++))
+        fi
+    done
+
+    if [ "$failures" -gt 0 ]; then
+        echo -e "${RED}🔴 RAW: Tests failed $failures/3 times${NC}"
+        echo "   → FLAKY TESTS. These are worse than no tests."
+        echo "   → Fix the non-determinism before merging."
+    else
+        echo -e "${GREEN}🟢 MICHELIN STAR: Tests are stable${NC}"
+    fi
+}
+
+# Function to assess isolation
+assess_isolation() {
+    echo ""
+    echo "🏝️  ISOLATION CHECK"
+    echo "------------------"
+
+    # Check for shared state patterns
+    if grep -ri "global\|beforeAll\|shared" "$TEST_DIR" > /dev/null 2>&1; then
+        echo -e "${YELLOW}🟡 WARNING: Shared state patterns detected${NC}"
+        echo "   → Are your tests independent? Can they run in any order?"
+    fi
+
+    # Check for test order dependencies
+    if grep -r "\.only\|\.skip" "$TEST_DIR" > /dev/null 2>&1; then
+        echo -e "${YELLOW}🟡 WARNING: .only or .skip found${NC}"
+        echo "   → Don't commit tests with .only or .skip"
+    fi
+
+    echo -e "${GREEN}✓ Review test isolation manually${NC}"
+}
+
+# Run all assessments
+assess_coverage
+assess_edge_cases
+assess_clarity
+assess_speed
+assess_stability
+assess_isolation
+
+# Final verdict
+echo ""
+echo "=================================================="
+echo "🎯 FINAL VERDICT"
+echo "=================================================="
+echo ""
+echo "Look at the results above. If you see multiple 🔴 RAW marks,"
+echo "these tests are NOT production-ready."
+echo ""
+echo "Expected standards:"
+echo "  - 80%+ branch coverage"
+echo "  - Edge cases tested (null, empty, boundaries)"
+echo "  - Clear test names"
+echo "  - <10s to run"
+echo "  - 0% flaky"
+echo "  - Independent tests"
+echo ""
+echo "You know what good tests look like. Why aren't you writing them?"

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

@@ -0,0 +1,301 @@
+# 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 37 QE skills and coordinates 18 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 18 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 37 Skills Available
+
+The orchestrator can invoke any of the 37 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 (3)**:
+- Strategic: six-thinking-hats, brutal-honesty-review, cicd-pipeline-qe-orchestrator
+
+### All 18 Agents Available
+
+The orchestrator coordinates all 18 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 37 QE Skills Reference](https://github.com/ruvnet/agentic-qe-cf/blob/main/docs/reference/skills.md)
+- [All 18 QE Agents Reference](https://github.com/ruvnet/agentic-qe-cf/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**: 37 QE Skills, 18 QE Agents, All CI/CD platforms