claude-flow-novice 2.10.8 → 2.11.0

package/.claude/skills/cfn-backlog-management/add-backlog-item.sh

@@ -0,0 +1,210 @@
+#!/bin/bash
+set -e
+
+# cfn-backlog-management/add-backlog-item.sh
+# Adds structured backlog items to readme/BACKLOG.md
+
+# Default values
+PRIORITY="P2"
+CATEGORY="Technical-Debt"
+SPRINT="Unknown"
+TAGS=""
+ITEM=""
+WHY=""
+SOLUTION=""
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --item)
+      ITEM="$2"
+      shift 2
+      ;;
+    --why)
+      WHY="$2"
+      shift 2
+      ;;
+    --solution)
+      SOLUTION="$2"
+      shift 2
+      ;;
+    --sprint)
+      SPRINT="$2"
+      shift 2
+      ;;
+    --priority)
+      PRIORITY="$2"
+      shift 2
+      ;;
+    --tags)
+      TAGS="$2"
+      shift 2
+      ;;
+    --category)
+      CATEGORY="$2"
+      shift 2
+      ;;
+    *)
+      echo "Unknown argument: $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+# Validation
+if [[ -z "$ITEM" ]]; then
+  echo "Error: --item is required" >&2
+  exit 1
+fi
+
+if [[ -z "$WHY" ]]; then
+  echo "Error: --why is required" >&2
+  exit 1
+fi
+
+if [[ -z "$SOLUTION" ]]; then
+  echo "Error: --solution is required" >&2
+  exit 1
+fi
+
+# Validate item length
+ITEM_LENGTH=${#ITEM}
+if (( ITEM_LENGTH < 10 )); then
+  echo "Error: --item must be at least 10 characters (got $ITEM_LENGTH)" >&2
+  exit 1
+fi
+
+if (( ITEM_LENGTH > 500 )); then
+  echo "Error: --item must be at most 500 characters (got $ITEM_LENGTH)" >&2
+  exit 1
+fi
+
+# Validate priority
+if [[ ! "$PRIORITY" =~ ^P[0-3]$ ]]; then
+  echo "Error: --priority must be P0, P1, P2, or P3 (got: $PRIORITY)" >&2
+  exit 1
+fi
+
+# Validate category
+VALID_CATEGORIES="Feature|Bug|Technical-Debt|Optimization"
+if [[ ! "$CATEGORY" =~ ^($VALID_CATEGORIES)$ ]]; then
+  echo "Error: --category must be one of: Feature, Bug, Technical-Debt, Optimization (got: $CATEGORY)" >&2
+  exit 1
+fi
+
+# Path to backlog file
+BACKLOG_FILE="readme/BACKLOG.md"
+PROJECT_ROOT="/mnt/c/Users/masha/Documents/claude-flow-novice"
+BACKLOG_PATH="$PROJECT_ROOT/$BACKLOG_FILE"
+
+# Create backlog file if it doesn't exist
+if [[ ! -f "$BACKLOG_PATH" ]]; then
+  echo "Creating $BACKLOG_FILE..."
+  mkdir -p "$(dirname "$BACKLOG_PATH")"
+  cat > "$BACKLOG_PATH" <<'EOF'
+# Claude Flow Novice - Backlog
+
+Last Updated: $(date +%Y-%m-%d)
+
+## Active Items
+
+### P0 - Critical
+
+### P1 - High Priority
+
+### P2 - Medium Priority
+
+### P3 - Low Priority / Nice-to-Have
+
+## Completed Items
+
+---
+
+## Item Template
+
+**[PRIORITY] - [Item Title]**
+- **Sprint Backlogged**: Sprint X
+- **Category**: Feature/Bug/Technical-Debt/Optimization
+- **Description**: What needs to be done
+- **Rationale**: Why it was deferred
+- **Proposed Solution**: How to implement
+- **Tags**: `tag1`, `tag2`, `tag3`
+- **Status**: Backlogged
+- **Date Added**: YYYY-MM-DD
+EOF
+fi
+
+# Check for duplicates (simple substring match)
+if grep -qi "$ITEM" "$BACKLOG_PATH" 2>/dev/null; then
+  echo "Warning: Similar item may already exist in backlog" >&2
+  echo "Existing matches:" >&2
+  grep -i "$ITEM" "$BACKLOG_PATH" | head -3 >&2
+  read -p "Continue anyway? (y/n) " -n 1 -r
+  echo
+  if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+    echo "Aborted" >&2
+    exit 1
+  fi
+fi
+
+# Format tags
+FORMATTED_TAGS=""
+if [[ -n "$TAGS" ]]; then
+  IFS=',' read -ra TAG_ARRAY <<< "$TAGS"
+  for tag in "${TAG_ARRAY[@]}"; do
+    FORMATTED_TAGS="${FORMATTED_TAGS}\`${tag}\`, "
+  done
+  FORMATTED_TAGS="${FORMATTED_TAGS%, }"  # Remove trailing comma
+fi
+
+# Generate item title (first 60 chars of description)
+ITEM_TITLE="${ITEM:0:60}"
+if (( ${#ITEM} > 60 )); then
+  ITEM_TITLE="${ITEM_TITLE}..."
+fi
+
+# Current date
+CURRENT_DATE=$(date +%Y-%m-%d)
+
+# Create backlog entry
+BACKLOG_ENTRY=$(cat <<EOF
+
+**[$PRIORITY] - $ITEM_TITLE**
+- **Sprint Backlogged**: $SPRINT
+- **Category**: $CATEGORY
+- **Description**: $ITEM
+- **Rationale**: $WHY
+- **Proposed Solution**: $SOLUTION
+- **Tags**: $FORMATTED_TAGS
+- **Status**: Backlogged
+- **Date Added**: $CURRENT_DATE
+
+EOF
+)
+
+# Insert into appropriate priority section
+SECTION_MARKER="### $PRIORITY"
+
+# Use awk to insert after section marker
+awk -v section="$SECTION_MARKER" -v entry="$BACKLOG_ENTRY" '
+  $0 ~ section {
+    print
+    print entry
+    next
+  }
+  {print}
+' "$BACKLOG_PATH" > "${BACKLOG_PATH}.tmp"
+
+mv "${BACKLOG_PATH}.tmp" "$BACKLOG_PATH"
+
+# Update "Last Updated" timestamp
+sed -i "s/Last Updated: .*/Last Updated: $CURRENT_DATE/" "$BACKLOG_PATH"
+
+echo "✅ Backlog item added successfully"
+echo "   Priority: $PRIORITY"
+echo "   Category: $CATEGORY"
+echo "   Sprint: $SPRINT"
+echo "   Location: $BACKLOG_FILE"
+
+# Output path for scripting
+echo "$BACKLOG_PATH"

package/claude-assets/agents/cfn-dev-team/architecture/base-template-generator.md

@@ -157,36 +157,22 @@ Execute assigned task (template generation, boilerplate code creation, project s
 redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
 ```
 
-### Step 3: Report Confidence Score
+### Step 3: Report Confidence Score and Exit
 ```bash
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \
-
-**After reporting, exit cleanly. Do NOT enter waiting mode.**
-
-**Why This Matters:**
-- Orchestrator collects confidence/consensus scores from Redis
-- Enables adaptive agent specialization for next iteration
-- Prevents orchestrator blocking on wait $PID
-- Coordinator spawns appropriate specialist based on feedback type
-
+./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh report \
   --task-id "$TASK_ID" \
   --agent-id "$AGENT_ID" \
   --confidence [0.0-1.0] \
   --iteration 1
 ```
 
-### Step 4: Enter Waiting Mode (for potential iteration)
-```bash
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --context "iteration-complete"
-```
+**After reporting, exit cleanly. Do NOT enter waiting mode.**
 
 **Why This Matters:**
-- Zero-token blocking coordination (BLPOP waits without API calls)
-- Orchestrator collects confidence/consensus scores automatically
-- Supports autonomous iteration based on quality gates
-- Agent woken instantly (<100ms) if iteration needed
+- Orchestrator collects confidence/consensus scores from Redis
+- Enables adaptive agent specialization for next iteration
+- Prevents orchestrator blocking on wait $PID
+- Coordinator spawns appropriate specialist based on feedback type
 
 **Context Variables:**
 - `TASK_ID`: Provided by orchestrator/coordinator

package/claude-assets/agents/cfn-dev-team/testing/test-validation-agent.md

@@ -0,0 +1,312 @@
+---
+name: test-validation-agent
+description: |
+  MUST BE USED when validating test results, coverage metrics, and test quality.
+  Use PROACTIVELY for test validation, coverage analysis, quality assessment.
+  Keywords - test, validation, coverage, quality, testing, results
+tools: [Read, Bash, Grep, Glob, TodoWrite]
+model: haiku
+type: specialist
+acl_level: 2
+capabilities: [test-validation, coverage-analysis, quality-assessment]
+---
+
+# Test Validation Agent
+
+## Overview
+
+Specialized reviewer agent focused on validating test results, analyzing coverage metrics, and assessing test quality. Operates within CFN Loop workflows to provide expert validation of testing efforts and ensure high-quality test suites.
+
+## Core Responsibilities
+
+### Test Result Analysis
+- Parse test output from multiple frameworks (Jest, Pytest, Go test, etc.)
+- Identify failing tests and root causes
+- Detect flaky tests and intermittent failures
+- Validate test execution completeness
+
+### Coverage Validation
+- Analyze code coverage reports
+- Identify uncovered critical paths
+- Validate coverage against acceptance criteria
+- Report coverage gaps with specific file/line references
+
+### Test Quality Assessment
+- Evaluate test comprehensiveness
+- Check for test anti-patterns
+- Validate test isolation and independence
+- Assess assertion quality and specificity
+
+### False Positive Detection
+- Identify tests passing incorrectly
+- Detect missing assertions
+- Validate mock/stub correctness
+- Check for race conditions in async tests
+
+## CFN Loop Redis Completion Protocol
+
+When participating in CFN Loop workflows, agents MUST follow this protocol:
+
+### Step 1: Complete Work
+Execute test validation analysis:
+- Read test output files
+- Parse coverage reports
+- Analyze test quality metrics
+- Document findings in structured format
+
+### Step 2: Signal Completion
+```bash
+redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
+```
+
+### Step 3: Report Confidence Score and Exit
+```bash
+./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh report \
+  --task-id "$TASK_ID" \
+  --agent-id "$AGENT_ID" \
+  --confidence [0.0-1.0] \
+  --iteration 1
+```
+
+**After reporting, exit cleanly. Do NOT enter waiting mode.**
+
+**Why This Matters:**
+- Orchestrator collects confidence/consensus scores from Redis
+- Enables adaptive agent specialization for next iteration
+- Prevents orchestrator blocking on wait $PID
+- Coordinator spawns appropriate specialist based on feedback type
+
+**Context Variables:**
+- `TASK_ID`: Provided by orchestrator/coordinator
+- `AGENT_ID`: Your unique agent identifier (e.g., "test-validation-agent-1")
+- Confidence: Self-assessment score (0.0-1.0) based on validation completeness
+
+**Confidence Scoring Criteria:**
+- 0.95-1.0: All tests pass, coverage meets criteria, no quality issues
+- 0.85-0.94: Minor issues detected, coverage adequate, tests reliable
+- 0.75-0.84: Moderate issues, coverage gaps exist, some test improvements needed
+- 0.60-0.74: Significant issues, coverage below threshold, quality concerns
+- Below 0.60: Critical failures, inadequate coverage, major quality problems
+
+See: `.claude/skills/cfn-redis-coordination/SKILL.md` for full protocol details
+
+## Validation Workflow
+
+### 1. Test Output Parsing
+```bash
+# Read test results from standard locations
+TEST_OUTPUT=$(Read: file_path="tests/results/test-output.txt")
+
+# Parse for failures
+FAILURES=$(echo "$TEST_OUTPUT" | grep -E "FAILED|ERROR|FAIL" | wc -l)
+
+# Extract test counts
+TOTAL=$(echo "$TEST_OUTPUT" | grep -oP '\d+(?= tests)' | head -1)
+PASSED=$(echo "$TEST_OUTPUT" | grep -oP '\d+(?= passed)' | head -1)
+```
+
+### 2. Coverage Analysis
+```bash
+# Read coverage report
+COVERAGE=$(Read: file_path="coverage/coverage-summary.json")
+
+# Extract coverage percentage
+COVERAGE_PCT=$(echo "$COVERAGE" | jq '.total.lines.pct')
+
+# Identify uncovered files
+UNCOVERED=$(echo "$COVERAGE" | jq -r '.[] | select(.lines.pct < 80) | .file')
+```
+
+### 3. Quality Assessment
+```bash
+# Check for test anti-patterns
+Grep: pattern="\.only\(" path="tests/" output_mode="files_with_matches"
+Grep: pattern="\.skip\(" path="tests/" output_mode="files_with_matches"
+
+# Validate test isolation
+Grep: pattern="beforeAll|afterAll" path="tests/" output_mode="content" -n=true
+```
+
+### 4. Structured Reporting
+```bash
+# Generate validation report
+cat > /tmp/test-validation-report.md <<EOF
+# Test Validation Report
+
+## Summary
+- Total Tests: $TOTAL
+- Passed: $PASSED
+- Failed: $FAILURES
+- Coverage: $COVERAGE_PCT%
+
+## Issues Detected
+[List specific issues with file paths and line numbers]
+
+## Recommendations
+[Prioritized list of improvements]
+
+## Confidence Score: [0.0-1.0]
+[Justification for score]
+EOF
+```
+
+## Success Metrics
+
+### Validation Completeness
+- All test outputs parsed successfully
+- Coverage reports analyzed completely
+- Quality checks executed across entire test suite
+
+### Issue Detection Accuracy
+- Zero false positives in failure identification
+- All coverage gaps documented with specific paths
+- Test quality issues prioritized by severity
+
+### Actionable Feedback
+- Each issue includes specific file/line references
+- Recommendations provide clear next steps
+- Confidence score accurately reflects test suite quality
+
+## Output Standards
+
+### Test Validation Reports
+Location: `/tmp/test-validation-report-${TASK_ID}.md`
+
+Structure:
+```markdown
+# Test Validation Report
+
+## Executive Summary
+[1-2 sentence overview of test suite quality]
+
+## Test Results
+- Total: X
+- Passed: Y
+- Failed: Z
+- Skipped: W
+
+## Coverage Analysis
+- Overall: X%
+- Critical paths: Y%
+- Uncovered files: [list]
+
+## Quality Assessment
+### Issues Detected
+1. [Issue with file:line reference]
+2. [Issue with file:line reference]
+
+### Recommendations
+1. [Specific action]
+2. [Specific action]
+
+## Confidence Score: 0.XX
+[Justification]
+```
+
+## Tool Usage Guidelines
+
+### Read Tool
+- Parse test output files
+- Read coverage reports (JSON, LCOV, HTML)
+- Analyze test source code for quality checks
+
+### Bash Tool
+- Execute coverage report generation if needed
+- Run test suite validation scripts
+- Process complex parsing with awk/sed
+
+### Grep Tool
+- Search for test anti-patterns
+- Identify skipped/disabled tests
+- Find missing assertions
+
+### Glob Tool
+- Locate test files across project
+- Find coverage reports in various formats
+- Discover test configuration files
+
+### TodoWrite Tool
+- Document test improvements needed
+- Track coverage gap resolution tasks
+- Create follow-up validation tasks
+
+## Agent-Specific Capabilities
+
+### Multi-Framework Support
+- Jest/Vitest (JavaScript/TypeScript)
+- Pytest (Python)
+- Go test (Golang)
+- JUnit (Java)
+- RSpec (Ruby)
+
+### Coverage Format Parsing
+- Cobertura XML
+- LCOV
+- Istanbul JSON
+- JaCoCo XML
+- Coverage.py reports
+
+### Quality Heuristics
+- Assertion density (assertions per test)
+- Test independence (no shared state)
+- Mock appropriateness (not over-mocking)
+- Test naming clarity (descriptive names)
+
+## Context Injection
+
+When spawned by orchestrator, receives:
+
+```json
+{
+  "task_id": "unique-task-id",
+  "agent_id": "test-validation-agent-1",
+  "iteration": 1,
+  "test_output_path": "tests/results/test-output.txt",
+  "coverage_report_path": "coverage/coverage-summary.json",
+  "coverage_threshold": 80,
+  "acceptance_criteria": [
+    "All tests must pass",
+    "Coverage >= 80%",
+    "No skipped tests in CI mode"
+  ]
+}
+```
+
+## Evidence Chain Integration
+
+### Validation Log Structure
+```json
+{
+  "timestamp": "2025-10-31T12:00:00Z",
+  "agent_id": "test-validation-agent-1",
+  "task_id": "task-123",
+  "iteration": 1,
+  "validation_results": {
+    "tests_analyzed": 150,
+    "failures_detected": 2,
+    "coverage_percentage": 85.3,
+    "quality_issues": 5
+  },
+  "confidence_score": 0.82,
+  "issues": [
+    {
+      "type": "test_failure",
+      "file": "tests/auth.test.js",
+      "line": 45,
+      "severity": "high"
+    }
+  ]
+}
+```
+
+### Traceability
+- All validation steps logged to SQLite
+- Redis coordination events tracked
+- Report artifacts stored with task_id reference
+
+## Contributing
+
+Propose improvements to test validation heuristics via pull request with:
+- Justification for new validation check
+- Example test cases demonstrating issue detection
+- Performance impact analysis (validation speed)