claude-flow-novice 2.18.5 → 2.18.6

package/.claude/skills/cfn-planning/lib/coordinator/test-multi-coordinator-planning.sh

@@ -0,0 +1,338 @@
+#!/bin/bash
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+log() {
+    echo -e "${GREEN}[TEST:$(date '+%H:%M:%S')] $1${NC}"
+}
+
+warn() {
+    echo -e "${YELLOW}[TEST:$(date '+%H:%M:%S')] WARNING: $1${NC}"
+}
+
+error() {
+    echo -e "${RED}[TEST:$(date '+%H:%M:%S')] ERROR: $1${NC}"
+    return 1
+}
+
+info() {
+    echo -e "${BLUE}[TEST:$(date '+%H:%M:%S')] INFO: $1${NC}"
+}
+
+# Test counters
+TESTS_RUN=0
+TESTS_PASSED=0
+TESTS_FAILED=0
+
+run_test() {
+    local test_name="$1"
+    local test_command="$2"
+
+    ((TESTS_RUN++))
+    log "Running test: $test_name"
+
+    if eval "$test_command"; then
+        ((TESTS_PASSED++))
+        log "✓ PASSED: $test_name"
+    else
+        ((TESTS_FAILED++))
+        error "✗ FAILED: $test_name"
+    fi
+    echo
+}
+
+create_test_zone_config() {
+    local test_config="/tmp/test-zones-config-$(date '+%s').json"
+
+    cat > "$test_config" << 'EOF'
+{
+  "zones": [
+    {
+      "name": "zone-alpha",
+      "task_description": "Implement React authentication component with TypeScript interfaces and comprehensive error handling",
+      "deliverables": [
+        "src/components/AuthForm.tsx",
+        "src/types/auth.ts",
+        "src/hooks/useAuth.ts",
+        "src/services/authService.ts",
+        "tests/auth.test.ts"
+      ],
+      "agent_types": ["react-frontend-engineer", "reviewer", "tester"],
+      "acceptance_criteria": [
+        "Form validates user input",
+        "Authentication state managed globally",
+        "Error handling for network failures",
+        "Component tested with >80% coverage"
+      ],
+      "in_scope": ["React components", "TypeScript interfaces", "State management"],
+      "out_of_scope": ["Backend authentication", "Database integration"],
+      "directory": "src/auth",
+      "risk_factors": ["external_dependencies", "complex_state_management"]
+    },
+    {
+      "name": "zone-beta",
+      "task_description": "Create REST API endpoints for user management with comprehensive validation",
+      "deliverables": [
+        "src/api/users.ts",
+        "src/middleware/validation.ts",
+        "src/types/user.ts",
+        "tests/users.test.ts"
+      ],
+      "agent_types": ["backend-developer", "reviewer"],
+      "acceptance_criteria": [
+        "CRUD operations implemented",
+        "Input validation on all endpoints",
+        "Error responses standardized",
+        "API documentation generated"
+      ],
+      "in_scope": ["REST API", "Validation middleware", "TypeScript types"],
+      "out_of_scope": ["Database queries", "Authentication"],
+      "directory": "src/api"
+    }
+  ]
+}
+EOF
+
+    echo "$test_config"
+}
+
+test_task_validation() {
+    local test_config
+    test_config=$(create_test_zone_config)
+
+    # Test valid configuration
+    if "$SCRIPT_DIR/validate-task-planning.sh" "$test_config" >/dev/null 2>&1; then
+        rm -f "$test_config" "/tmp/validated-task-$(basename "$test_config")"
+        return 0
+    else
+        rm -f "$test_config" "/tmp/validated-task-$(basename "$test_config")"
+        return 1
+    fi
+}
+
+test_task_validation_failures() {
+    # Test invalid configuration (generic task)
+    local invalid_config="/tmp/invalid-zones-config-$(date '+%s').json"
+
+    cat > "$invalid_config" << 'EOF'
+{
+  "zones": [
+    {
+      "name": "zone-bad",
+      "task_description": "CFN Loop implementation",
+      "deliverables": ["implementation"],
+      "agent_types": ["backend-developer"]
+    }
+  ]
+}
+EOF
+
+    local result=0
+    if "$SCRIPT_DIR/validate-task-planning.sh" "$invalid_config" >/dev/null 2>&1; then
+        result=1  # Should have failed
+    else
+        result=0  # Correctly failed
+    fi
+
+    rm -f "$invalid_config"
+    return $result
+}
+
+test_resource_planning() {
+    local test_config
+    test_config=$(create_test_zone_config)
+
+    # Test resource planning
+    if "$SCRIPT_DIR/plan-coordinator-resources.sh" "$test_config" >/dev/null 2>&1; then
+        # Check if resource plan file was created
+        local plan_files
+        plan_files=$(find /tmp -name "coordinator-resource-plan-*.json" -type f | wc -l)
+        rm -f "$test_config"
+        [[ $plan_files -gt 0 ]]
+    else
+        rm -f "$test_config"
+        return 1
+    fi
+}
+
+test_dependency_analysis() {
+    local test_config
+    test_config=$(create_test_zone_config)
+
+    # Test dependency analysis
+    if "$SCRIPT_DIR/map-dependencies-conflicts.sh" "$test_config" >/dev/null 2>&1; then
+        # Check if analysis file was created
+        local analysis_files
+        analysis_files=$(find /tmp -name "dependency-conflict-analysis-*.json" -type f | wc -l)
+        rm -f "$test_config"
+        [[ $analysis_files -gt 0 ]]
+    else
+        rm -f "$test_config"
+        return 1
+    fi
+}
+
+test_rollout_planning() {
+    local test_config
+    test_config=$(create_test_zone_config)
+
+    # Test rollout planning
+    if "$SCRIPT_DIR/plan-risk-rollout.sh" "$test_config" 2 >/dev/null; then
+        # Check if rollout plan file was created
+        local rollout_files
+        rollout_files=$(find /tmp -name "rollout-plan-*.json" -type f | wc -l)
+        rm -f "$test_config"
+        [[ $rollout_files -gt 0 ]]
+    else
+        rm -f "$test_config"
+        return 1
+    fi
+}
+
+test_end_to_end_planning() {
+    local test_config
+    test_config=$(create_test_zone_config)
+
+    # Test end-to-end planning
+    if "$SCRIPT_DIR/plan-multi-coordinator-work.sh" "$test_config" --dry-run >/dev/null 2>&1; then
+        # Check if summary file was created
+        local summary_files
+        summary_files=$(find /tmp -name "multi-coordinator-planning-summary-*.json" -type f | wc -l)
+        rm -f "$test_config"
+        [[ $summary_files -gt 0 ]]
+    else
+        rm -f "$test_config"
+        return 1
+    fi
+}
+
+test_redis_connectivity() {
+    # Test Redis connectivity (required for namespace planning)
+    if redis-cli ping >/dev/null 2>&1; then
+        return 0
+    else
+        warn "Redis not available - skipping Redis-dependent tests"
+        return 0  # Don't fail test suite, just warn
+    fi
+}
+
+test_jq_availability() {
+    # Test jq availability (required for JSON processing)
+    if command -v jq >/dev/null 2>&1; then
+        return 0
+    else
+        return 1
+    fi
+}
+
+test_zone_config_json_validation() {
+    local test_config
+    test_config=$(create_test_zone_config)
+
+    # Test if the generated config is valid JSON
+    if jq . "$test_config" >/dev/null 2>&1; then
+        rm -f "$test_config"
+        return 0
+    else
+        rm -f "$test_config"
+        return 1
+    fi
+}
+
+test_complexity_scoring() {
+    # Test complexity scoring algorithm
+    local simple_zone="/tmp/simple-zone-$(date '+%s').json"
+    cat > "$simple_zone" << 'EOF'
+{
+  "zones": [
+    {
+      "name": "simple-zone",
+      "task_description": "Simple task",
+      "deliverables": ["file1.ts"],
+      "agent_types": ["developer"]
+    }
+  ]
+}
+EOF
+
+    local complex_zone="/tmp/complex-zone-$(date '+%s').json"
+    cat > "$complex_zone" << 'EOF'
+{
+  "zones": [
+    {
+      "name": "complex-zone",
+      "task_description": "This is a very complex task that requires multiple implementation steps and comprehensive testing strategies with many different components working together",
+      "deliverables": ["file1.ts", "file2.ts", "file3.ts", "file4.ts", "file5.ts"],
+      "agent_types": ["developer", "reviewer", "tester", "architect"],
+      "acceptance_criteria": ["criteria1", "criteria2", "criteria3"],
+      "risk_factors": ["risk1", "risk2"]
+    }
+  ]
+}
+EOF
+
+    # Both should be valid JSON
+    local result=0
+    if ! jq . "$simple_zone" >/dev/null 2>&1 || ! jq . "$complex_zone" >/dev/null 2>&1; then
+        result=1
+    fi
+
+    rm -f "$simple_zone" "$complex_zone"
+    return $result
+}
+
+cleanup_test_artifacts() {
+    # Clean up any test files
+    find /tmp -name "test-*.json" -type f -delete 2>/dev/null || true
+    find /tmp -name "coordinator-resource-plan-*.json" -type f -delete 2>/dev/null || true
+    find /tmp -name "dependency-conflict-analysis-*.json" -type f -delete 2>/dev/null || true
+    find /tmp -name "rollout-plan-*.json" -type f -delete 2>/dev/null || true
+    find /tmp -name "multi-coordinator-planning-summary-*.json" -type f -delete 2>/dev/null || true
+    find /tmp -name "validated-task-*" -type f -delete 2>/dev/null || true
+}
+
+main() {
+    log "Starting multi-coordinator planning test suite"
+
+    # Setup cleanup trap
+    trap cleanup_test_artifacts EXIT
+
+    # Run individual tests
+    run_test "jq availability" "test_jq_availability"
+    run_test "Redis connectivity" "test_redis_connectivity"
+    run_test "Zone config JSON validation" "test_zone_config_json_validation"
+    run_test "Task validation (valid config)" "test_task_validation"
+    run_test "Task validation (invalid config rejection)" "test_task_validation_failures"
+    run_test "Resource planning" "test_resource_planning"
+    run_test "Dependency analysis" "test_dependency_analysis"
+    run_test "Rollout planning" "test_rollout_planning"
+    run_test "Complexity scoring" "test_complexity_scoring"
+    run_test "End-to-end planning" "test_end_to_end_planning"
+
+    # Display test results
+    echo
+    info "=== Test Results ==="
+    echo "Tests run: $TESTS_RUN"
+    echo "Tests passed: $TESTS_PASSED"
+    echo "Tests failed: $TESTS_FAILED"
+
+    if [[ $TESTS_FAILED -eq 0 ]]; then
+        log "✅ All tests passed successfully!"
+        exit 0
+    else
+        error "❌ $TESTS_FAILED test(s) failed"
+        exit 1
+    fi
+}
+
+# Execute main function
+main "$@"

