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

package/assets/skills/brutal-honesty-review/scripts/assess-code.sh

@@ -0,0 +1,179 @@
+#!/bin/bash
+# Brutal Honesty Code Assessment Script (Linus Mode)
+
+set -e
+
+# Colors
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+GREEN='\033[0;32m'
+NC='\033[0m' # No Color
+
+echo "🔥 BRUTAL HONESTY CODE ASSESSMENT (Linus Mode)"
+echo "================================================"
+echo ""
+
+# Check if file argument provided
+if [ -z "$1" ]; then
+    echo "Usage: $0 <file-or-directory>"
+    exit 1
+fi
+
+TARGET="$1"
+
+# Function to assess correctness
+assess_correctness() {
+    echo "📊 CORRECTNESS CHECK"
+    echo "-------------------"
+
+    # Check for common bug patterns
+    if grep -r "TODO\|FIXME\|BUG\|HACK" "$TARGET" 2>/dev/null; then
+        echo -e "${RED}🔴 FAILING: Found TODO/FIXME/BUG/HACK comments${NC}"
+        echo "   → This code admits it's broken. Fix it before review."
+        return 0
+    fi
+
+    # Check for error-prone patterns
+    if grep -r "null\|undefined" "$TARGET" 2>/dev/null | grep -v "!== null" | grep -v "!== undefined" > /dev/null; then
+        echo -e "${YELLOW}🟡 WARNING: Potential null/undefined issues${NC}"
+        echo "   → Are you handling null cases properly?"
+    fi
+
+    echo -e "${GREEN}✓ No obvious correctness issues${NC}"
+}
+
+# Function to assess performance
+assess_performance() {
+    echo ""
+    echo "⚡ PERFORMANCE CHECK"
+    echo "-------------------"
+
+    # Check for nested loops (potential O(n²))
+    nested_loops=$(grep -r "for.*{" "$TARGET" | wc -l)
+    if [ "$nested_loops" -gt 5 ]; then
+        echo -e "${RED}🔴 FAILING: Found $nested_loops loops${NC}"
+        echo "   → Are you creating O(n²) complexity where O(n) exists?"
+        echo "   → Use hash maps, sets, or better algorithms."
+    fi
+
+    # Check for synchronous I/O in hot paths
+    if grep -r "readFileSync\|writeFileSync" "$TARGET" 2>/dev/null; then
+        echo -e "${RED}🔴 FAILING: Synchronous file I/O detected${NC}"
+        echo "   → You're blocking the event loop. Use async operations."
+    fi
+
+    echo -e "${GREEN}✓ No obvious performance issues${NC}"
+}
+
+# Function to assess error handling
+assess_error_handling() {
+    echo ""
+    echo "🛡️  ERROR HANDLING CHECK"
+    echo "----------------------"
+
+    # Check for try/catch usage
+    try_count=$(grep -r "try\|catch" "$TARGET" 2>/dev/null | wc -l)
+    if [ "$try_count" -eq 0 ]; then
+        echo -e "${RED}🔴 FAILING: No error handling found${NC}"
+        echo "   → What happens when this code fails? It crashes."
+    else
+        echo -e "${GREEN}✓ Found error handling (verify it's sufficient)${NC}"
+    fi
+
+    # Check for empty catch blocks
+    if grep -A 1 "catch" "$TARGET" 2>/dev/null | grep -q "^\s*}"; then
+        echo -e "${RED}🔴 FAILING: Empty catch blocks detected${NC}"
+        echo "   → Swallowing errors silently is worse than crashing."
+    fi
+}
+
+# Function to assess concurrency
+assess_concurrency() {
+    echo ""
+    echo "🔀 CONCURRENCY CHECK"
+    echo "-------------------"
+
+    # Check for global state mutations
+    if grep -r "global\.\|window\." "$TARGET" 2>/dev/null; then
+        echo -e "${YELLOW}🟡 WARNING: Global state mutations detected${NC}"
+        echo "   → Are you handling concurrent access safely?"
+    fi
+
+    # Check for race condition patterns
+    if grep -r "setTimeout\|setInterval" "$TARGET" 2>/dev/null; then
+        echo -e "${YELLOW}🟡 WARNING: Timing-based code detected${NC}"
+        echo "   → Are you creating race conditions?"
+    fi
+
+    echo -e "${GREEN}✓ Review concurrency manually${NC}"
+}
+
+# Function to assess testability
+assess_testability() {
+    echo ""
+    echo "🧪 TESTABILITY CHECK"
+    echo "-------------------"
+
+    # Check if tests exist
+    if [ -d "tests" ] || [ -d "test" ] || [ -d "__tests__" ]; then
+        echo -e "${GREEN}✓ Test directory exists${NC}"
+    else
+        echo -e "${RED}🔴 FAILING: No test directory found${NC}"
+        echo "   → Where are the tests? Did you even test this?"
+    fi
+
+    # Check for dependency injection
+    if grep -r "new\s\+\w\+(" "$TARGET" 2>/dev/null | grep -v "Error\|Date" > /dev/null; then
+        echo -e "${YELLOW}🟡 WARNING: Hard-coded dependencies detected${NC}"
+        echo "   → Use dependency injection for testability."
+    fi
+}
+
+# Function to assess maintainability
+assess_maintainability() {
+    echo ""
+    echo "🔧 MAINTAINABILITY CHECK"
+    echo "-----------------------"
+
+    # Check function length (should be <50 lines)
+    if [ -f "$TARGET" ]; then
+        long_functions=$(awk '/^function|^const.*=>/ {start=NR} /^}/ {if(NR-start>50) print "Line",start}' "$TARGET" | wc -l)
+        if [ "$long_functions" -gt 0 ]; then
+            echo -e "${YELLOW}🟡 WARNING: Found $long_functions functions >50 lines${NC}"
+            echo "   → Break down complex functions."
+        fi
+    fi
+
+    # Check for magic numbers
+    if grep -rE "\s[0-9]{3,}" "$TARGET" 2>/dev/null | grep -v "1000\|2000" > /dev/null; then
+        echo -e "${YELLOW}🟡 WARNING: Magic numbers detected${NC}"
+        echo "   → Use named constants."
+    fi
+
+    echo -e "${GREEN}✓ Review code clarity manually${NC}"
+}
+
+# Run all assessments
+assess_correctness
+assess_performance
+assess_error_handling
+assess_concurrency
+assess_testability
+assess_maintainability
+
+# Final verdict
+echo ""
+echo "================================================"
+echo "🎯 FINAL VERDICT"
+echo "================================================"
+echo ""
+echo "Review the findings above. If you see multiple 🔴 FAILING marks,"
+echo "this code is NOT ready for review."
+echo ""
+echo "Expected standards:"
+echo "  - All error paths handled"
+echo "  - No obvious performance issues"
+echo "  - Tests exist and pass"
+echo "  - Code is clear and maintainable"
+echo ""
+echo "If you wouldn't deploy this to production, don't submit it for review."

