claude-flow-novice 2.5.2 → 2.8.1

package/.claude/skills/cfn-loop-orchestration/security_utils.sh

@@ -0,0 +1,99 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Security Utilities for CFN Loop Orchestration
+# Provides input sanitization and validation functions
+##############################################################################
+
+# Validate and sanitize input for agent IDs, task IDs, iteration numbers
+# Allowed characters: alphanumeric, dash, underscore
+# Maximum length: 64 characters
+function sanitize_input() {
+    local input="$1"
+    local max_length="${2:-64}"
+    local pattern="^[a-zA-Z0-9_-]+$"
+
+    # Check if input is empty
+    if [ -z "$input" ]; then
+        echo "Error: Input cannot be empty" >&2
+        return 1
+    fi
+
+    # Check input length
+    if [ ${#input} -gt "$max_length" ]; then
+        echo "Error: Input exceeds maximum length of $max_length characters" >&2
+        return 1
+    fi
+
+    # Validate against allowed pattern
+    if [[ ! "$input" =~ $pattern ]]; then
+        echo "Error: Invalid characters in input. Only alphanumeric, dash, and underscore allowed" >&2
+        return 1
+    fi
+
+    # If all checks pass, echo the sanitized input
+    echo "$input"
+}
+
+# Validate context JSON (optional JSON structure validation)
+function validate_json_context() {
+    local context="$1"
+
+    # If context is empty, return success
+    if [ -z "$context" ]; then
+        return 0
+    fi
+
+    # Use jq to validate JSON structure, silently discard output
+    if ! echo "$context" | jq -e . >/dev/null 2>&1; then
+        echo "Error: Invalid JSON context" >&2
+        return 1
+    fi
+
+    return 0
+}
+
+# Safe Redis key generator
+function generate_safe_redis_key() {
+    local prefix="$1"
+    local task_id="$2"
+    local suffix="${3:-}"
+
+    # Sanitize all input components
+    local safe_prefix
+    local safe_task_id
+    local safe_suffix
+
+    safe_prefix=$(sanitize_input "$prefix" 32) || return 1
+    safe_task_id=$(sanitize_input "$task_id" 64) || return 1
+
+    # Suffix is optional, but if provided, must be sanitized
+    if [ -n "$suffix" ]; then
+        safe_suffix=$(sanitize_input "$suffix" 32) || return 1
+        echo "swarm:${safe_prefix}:${safe_task_id}:${safe_suffix}"
+    else
+        echo "swarm:${safe_prefix}:${safe_task_id}"
+    fi
+}
+
+# Validation function for agent lists
+function validate_agent_list() {
+    local agents="$1"
+
+    # Check if empty
+    if [ -z "$agents" ]; then
+        echo "Error: Agent list cannot be empty" >&2
+        return 1
+    fi
+
+    # Split agents and validate each
+    IFS=',' read -ra AGENT_ARRAY <<< "$agents"
+    for agent in "${AGENT_ARRAY[@]}"; do
+        if ! sanitize_input "$agent" 64 >/dev/null; then
+            echo "Error: Invalid agent ID: $agent" >&2
+            return 1
+        fi
+    done
+
+    return 0
+}

package/.claude/skills/cfn-loop-orchestration/test-cfn-orchestration.sh

@@ -0,0 +1,281 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# CFN Loop Orchestration Test Suite
+# Version: 1.0.0
+#
+# Comprehensive tests for modular CFN Loop Orchestration skill
+##############################################################################
+
+set -euo pipefail
+
+# Test configuration
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+HELPERS_DIR="$SCRIPT_DIR/helpers"
+TEST_TASK_ID="test-cfn-$(date +%s)"
+PASSED=0
+FAILED=0
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+##############################################################################
+# Test Helper Functions
+##############################################################################
+
+function test_passed() {
+  local test_name="$1"
+  echo -e "${GREEN}✓${NC} $test_name"
+  PASSED=$((PASSED + 1))
+}
+
+function test_failed() {
+  local test_name="$1"
+  local reason="$2"
+  echo -e "${RED}✗${NC} $test_name: $reason"
+  FAILED=$((FAILED + 1))
+}
+
+function cleanup_test() {
+  local task_id="$1"
+  # Clean up Redis keys for test
+  redis-cli --scan --pattern "swarm:${task_id}:*" | xargs -r redis-cli del > /dev/null 2>&1 || true
+}
+
+##############################################################################
+# Test Cases
+##############################################################################
+
+echo "=============================================="
+echo "CFN Loop Orchestration Test Suite"
+echo "=============================================="
+echo ""
+
+# Test 1: Gate Check Helper - Pass
+echo "Test 1: Gate Check - Pass Scenario"
+cleanup_test "$TEST_TASK_ID"
+
+# Simulate Loop 3 agents with high confidence
+redis-cli lpush "swarm:${TEST_TASK_ID}:agent1:result" "0.85" > /dev/null
+redis-cli lpush "swarm:${TEST_TASK_ID}:agent2:result" "0.90" > /dev/null
+redis-cli lpush "swarm:${TEST_TASK_ID}:agent3:result" "0.88" > /dev/null
+
+if "$HELPERS_DIR/gate-check.sh" \
+     --task-id "$TEST_TASK_ID" \
+     --agents "agent1,agent2,agent3" \
+     --threshold "0.75" \
+     --min-quorum "0.66" > /dev/null 2>&1; then
+  # Check that gate-passed signal was sent
+  if redis-cli --raw lrange "swarm:${TEST_TASK_ID}:gate-passed" 0 -1 | grep -q "1"; then
+    test_passed "Gate check PASS with signal broadcast"
+  else
+    test_failed "Gate check PASS" "Signal not broadcast to Loop 2"
+  fi
+else
+  test_failed "Gate check PASS" "Should have passed with 0.87 avg confidence"
+fi
+
+cleanup_test "$TEST_TASK_ID"
+echo ""
+
+# Test 2: Gate Check Helper - Fail
+echo "Test 2: Gate Check - Fail Scenario"
+cleanup_test "$TEST_TASK_ID"
+
+# Simulate Loop 3 agents with low confidence
+redis-cli lpush "swarm:${TEST_TASK_ID}:agent1:result" "0.65" > /dev/null
+redis-cli lpush "swarm:${TEST_TASK_ID}:agent2:result" "0.70" > /dev/null
+redis-cli lpush "swarm:${TEST_TASK_ID}:agent3:result" "0.68" > /dev/null
+
+if ! "$HELPERS_DIR/gate-check.sh" \
+       --task-id "$TEST_TASK_ID" \
+       --agents "agent1,agent2,agent3" \
+       --threshold "0.75" \
+       --min-quorum "0.66" > /dev/null 2>&1; then
+  test_passed "Gate check FAIL detection"
+else
+  test_failed "Gate check FAIL" "Should have failed with 0.67 avg confidence"
+fi
+
+cleanup_test "$TEST_TASK_ID"
+echo ""
+
+# Test 3: Consensus Check Helper - Pass
+echo "Test 3: Consensus Check - Pass Scenario"
+cleanup_test "$TEST_TASK_ID"
+
+# Simulate Loop 2 validators with high consensus
+redis-cli lpush "swarm:${TEST_TASK_ID}:reviewer1:result" "0.92" > /dev/null
+redis-cli lpush "swarm:${TEST_TASK_ID}:tester1:result" "0.95" > /dev/null
+redis-cli lpush "swarm:${TEST_TASK_ID}:security1:result" "0.91" > /dev/null
+
+if "$HELPERS_DIR/consensus.sh" \
+     --task-id "$TEST_TASK_ID" \
+     --agents "reviewer1,tester1,security1" \
+     --threshold "0.90" \
+     --min-quorum "0.66" > /dev/null 2>&1; then
+  test_passed "Consensus check PASS"
+else
+  test_failed "Consensus check PASS" "Should have passed with 0.93 avg consensus"
+fi
+
+cleanup_test "$TEST_TASK_ID"
+echo ""
+
+# Test 4: Consensus Check Helper - Fail
+echo "Test 4: Consensus Check - Fail Scenario"
+cleanup_test "$TEST_TASK_ID"
+
+# Simulate Loop 2 validators with low consensus
+redis-cli lpush "swarm:${TEST_TASK_ID}:reviewer1:result" "0.82" > /dev/null
+redis-cli lpush "swarm:${TEST_TASK_ID}:tester1:result" "0.85" > /dev/null
+redis-cli lpush "swarm:${TEST_TASK_ID}:security1:result" "0.88" > /dev/null
+
+if ! "$HELPERS_DIR/consensus.sh" \
+       --task-id "$TEST_TASK_ID" \
+       --agents "reviewer1,tester1,security1" \
+       --threshold "0.90" \
+       --min-quorum "0.66" > /dev/null 2>&1; then
+  test_passed "Consensus check FAIL detection"
+else
+  test_failed "Consensus check FAIL" "Should have failed with 0.85 avg consensus"
+fi
+
+cleanup_test "$TEST_TASK_ID"
+echo ""
+
+# Test 5: Deliverable Verifier - File Exists
+echo "Test 5: Deliverable Verifier - File Exists"
+
+# Create test file
+TEST_FILE="/tmp/test-deliverable-$$.txt"
+echo "test content" > "$TEST_FILE"
+
+if "$HELPERS_DIR/deliverable-verifier.sh" \
+     --expected-files "$TEST_FILE" \
+     --task-type "implement feature" > /dev/null 2>&1; then
+  test_passed "Deliverable verification - file exists"
+else
+  test_failed "Deliverable verification" "Should have passed with existing file"
+fi
+
+# Cleanup
+rm -f "$TEST_FILE"
+echo ""
+
+# Test 6: Deliverable Verifier - Missing File
+echo "Test 6: Deliverable Verifier - Missing File"
+
+# Reference non-existent file
+TEST_FILE="/tmp/nonexistent-file-$$.txt"
+
+if ! "$HELPERS_DIR/deliverable-verifier.sh" \
+       --expected-files "$TEST_FILE" \
+       --task-type "create component" > /dev/null 2>&1; then
+  test_passed "Deliverable verification - missing file detection"
+else
+  test_failed "Deliverable verification" "Should have failed with missing file"
+fi
+
+echo ""
+
+# Test 7: Timeout Calculator - Phase-Specific
+echo "Test 7: Timeout Calculator - Phase-Specific"
+
+PHASE1_TIMEOUT=$("$HELPERS_DIR/timeout-calculator.sh" --phase-id "phase-1")
+PHASE2_TIMEOUT=$("$HELPERS_DIR/timeout-calculator.sh" --phase-id "phase-2")
+UNKNOWN_TIMEOUT=$("$HELPERS_DIR/timeout-calculator.sh" --phase-id "unknown-phase")
+
+if [ "$PHASE1_TIMEOUT" = "900" ] && [ "$PHASE2_TIMEOUT" = "3600" ] && [ "$UNKNOWN_TIMEOUT" = "3600" ]; then
+  test_passed "Timeout calculator - phase-specific values"
+else
+  test_failed "Timeout calculator" "Expected 900, 3600, 3600 but got $PHASE1_TIMEOUT, $PHASE2_TIMEOUT, $UNKNOWN_TIMEOUT"
+fi
+
+echo ""
+
+# Test 8: Iteration Manager - Wake Agents
+echo "Test 8: Iteration Manager - Agent Wake"
+cleanup_test "$TEST_TASK_ID"
+
+# Simulate agents in waiting mode
+redis-cli lpush "swarm:${TEST_TASK_ID}:agent1:wake" "" > /dev/null
+redis-cli lpush "swarm:${TEST_TASK_ID}:agent2:wake" "" > /dev/null
+
+# Store feedback
+redis-cli set "swarm:${TEST_TASK_ID}:feedback:agent1" "Improve test coverage" > /dev/null
+redis-cli set "swarm:${TEST_TASK_ID}:feedback:agent2" "Add error handling" > /dev/null
+
+if "$HELPERS_DIR/iteration-manager.sh" \
+     --task-id "$TEST_TASK_ID" \
+     --iteration "2" \
+     --agents "agent1,agent2" \
+     --feedback-source "swarm:${TEST_TASK_ID}:feedback" > /dev/null 2>&1; then
+  test_passed "Iteration manager - agent wake"
+else
+  test_failed "Iteration manager" "Failed to wake agents"
+fi
+
+cleanup_test "$TEST_TASK_ID"
+echo ""
+
+# Test 9: Helper Script Parameter Validation
+echo "Test 9: Parameter Validation"
+
+# Test gate-check.sh without required params
+if ! "$HELPERS_DIR/gate-check.sh" > /dev/null 2>&1; then
+  test_passed "Parameter validation - gate-check.sh"
+else
+  test_failed "Parameter validation" "gate-check.sh should fail without params"
+fi
+
+# Test consensus.sh without required params
+if ! "$HELPERS_DIR/consensus.sh" > /dev/null 2>&1; then
+  test_passed "Parameter validation - consensus.sh"
+else
+  test_failed "Parameter validation" "consensus.sh should fail without params"
+fi
+
+echo ""
+
+# Test 10: SKILL.md Metadata Validation
+echo "Test 10: SKILL.md Metadata Validation"
+
+if [ -f "$SCRIPT_DIR/SKILL.md" ]; then
+  # Check for required metadata fields
+  if grep -q "Skill ID:" "$SCRIPT_DIR/SKILL.md" && \
+     grep -q "Version:" "$SCRIPT_DIR/SKILL.md" && \
+     grep -q "Dependencies:" "$SCRIPT_DIR/SKILL.md" && \
+     grep -q "Purpose" "$SCRIPT_DIR/SKILL.md"; then
+    test_passed "SKILL.md metadata completeness"
+  else
+    test_failed "SKILL.md metadata" "Missing required fields"
+  fi
+else
+  test_failed "SKILL.md" "File not found"
+fi
+
+echo ""
+
+##############################################################################
+# Test Summary
+##############################################################################
+
+echo "=============================================="
+echo "Test Summary"
+echo "=============================================="
+echo -e "${GREEN}Passed:${NC} $PASSED"
+echo -e "${RED}Failed:${NC} $FAILED"
+echo "Total: $((PASSED + FAILED))"
+echo "=============================================="
+
+if [ $FAILED -eq 0 ]; then
+  echo -e "${GREEN}All tests passed!${NC}"
+  exit 0
+else
+  echo -e "${RED}Some tests failed${NC}"
+  exit 1
+fi

package/.claude/skills/cfn-loop-orchestration/test-edge-cases.sh

@@ -0,0 +1,188 @@
+#!/bin/bash
+# Edge Case Test Suite for CFN Loop Orchestration
+
+set -e
+
+# Results tracking
+TOTAL_TESTS=0
+PASSED_TESTS=0
+OUTPUT_FILE="/tmp/edge-case-test-results.md"
+
+# Utility function
+log_test() {
+    local test_name="$1"
+    local result="$2"
+    local reason="${3:-No details}"
+
+    TOTAL_TESTS=$((TOTAL_TESTS + 1))
+
+    if [[ "$result" == "PASS" ]]; then
+        PASSED_TESTS=$((PASSED_TESTS + 1))
+        echo "- [x] $test_name" >> "$OUTPUT_FILE"
+    else
+        echo "- [ ] $test_name (FAILED)" >> "$OUTPUT_FILE"
+        echo "  - Reason: $reason" >> "$OUTPUT_FILE"
+    fi
+}
+
+# Prepare results file
+echo "# CFN Loop Edge Case Test Suite" > "$OUTPUT_FILE"
+echo "## Test Execution: $(date)" >> "$OUTPUT_FILE"
+echo "---" >> "$OUTPUT_FILE"
+
+# Test context injection
+test_context_injection() {
+    # Test empty context
+    if echo '{}' | jq empty >/dev/null 2>&1; then
+        log_test "Empty Context" "PASS"
+    else
+        log_test "Empty Context" "FAIL" "JSON parsing failed"
+    fi
+
+    # Test large context
+    local large_context=$(python3 -c "
+import json
+print(json.dumps({
+    'deliverables': [f'file_{i}' for i in range(1000)],
+    'description': 'A' * 10000
+}))
+")
+
+    if echo "$large_context" | jq empty >/dev/null 2>&1; then
+        log_test "Large Context" "PASS"
+    else
+        log_test "Large Context" "FAIL" "Large JSON parsing failed"
+    fi
+
+    # Test Unicode context
+    local unicode_context='{"key": "こんにちは世界"}'
+    if echo "$unicode_context" | jq empty >/dev/null 2>&1; then
+        log_test "Unicode Context" "PASS"
+    else
+        log_test "Unicode Context" "FAIL" "Unicode JSON parsing failed"
+    fi
+
+    # Test malformed JSON
+    local malformed_cases=(
+        '{invalid json'
+        '{"key": "value"'
+        '{]'
+        '{"nested": {]}'
+    )
+
+    for case in "${malformed_cases[@]}"; do
+        if ! echo "$case" | jq empty >/dev/null 2>&1; then
+            log_test "Malformed JSON: $case" "PASS"
+        else
+            log_test "Malformed JSON: $case" "FAIL" "Should fail parsing"
+        fi
+    done
+}
+
+# Test confidence handling
+test_confidence_handling() {
+    # Test valid confidence ranges
+    local confidence_cases=(0.0 0.5 0.75 1.0)
+    local invalid_cases=(-0.1 1.1)
+
+    for conf in "${confidence_cases[@]}"; do
+        if [[ $(echo "$conf >= 0.0 && $conf <= 1.0" | bc) -eq 1 ]]; then
+            log_test "Confidence Range: $conf" "PASS"
+        else
+            log_test "Confidence Range: $conf" "FAIL" "Out of valid range"
+        fi
+    done
+
+    for conf in "${invalid_cases[@]}"; do
+        if [[ $(echo "$conf >= 0.0 && $conf <= 1.0" | bc) -eq 0 ]]; then
+            log_test "Invalid Confidence: $conf" "PASS"
+        else
+            log_test "Invalid Confidence: $conf" "FAIL" "Should be rejected"
+        fi
+    done
+
+    # Test mixed confidence formats
+    local mixed_cases=(
+        '{"agent1": 0.85, "agent2": "high", "agent3": 90}'
+        '{"agent1": 95, "agent2": 0.95, "agent3": "excellent"}'
+    )
+
+    for case in "${mixed_cases[@]}"; do
+        if echo "$case" | jq . >/dev/null 2>&1; then
+            log_test "Mixed Confidence Format" "PASS"
+        else
+            log_test "Mixed Confidence Format" "FAIL" "Unable to parse mixed format"
+        fi
+    done
+}
+
+# Test agent spawning
+test_agent_spawning() {
+    # Simulate agent list scenarios
+    local single_agent=("test-agent")
+    local duplicate_agents=("agent1" "agent1" "agent2")
+    local many_agents=("agent1" "agent2" "agent3" "agent4" "agent5")
+
+    if [[ "${#single_agent[@]}" -eq 1 ]]; then
+        log_test "Single Agent Spawn" "PASS"
+    else
+        log_test "Single Agent Spawn" "FAIL" "Incorrect agent count"
+    fi
+
+    local unique_agents=($(echo "${duplicate_agents[@]}" | tr ' ' '\n' | sort -u))
+    if [[ "${#unique_agents[@]}" -lt "${#duplicate_agents[@]}" ]]; then
+        log_test "Duplicate Agents Detection" "PASS"
+    else
+        log_test "Duplicate Agents Detection" "FAIL" "Failed to detect duplicates"
+    fi
+
+    if [[ "${#many_agents[@]}" -ge 3 ]]; then
+        log_test "Multiple Agent Spawn" "PASS"
+    else
+        log_test "Multiple Agent Spawn" "FAIL" "Insufficient agents"
+    fi
+}
+
+# Test Redis connectivity
+test_redis_connectivity() {
+    if redis-cli ping | grep -q PONG; then
+        log_test "Redis Connection" "PASS"
+    else
+        log_test "Redis Connection" "FAIL" "Cannot connect to Redis"
+    fi
+
+    # Test Redis key operations
+    local test_key="cfn_loop_test_$(date +%s)"
+    if redis-cli SET "$test_key" "test_value" &&
+       redis-cli GET "$test_key" | grep -q "test_value" &&
+       redis-cli DEL "$test_key" >/dev/null; then
+        log_test "Redis Key Operations" "PASS"
+    else
+        log_test "Redis Key Operations" "FAIL" "Failed basic Redis operations"
+    fi
+}
+
+# Main test execution
+main() {
+    test_context_injection
+    test_confidence_handling
+    test_agent_spawning
+    test_redis_connectivity
+
+    # Summarize results
+    echo "" >> "$OUTPUT_FILE"
+    echo "## Test Summary" >> "$OUTPUT_FILE"
+    echo "- Total Tests: $TOTAL_TESTS" >> "$OUTPUT_FILE"
+    echo "- Passed: $PASSED_TESTS" >> "$OUTPUT_FILE"
+    echo "- Failure Rate: $((TOTAL_TESTS - PASSED_TESTS))/$TOTAL_TESTS" >> "$OUTPUT_FILE"
+
+    local confidence=$(echo "scale=2; $PASSED_TESTS / $TOTAL_TESTS" | bc)
+    echo "CONFIDENCE_SCORE=$confidence" > /tmp/edge_case_confidence.txt
+
+    cat "$OUTPUT_FILE"
+    echo ""
+    cat /tmp/edge_case_confidence.txt
+}
+
+# Run tests
+main