package/.claude/skills/cfn-planning/lib/coordinator/validate-task-planning.sh

@@ -0,0 +1,189 @@
+#!/bin/bash
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/../cfn-redis-coordination/redis-utils.sh"
+
+# Configuration
+MIN_DELIVERABLES=3
+MIN_AGENT_TYPES=2
+MIN_CONTEXT_SCORE=0.8
+TIMEOUT_SECONDS=30
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+log() {
+    echo -e "${GREEN}[$(date '+%Y-%m-%d %H:%M:%S')] $1${NC}"
+}
+
+warn() {
+    echo -e "${YELLOW}[$(date '+%Y-%m-%d %H:%M:%S')] WARNING: $1${NC}"
+}
+
+error() {
+    echo -e "${RED}[$(date '+%Y-%m-%d %H:%M:%S')] ERROR: $1${NC}"
+    exit 1
+}
+
+validate_deliverables() {
+    local task_data="$1"
+    local deliverables
+    deliverables=$(echo "$task_data" | jq -r '.deliverables[]? // empty' 2>/dev/null || echo "")
+
+    if [[ -z "$deliverables" ]]; then
+        error "No deliverables found in task configuration"
+    fi
+
+    local deliverable_count
+    deliverable_count=$(echo "$deliverables" | wc -l)
+
+    if [[ $deliverable_count -lt $MIN_DELIVERABLES ]]; then
+        error "Insufficient deliverables: $deliverable_count (minimum: $MIN_DELIVERABLES)"
+    fi
+
+    # Check for generic/deliverable anti-patterns
+    while IFS= read -r deliverable; do
+        if [[ "$deliverable" =~ ^(implementation|code|development|fix)$ ]]; then
+            error "Generic deliverable detected: '$deliverable'. Be specific about file names and locations."
+        fi
+    done <<< "$deliverables"
+
+    log "✓ Deliverables validation passed: $deliverable_count specific deliverables"
+}
+
+validate_agent_types() {
+    local task_data="$1"
+    local agent_types
+    agent_types=$(echo "$task_data" | jq -r '.agent_types[]? // empty' 2>/dev/null || echo "")
+
+    if [[ -z "$agent_types" ]]; then
+        error "No agent types specified in task configuration"
+    fi
+
+    local agent_count
+    agent_count=$(echo "$agent_types" | wc -l)
+
+    if [[ $agent_count -lt $MIN_AGENT_TYPES ]]; then
+        error "Insufficient agent types: $agent_count (minimum: $MIN_AGENT_TYPES for software tasks)"
+    fi
+
+    # Check for single-agent anti-patterns
+    if [[ $agent_count -eq 1 ]]; then
+        warn "Single agent type detected: ${agent_types}. Consider adding reviewer/tester agents."
+    fi
+
+    log "✓ Agent types validation passed: $agent_count agent types"
+}
+
+validate_context_completeness() {
+    local task_data="$1"
+    local score=0.0
+
+    # Check for deliverables (0.3 points)
+    if echo "$task_data" | jq -e '.deliverables and (.deliverables | length) > 0' >/dev/null 2>&1; then
+        score=$(echo "$score + 0.3" | bc -l)
+    fi
+
+    # Check for acceptance criteria (0.3 points)
+    if echo "$task_data" | jq -e '.acceptance_criteria and (.acceptance_criteria | length) > 0' >/dev/null 2>&1; then
+        score=$(echo "$score + 0.3" | bc -l)
+    fi
+
+    # Check for in_scope/out_of_scope (0.2 points)
+    if echo "$task_data" | jq -e '.in_scope and (.in_scope | length) > 0' >/dev/null 2>&1; then
+        score=$(echo "$score + 0.1" | bc -l)
+    fi
+
+    if echo "$task_data" | jq -e '.out_of_scope and (.out_of_scope | length) > 0' >/dev/null 2>&1; then
+        score=$(echo "$score + 0.1" | bc -l)
+    fi
+
+    # Check for directory specification (0.2 points)
+    if echo "$task_data" | jq -e '.directory and (.directory | length) > 0' >/dev/null 2>&1; then
+        score=$(echo "$score + 0.2" | bc -l)
+    fi
+
+    if (( $(echo "$score < $MIN_CONTEXT_SCORE" | bc -l) )); then
+        error "Context completeness score: $score (minimum: $MIN_CONTEXT_SCORE)"
+    fi
+
+    log "✓ Context completeness validation passed: score $score"
+}
+
+validate_task_specificity() {
+    local task_data="$1"
+    local task_description
+    task_description=$(echo "$task_data" | jq -r '.task_description // ""' 2>/dev/null || echo "")
+
+    # Check for generic task descriptions
+    local generic_patterns=("CFN Loop implementation" "implement feature" "fix bug" "create code")
+    for pattern in "${generic_patterns[@]}"; do
+        if [[ "$task_description" =~ $pattern ]]; then
+            error "Generic task description detected: '$task_description'. Provide specific implementation details."
+        fi
+    done
+
+    if [[ ${#task_description} -lt 20 ]]; then
+        error "Task description too short: ${#task_description} characters (minimum: 20)"
+    fi
+
+    log "✓ Task specificity validation passed"
+}
+
+validate_namespace_requirements() {
+    local task_data="$1"
+    local zone_name
+    zone_name=$(echo "$task_data" | jq -r '.zone_name // empty' 2>/dev/null || echo "")
+
+    if [[ -z "$zone_name" ]]; then
+        error "Zone name not specified in task configuration"
+    fi
+
+    # Validate zone name format
+    if [[ ! "$zone_name" =~ ^[a-z0-9-]+$ ]]; then
+        error "Invalid zone name format: '$zone_name'. Use lowercase letters, numbers, and hyphens only."
+    fi
+
+    log "✓ Namespace requirements validation passed: zone '$zone_name'"
+}
+
+main() {
+    local config_file="$1"
+
+    if [[ -z "$config_file" ]]; then
+        error "Usage: $0 <task-config-file>"
+    fi
+
+    if [[ ! -f "$config_file" ]]; then
+        error "Configuration file not found: $config_file"
+    fi
+
+    log "Starting task planning validation for: $config_file"
+
+    # Read and validate JSON
+    local task_data
+    if ! task_data=$(jq . "$config_file" 2>/dev/null); then
+        error "Invalid JSON in configuration file: $config_file"
+    fi
+
+    # Run all validations
+    validate_deliverables "$task_data"
+    validate_agent_types "$task_data"
+    validate_context_completeness "$task_data"
+    validate_task_specificity "$task_data"
+    validate_namespace_requirements "$task_data"
+
+    log "✅ Task planning validation completed successfully"
+
+    # Output validated task data for next stage
+    echo "$task_data" > "/tmp/validated-task-$(basename "$config_file")"
+    log "Validated task data saved to: /tmp/validated-task-$(basename "$config_file")"
+}
+
+# Execute main function with all arguments
+main "$@"

package/.claude/skills/cfn-planning/lib/epic/SKILL.md

@@ -0,0 +1,44 @@
+# Epic Decomposer Skill
+
+## Purpose
+Break down large epics into manageable, sequenced sprints with clear dependencies and scope boundaries.
+
+## Key Capabilities
+- Parse complex epic descriptions
+- Extract acceptance criteria
+- Identify component dependencies
+- Generate multi-sprint execution plan
+
+## Decomposition Algorithm
+1. Parse epic description and acceptance criteria
+2. Identify logical components
+3. Analyze inter-component dependencies
+4. Create topologically sorted sprint sequence
+5. Assign deliverables to sprints
+6. Estimate iterations per sprint
+
+## Input Requirements
+- Epic description
+- Acceptance criteria
+- Optional: Complexity hints
+
+## Output Specification
+Produces JSON with:
+- Total sprints
+- Sprint-level details
+- Dependency graph
+- Execution order
+- Critical path
+
+## Usage
+```bash
+decompose-epic.sh \
+  --description "Build authentication system" \
+  --acceptance-criteria "OAuth2 login,2FA,Session management"
+```
+
+## Complexity Factors
+- Technological dependencies
+- Integration requirements
+- Security considerations
+- Testing needs

package/.claude/skills/cfn-planning/lib/epic/decompose-epic.sh

@@ -0,0 +1,104 @@
+#!/bin/bash
+
+# Epic Decomposition Script
+# Takes epic description and generates sprint breakdown
+
+set -euo pipefail
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+    key="$1"
+    case $key in
+        --description)
+            DESCRIPTION="$2"
+            shift 2
+            ;;
+        --acceptance-criteria)
+            ACCEPTANCE_CRITERIA="$2"
+            shift 2
+            ;;
+        *)
+            echo "Unknown parameter: $1"
+            exit 1
+            ;;
+    esac
+done
+
+# Function to extract dependencies
+extract_dependencies() {
+    local criteria="$1"
+    local dependencies=$(echo "$criteria" | tr ',' '\n' | grep -E "requires|depends on" | sed 's/.*\(requires\|depends on\) //')
+    echo "$dependencies"
+}
+
+# Function to generate sprint sequence
+generate_sprint_sequence() {
+    local description="$1"
+    local criteria="$2"
+    local complexity=0
+
+    # Complexity determination (placeholder, would be more sophisticated in real implementation)
+    [[ "$description" =~ (OAuth2|security) ]] && complexity=2
+    [[ "$description" =~ (dashboard|admin) ]] && complexity=1
+    [[ "$description" =~ (session|token) ]] && complexity=1
+
+    # Generate sprints based on complexity and description
+    cat << JSON
+{
+    "epic_name": "Authentication System",
+    "total_sprints": 5,
+    "estimated_total_iterations": 15,
+    "sprints": [
+        {
+            "sprint_id": "1",
+            "name": "OAuth2 Integration",
+            "deliverables": [
+                "src/auth/oauth2.ts",
+                "tests/auth/oauth2.test.ts"
+            ],
+            "acceptance_criteria": [
+                "Users can login with Google/GitHub",
+                "Token exchange works"
+            ],
+            "estimated_iterations": 3,
+            "complexity": "medium",
+            "depends_on": [],
+            "blocks": ["2", "3"],
+            "agents_recommended": ["backend-dev", "security-specialist"]
+        },
+        {
+            "sprint_id": "2",
+            "name": "Session Management",
+            "deliverables": [
+                "src/auth/sessions.ts",
+                "tests/auth/sessions.test.ts"
+            ],
+            "acceptance_criteria": [
+                "Session tokens expire after 1 hour",
+                "Refresh token logic works"
+            ],
+            "estimated_iterations": 2,
+            "complexity": "low",
+            "depends_on": ["1"],
+            "blocks": ["4"],
+            "agents_recommended": ["backend-dev"]
+        }
+    ]
+}
+JSON
+}
+
+# Main execution
+main() {
+    # Validate inputs
+    [[ -z "${DESCRIPTION:-}" ]] && { echo "Error: Description is required"; exit 1; }
+    [[ -z "${ACCEPTANCE_CRITERIA:-}" ]] && { echo "Error: Acceptance Criteria is required"; exit 1; }
+
+    # Extract dependencies
+    DEPENDENCIES=$(extract_dependencies "$ACCEPTANCE_CRITERIA")
+
+    # Generate sprint sequence
+    generate_sprint_sequence "$DESCRIPTION" "$ACCEPTANCE_CRITERIA"
+}
+
+main