package/assets/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/assets/skills/bug-reporting-excellence/SKILL.md

@@ -0,0 +1,225 @@
+---
+name: bug-reporting-excellence
+description: "Write high-quality bug reports that get fixed quickly. Use when reporting bugs, training teams on bug reporting, or establishing bug report standards."
+category: quality-communication
+priority: high
+tokenEstimate: 900
+agents: [qe-quality-analyzer, qe-production-intelligence, qe-flaky-test-hunter]
+implementation_status: optimized
+optimization_version: 1.0
+last_optimized: 2025-12-03
+dependencies: []
+quick_reference_card: true
+tags: [bugs, reporting, communication, triage, quality]
+---
+
+# Bug Reporting Excellence
+
+<default_to_action>
+When reporting bugs:
+1. TITLE: `[Component] fails [Condition] causing [Impact]`
+2. DESCRIBE: Expected behavior → Actual behavior → Steps to reproduce
+3. INCLUDE: Environment, severity, screenshots/logs, business impact
+4. ISOLATE: Narrow down conditions (browser, user, amount thresholds)
+5. ONE BUG = ONE REPORT (don't combine issues)
+
+**Bug Report Formula:**
+```markdown
+## [Component] Issue Title
+**Severity:** Critical/High/Medium/Low
+**Environment:** Production/Staging/Dev
+
+### Expected Behavior
+What should happen
+
+### Actual Behavior
+What actually happens (with error messages)
+
+### Steps to Reproduce
+1. Step one
+2. Step two
+3. Observe issue
+
+### Impact
+How this affects users/business
+```
+
+**Critical Success Factors:**
+- Reproducible steps (100%)
+- Environment info (100%)
+- Business impact stated (90%)
+- Screenshots or logs (80%)
+</default_to_action>
+
+## Quick Reference Card
+
+### Severity Levels
+
+| Level | Definition | Examples |
+|-------|------------|----------|
+| **Critical** | System down, data loss, security | DB deleted, payments broken, credentials exposed |
+| **High** | Major feature broken, many users | Can't checkout, search broken, dashboard fails |
+| **Medium** | Partial break, workaround exists | Filter broken (refresh works), slow export |
+| **Low** | Cosmetic, rare edge case | Button wraps on mobile, tooltip wrong color |
+
+### Title Formula
+❌ Bad: "Checkout broken"
+✅ Good: "Payment fails with Visa cards when order total > $1000"
+
+**Pattern:** `[Component] fails [Condition] causing [Impact]`
+
+---
+
+## Essential Information
+
+### Environment Details
+```
+Browser: Chrome 120.0.6099.109 (Windows)
+OS: Windows 11 Pro
+URL: https://example.com/checkout
+Date/Time: 2025-10-17 14:23 UTC
+User: test@example.com (ID: 12345)
+Request ID: abc-123-def-456
+```
+
+### Supporting Evidence
+
+**Error Messages:**
+```json
+{
+  "error": "Payment service unavailable",
+  "code": "GATEWAY_TIMEOUT",
+  "requestId": "abc-123-def-456"
+}
+```
+
+**Console Logs:**
+```
+[ERROR] PaymentGateway: Connection timeout after 30000ms
+  at PaymentGateway.charge (gateway.js:145)
+```
+
+---
+
+## Example: Excellent Bug Report
+
+```markdown
+## [Checkout] Payment processing times out for orders > $1000
+
+**Severity:** High
+**Environment:** Production
+**Affected Users:** ~15% of premium purchases
+
+### Expected Behavior
+Payment completes within 5 seconds regardless of amount.
+
+### Actual Behavior
+For orders above $1000, payment gateway times out after 30 seconds.
+User sees "Payment failed" error. Order not created.
+
+### Steps to Reproduce
+1. Add items totaling $1,050 to cart
+2. Proceed to checkout
+3. Enter payment: Visa 4532 1234 5678 9010
+4. Click "Place Order"
+5. Wait 30+ seconds
+6. Observe timeout error
+
+### Environment
+- Browser: Chrome 120 (Windows 11)
+- User: test@example.com
+- Request ID: abc-123-def-456
+
+### Evidence
+Console error: `PaymentGateway timeout: 30000ms exceeded`
+Network: /api/checkout: 30.14s (timeout)
+
+### Impact
+- Lost revenue: ~$15K/week from failed orders
+- 23 support tickets this week
+- Affects 15% of orders over $1000
+
+### Additional Context
+Started after Oct 15 deployment (v2.3.0)
+Possibly related to PR #456 (fraud check)
+```
+
+---
+
+## Anti-Patterns
+
+| ❌ Bad | Problem | ✅ Good |
+|--------|---------|--------|
+| "Checkout is broken" | What doesn't work? | "Payment button doesn't respond when clicked" |
+| "I saw an error" | No reproduction steps | Full steps with conditions |
+| "Page loads slowly" | No specifics | "Dashboard takes 12s to load (should be <3s)" |
+| Multiple bugs in one | Can't track separately | One report per bug |
+
+---
+
+## Agent Integration
+
+```typescript
+// Automated bug triage
+const triage = await Task("Triage Bug", {
+  title: 'Payment fails for orders > $1000',
+  description: bugDescription,
+  steps: reproductionSteps
+}, "qe-quality-analyzer");
+
+// Returns: { severity, priority, component, suggestedAssignee, relatedIssues }
+
+// Duplicate detection
+const dupeCheck = await Task("Check Duplicates", {
+  bugReport: newBug,
+  similarityThreshold: 0.85
+}, "qe-quality-analyzer");
+
+// Bug report enhancement
+const enhanced = await Task("Enhance Report", {
+  originalReport: userSubmittedBug,
+  addMissingInfo: true,
+  identifyRootCause: true
+}, "qe-production-intelligence");
+```
+
+---
+
+## Agent Coordination Hints
+
+### Memory Namespace
+```
+aqe/bug-reports/
+├── triaged/*          - Bug triage results
+├── duplicates/*       - Duplicate detection
+├── patterns/*         - Recurring bug patterns
+└── root-cause/*       - Root cause analyses
+```
+
+### Fleet Coordination
+```typescript
+const bugFleet = await FleetManager.coordinate({
+  strategy: 'bug-investigation',
+  agents: [
+    'qe-quality-analyzer',        // Triage and categorize
+    'qe-flaky-test-hunter',       // Check if test-related
+    'qe-production-intelligence'  // Check production logs
+  ],
+  topology: 'parallel'
+});
+```
+
+---
+
+## Related Skills
+- [technical-writing](../technical-writing/) - Clear bug documentation
+- [exploratory-testing-advanced](../exploratory-testing-advanced/) - Finding bugs
+- [sherlock-review](../sherlock-review/) - Root cause investigation
+
+---
+
+## Remember
+
+Your bug report is the starting point for someone else's work. Make it **complete** (all info needed), **clear** (anyone can follow), **concise** (no noise), and **actionable** (developer knows next step).
+
+**Good bug reports = Faster fixes = Better product = Happier users**