claude-flow-novice 2.18.6 → 2.18.7

package/claude-assets/skills/cfn-utilities/test.sh

@@ -1,317 +0,0 @@
-#!/usr/bin/env bash
-# CFN Utilities Test Suite
-# Tests all utility functions in lib/
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "$SCRIPT_DIR/execute.sh"
-
-# Test counters
-TESTS_RUN=0
-TESTS_PASSED=0
-TESTS_FAILED=0
-
-# Test result helpers
-pass() {
-    echo "PASS: $1"
-    TESTS_PASSED=$((TESTS_PASSED + 1))
-    TESTS_RUN=$((TESTS_RUN + 1))
-}
-
-fail() {
-    echo "FAIL: $1"
-    TESTS_FAILED=$((TESTS_FAILED + 1))
-    TESTS_RUN=$((TESTS_RUN + 1))
-}
-
-assert_equals() {
-    local expected="$1"
-    local actual="$2"
-    local test_name="$3"
-
-    if [ "$expected" = "$actual" ]; then
-        pass "$test_name"
-    else
-        fail "$test_name (expected: '$expected', got: '$actual')"
-    fi
-}
-
-assert_contains() {
-    local haystack="$1"
-    local needle="$2"
-    local test_name="$3"
-
-    if [[ "$haystack" == *"$needle"* ]]; then
-        pass "$test_name"
-    else
-        fail "$test_name (string '$needle' not found in output)"
-    fi
-}
-
-assert_success() {
-    local test_name="$1"
-    pass "$test_name"
-}
-
-assert_failure() {
-    local test_name="$1"
-    fail "$test_name"
-}
-
-# Cleanup temporary test files
-cleanup() {
-    rm -f /tmp/cfn-test-*
-}
-trap cleanup EXIT
-
-echo "=== CFN Utilities Test Suite ==="
-echo ""
-
-# ===== LOGGING TESTS =====
-echo "--- Testing Logging Functions ---"
-
-# Test: log_json outputs valid JSON
-output=$(log_json "info" "test message" '{"key":"value"}' 2>&1)
-if echo "$output" | grep -q '"timestamp"' && echo "$output" | grep -q '"level":"info"' && echo "$output" | grep -q '"message":"test message"'; then
-    pass "log_json outputs valid JSON structure"
-else
-    fail "log_json output invalid: $output"
-fi
-
-# Test: log_info outputs to stderr
-output=$(log_info "info test" '{}' 2>&1 >/dev/null)
-if echo "$output" | grep -q '"level":"info"'; then
-    pass "log_info outputs to stderr"
-else
-    fail "log_info output incorrect"
-fi
-
-# Test: log_error includes error level
-output=$(log_error "error test" '{"code":"E001"}' 2>&1)
-if echo "$output" | grep -q '"level":"error"' && echo "$output" | grep -q 'E001'; then
-    pass "log_error includes error level and context"
-else
-    fail "log_error output incorrect"
-fi
-
-# Test: log_debug respects LOG_LEVEL
-LOG_LEVEL=info
-output=$(log_debug "debug test" '{}' 2>&1)
-if [ -z "$output" ]; then
-    pass "log_debug respects LOG_LEVEL=info (no output)"
-else
-    fail "log_debug should not output when LOG_LEVEL=info"
-fi
-
-LOG_LEVEL=debug
-output=$(log_debug "debug test" '{}' 2>&1)
-if echo "$output" | grep -q '"level":"debug"'; then
-    pass "log_debug outputs when LOG_LEVEL=debug"
-else
-    fail "log_debug should output when LOG_LEVEL=debug"
-fi
-
-# Test: generate_correlation_id produces output
-corr_id=$(generate_correlation_id)
-if [ -n "$corr_id" ]; then
-    pass "generate_correlation_id produces non-empty ID"
-else
-    fail "generate_correlation_id produced empty ID"
-fi
-
-# ===== ERROR HANDLING TESTS =====
-echo ""
-echo "--- Testing Error Handling Functions ---"
-
-# Test: error_handle returns error code
-if error_handle "test error" '{}' 2>/dev/null; then
-    fail "error_handle should return non-zero exit code"
-else
-    pass "error_handle returns non-zero exit code"
-fi
-
-# Test: is_error_code detects specific codes
-EXITCODE=7
-if is_error_code $EXITCODE 7; then
-    pass "is_error_code detects correct exit code"
-else
-    fail "is_error_code should detect exit code 7"
-fi
-
-# Test: get_error_context returns JSON structure
-test_exit_42() { return 42; }
-test_exit_42 || true
-context=$(get_error_context)
-if echo "$context" | grep -q '"exit_code"' && echo "$context" | grep -q '"line"'; then
-    pass "get_error_context returns JSON structure"
-else
-    fail "get_error_context output invalid: $context"
-fi
-
-# ===== RETRY TESTS =====
-echo ""
-echo "--- Testing Retry Functions ---"
-
-# Test: retry_with_backoff succeeds on first try
-counter=0
-test_command() {
-    counter=$((counter + 1))
-    return 0
-}
-if retry_with_backoff 3 1 test_command 2>/dev/null; then
-    pass "retry_with_backoff succeeds immediately"
-else
-    fail "retry_with_backoff should succeed"
-fi
-
-# Test: retry_with_backoff retries on failure
-attempt_count=0
-failing_command() {
-    attempt_count=$((attempt_count + 1))
-    [ $attempt_count -ge 3 ]
-}
-if retry_with_backoff 5 1 failing_command 2>/dev/null; then
-    assert_equals "3" "$attempt_count" "retry_with_backoff retries correct number of times"
-else
-    fail "retry_with_backoff should eventually succeed"
-fi
-
-# Test: retry_with_backoff gives up after max attempts
-always_fail() {
-    return 1
-}
-if retry_with_backoff 2 1 always_fail 2>/dev/null; then
-    fail "retry_with_backoff should fail after max attempts"
-else
-    pass "retry_with_backoff gives up after max attempts"
-fi
-
-# Test: retry_fixed uses fixed delay
-fixed_count=0
-fixed_test() {
-    fixed_count=$((fixed_count + 1))
-    [ $fixed_count -ge 2 ]
-}
-if retry_fixed 3 1 fixed_test 2>/dev/null; then
-    pass "retry_fixed works with fixed delay"
-else
-    fail "retry_fixed should succeed"
-fi
-
-# ===== FILE OPERATIONS TESTS =====
-echo ""
-echo "--- Testing File Operations ---"
-
-# Test: atomic_write creates file
-test_file="/tmp/cfn-test-atomic-$$"
-if atomic_write "$test_file" "test content" 2>/dev/null; then
-    if [ -f "$test_file" ] && [ "$(cat "$test_file")" = "test content" ]; then
-        pass "atomic_write creates file with correct content"
-    else
-        fail "atomic_write file content incorrect"
-    fi
-else
-    fail "atomic_write failed"
-fi
-
-# Test: atomic_write is actually atomic (no .tmp files left)
-test_file2="/tmp/cfn-test-atomic2-$$"
-atomic_write "$test_file2" "content" 2>/dev/null
-if ! ls /tmp/cfn-test-atomic2-$$.tmp* 2>/dev/null; then
-    pass "atomic_write cleans up temporary files"
-else
-    fail "atomic_write left temporary files"
-fi
-
-# Test: acquire_lock creates lock file
-lock_file="/tmp/cfn-test-lock-$$"
-if acquire_lock "$lock_file" 5 2>/dev/null; then
-    if [ -f "$lock_file" ] && [ "$(cat "$lock_file")" = "$$" ]; then
-        pass "acquire_lock creates lock file with PID"
-        release_lock "$lock_file" 2>/dev/null
-    else
-        fail "acquire_lock file content incorrect"
-        release_lock "$lock_file" 2>/dev/null
-    fi
-else
-    fail "acquire_lock failed"
-fi
-
-# Test: acquire_lock blocks concurrent access
-lock_file2="/tmp/cfn-test-lock2-$$"
-acquire_lock "$lock_file2" 30 2>/dev/null
-if acquire_lock "$lock_file2" 1 2>/dev/null; then
-    fail "acquire_lock should block when lock is held"
-    release_lock "$lock_file2" 2>/dev/null
-else
-    pass "acquire_lock blocks concurrent access"
-    release_lock "$lock_file2" 2>/dev/null
-fi
-
-# Test: release_lock removes lock file
-lock_file3="/tmp/cfn-test-lock3-$$"
-acquire_lock "$lock_file3" 5 2>/dev/null
-if release_lock "$lock_file3" 2>/dev/null; then
-    if [ ! -f "$lock_file3" ]; then
-        pass "release_lock removes lock file"
-    else
-        fail "release_lock did not remove lock file"
-    fi
-else
-    fail "release_lock failed"
-fi
-
-# Test: with_lock executes command with lock
-lock_file4="/tmp/cfn-test-lock4-$$"
-output_file="/tmp/cfn-test-output-$$"
-if with_lock "$lock_file4" 5 bash -c "echo 'locked' > $output_file" 2>/dev/null; then
-    if [ -f "$output_file" ] && [ "$(cat "$output_file")" = "locked" ]; then
-        pass "with_lock executes command successfully"
-    else
-        fail "with_lock command did not execute correctly"
-    fi
-else
-    fail "with_lock failed"
-fi
-
-# Test: with_lock releases lock after execution
-if [ -f "$lock_file4" ]; then
-    fail "with_lock did not release lock after execution"
-else
-    pass "with_lock releases lock after execution"
-fi
-
-# Test: is_locked detects active locks
-lock_file5="/tmp/cfn-test-lock5-$$"
-acquire_lock "$lock_file5" 5 2>/dev/null
-if is_locked "$lock_file5"; then
-    pass "is_locked detects active lock"
-else
-    fail "is_locked should detect active lock"
-fi
-release_lock "$lock_file5" 2>/dev/null
-
-# Test: is_locked returns false when no lock
-lock_file6="/tmp/cfn-test-lock6-$$"
-if is_locked "$lock_file6"; then
-    fail "is_locked should return false when no lock exists"
-else
-    pass "is_locked returns false when no lock exists"
-fi
-
-# ===== SUMMARY =====
-echo ""
-echo "==================================="
-echo "Tests run: $TESTS_RUN"
-echo "Passed: $TESTS_PASSED"
-echo "Failed: $TESTS_FAILED"
-echo "==================================="
-
-if [ $TESTS_FAILED -eq 0 ]; then
-    echo "All tests passed!"
-    exit 0
-else
-    echo "Some tests failed!"
-    exit 1
-fi

package/claude-assets/skills/cfn-validation-framework/SKILL.md

@@ -1,60 +0,0 @@
----
-name: cfn-validation-framework
-description: Multi-layer validation for CFN Loop - templates, defense-in-depth, deliverables, instrumentation
-version: 1.0.0
-tags: [mega-skill, validation, quality, testing]
-status: production
----
-
-# Validation Framework Skill (Mega-Skill)
-
-**Version:** 1.0.0
-**Purpose:** Multi-layer validation for CFN Loop
-**Status:** Production
-**Consolidates:** cfn-validation-templates, cfn-defense-in-depth, cfn-deliverable-validation, cfn-validation-runner-instrumentation, json-validation
-
----
-
-## Overview
-
-This mega-skill provides complete validation capabilities:
-- **Templates** - Task-type specific validation templates
-- **Layers** - Defense-in-depth multi-layer validation
-- **Deliverables** - File and content validation
-- **Instrumentation** - Validation runner metrics
-- **JSON** - Schema validation and sanitization
-
----
-
-## Directory Structure
-
-```
-validation-framework/
-├── SKILL.md
-├── lib/
-│   ├── templates/        # From cfn-validation-templates
-│   ├── layers/           # From cfn-defense-in-depth
-│   ├── deliverables/     # From cfn-deliverable-validation
-│   ├── instrumentation/  # From cfn-validation-runner-instrumentation
-│   └── json/             # From json-validation
-└── cli/
-```
-
----
-
-## Migration Paths
-
-| Old Path | New Path |
-|----------|----------|
-| cfn-validation-templates/ | validation-framework/lib/templates/ |
-| cfn-defense-in-depth/ | validation-framework/lib/layers/ |
-| cfn-deliverable-validation/ | validation-framework/lib/deliverables/ |
-| cfn-validation-runner-instrumentation/ | validation-framework/lib/instrumentation/ |
-| json-validation/ | validation-framework/lib/json/ |
-
----
-
-## Version History
-
-### 1.0.0 (2025-12-02)
-- Consolidated 5 validation skills into mega-skill

package/claude-assets/skills/cfn-validation-framework/lib/deliverables/confidence-calculator.sh

@@ -1,262 +0,0 @@
-#!/bin/bash
-# Deliverable-Based Confidence Calculator
-# Calculates confidence scores based on actual deliverable completion
-
-set -euo pipefail
-
-# Arguments
-TASK_ID="$1"
-AGENT_ID="$2"
-EXPECTED_DELIVERABLES="$3"  # JSON array of expected files/deliverables
-WORKING_DIR="${4:-$(pwd)}"
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-echo -e "${BLUE}📊 Deliverable-Based Confidence Calculator${NC}"
-echo "Task ID: $TASK_ID"
-echo "Agent ID: $AGENT_ID"
-echo "Working Directory: $WORKING_DIR"
-echo ""
-
-# Function to check if deliverable exists and is valid
-validate_deliverable() {
-    local deliverable="$1"
-    local deliverable_path="$WORKING_DIR/$deliverable"
-
-    # Handle different deliverable types
-    case "$deliverable" in
-        *.md|*.txt|*.json|*.yaml|*.yml)
-            # Text files - check existence and content
-            if [ -f "$deliverable_path" ]; then
-                local size=$(stat -c%s "$deliverable_path" 2>/dev/null || echo "0")
-                if [ "$size" -gt 0 ]; then
-                    echo "VALID:$size"
-                    return 0
-                fi
-            fi
-            ;;
-        *.sh|*.js|*.ts|*.tsx|*.py)
-            # Code files - check existence and basic syntax
-            if [ -f "$deliverable_path" ]; then
-                local size=$(stat -c%s "$deliverable_path" 2>/dev/null || echo "0")
-                if [ "$size" -gt 100 ]; then
-                    echo "VALID:$size"
-                    return 0
-                fi
-            fi
-            ;;
-        */)
-            # Directories - check existence and contents
-            if [ -d "$deliverable_path" ]; then
-                local file_count=$(find "$deliverable_path" -type f | wc -l)
-                if [ "$file_count" -gt 0 ]; then
-                    echo "VALID:$file_count"
-                    return 0
-                fi
-            fi
-            ;;
-        *.json)
-            # JSON files - check validity
-            if [ -f "$deliverable_path" ]; then
-                if jq empty "$deliverable_path" 2>/dev/null; then
-                    local size=$(stat -c%s "$deliverable_path" 2>/dev/null || echo "0")
-                    echo "VALID:$size"
-                    return 0
-                fi
-            fi
-            ;;
-        *)
-            # Generic file check
-            if [ -f "$deliverable_path" ]; then
-                local size=$(stat -c%s "$deliverable_path" 2>/dev/null || echo "0")
-                if [ "$size" -gt 0 ]; then
-                    echo "VALID:$size"
-                    return 0
-                fi
-            fi
-            ;;
-    esac
-
-    echo "INVALID"
-    return 1
-}
-
-# Function to calculate quality score based on deliverable characteristics
-calculate_quality_score() {
-    local deliverable="$1"
-    local deliverable_path="$WORKING_DIR/$deliverable"
-
-    local quality_score=0.5  # Base score for existing
-
-    # Size scoring (larger files with meaningful content)
-    if [ -f "$deliverable_path" ]; then
-        local size=$(stat -c%s "$deliverable_path" 2>/dev/null || echo "0")
-
-        if [ "$size" -gt 5000 ]; then
-            quality_score=0.9  # Substantial content
-        elif [ "$size" -gt 1000 ]; then
-            quality_score=0.8  # Good content
-        elif [ "$size" -gt 100 ]; then
-            quality_score=0.7  # Adequate content
-        else
-            quality_score=0.6  # Minimal content
-        fi
-    fi
-
-    # Content-specific scoring
-    case "$deliverable" in
-        *.md)
-            # Markdown files - check for structure
-            if grep -q "^#" "$deliverable_path" 2>/dev/null; then
-                quality_score=$((quality_score + 10))  # Has headers
-            fi
-            if grep -q "^```" "$deliverable_path" 2>/dev/null; then
-                quality_score=$((quality_score + 5))   # Has code blocks
-            fi
-            ;;
-        *.ts|*.tsx|*.js|*.jsx)
-            # Code files - check for functions/exports
-            if grep -q "function\|export\|class\|const.*=" "$deliverable_path" 2>/dev/null; then
-                quality_score=$((quality_score + 10))  # Has functions/exports
-            fi
-            ;;
-        *.json)
-            # JSON files - check for structure
-            if jq -e 'type == "object" and keys > 0' "$deliverable_path" >/dev/null 2>&1; then
-                quality_score=$((quality_score + 10))  # Has meaningful structure
-            fi
-            ;;
-    esac
-
-    # Cap at 1.0
-    if [ "$quality_score" -gt 100 ]; then
-        quality_score=100
-    fi
-
-    echo "$quality_score"
-}
-
-# Main confidence calculation
-main() {
-    echo -e "${YELLOW}Analyzing expected deliverables...${NC}"
-
-    # Parse expected deliverables from JSON
-    if ! echo "$EXPECTED_DELIVERABLES" | jq empty 2>/dev/null; then
-        echo -e "${RED}❌ Invalid JSON in expected deliverables${NC}"
-        echo "0.0"
-        return 1
-    fi
-
-    local total_deliverables=$(echo "$EXPECTED_DELIVERABLES" | jq 'length')
-    local valid_deliverables=0
-    local total_quality_score=0
-
-    echo "Expected deliverables: $total_deliverables"
-    echo ""
-
-    # Check each deliverable
-    for ((i=0; i<total_deliverables; i++)); do
-        local deliverable=$(echo "$EXPECTED_DELIVERABLES" | jq -r ".[$i]")
-
-        echo -n "  Checking: $deliverable ... "
-
-        local validation_result=$(validate_deliverable "$deliverable")
-
-        if [[ "$validation_result" == VALID* ]]; then
-            local quality_score=$(calculate_quality_score "$deliverable")
-            total_quality_score=$((total_quality_score + quality_score))
-            valid_deliverables=$((valid_deliverables + 1))
-
-            local size=$(echo "$validation_result" | cut -d: -f2)
-            echo -e "${GREEN}✓ VALID${NC} (size: $size, quality: $quality_score)"
-        else
-            echo -e "${RED}✗ MISSING/INVALID${NC}"
-        fi
-    done
-
-    echo ""
-    echo -e "${YELLOW}Summary:${NC}"
-    echo "  Valid deliverables: $valid_deliverables/$total_deliverables"
-
-    # Calculate completion score (0-1)
-    local completion_score=0
-    if [ "$total_deliverables" -gt 0 ]; then
-        completion_score=$(echo "scale=3; $valid_deliverables / $total_deliverables" | bc -l)
-    fi
-
-    # Calculate average quality score (0-1)
-    local avg_quality_score=0.5  # Default if no deliverables
-    if [ "$valid_deliverables" -gt 0 ]; then
-        avg_quality_score=$(echo "scale=3; $total_quality_score / ($valid_deliverables * 100)" | bc -l)
-    fi
-
-    # Calculate final confidence score
-    # Weight: 60% completion, 40% quality
-    local final_confidence=$(echo "scale=3; ($completion_score * 0.6) + ($avg_quality_score * 0.4)" | bc -l)
-
-    # Round to 2 decimal places
-    final_confidence=$(echo "$final_confidence" | sed 's/^\./0./' | sed 's/\.\([0-9]\{2\}\)[0-9]*$/.\1/')
-
-    echo "  Completion score: $completion_score"
-    echo "  Quality score: $avg_quality_score"
-    echo "  Final confidence: $final_confidence"
-
-    # Validation rules
-    if [ "$valid_deliverables" -eq 0 ]; then
-        echo -e "${RED}🚨 CRITICAL: No deliverables created - confidence should be 0.0${NC}"
-        echo "0.0"
-        return 1
-    elif (( $(echo "$final_confidence > 0.3" | bc -l) )); then
-        if [ "$valid_deliverables" -lt "$((total_deliverables / 2))" ]; then
-            echo -e "${YELLOW}⚠️  WARNING: Low deliverable completion (<50%) - confidence should be <= 0.3${NC}"
-        fi
-    fi
-
-    echo -e "${GREEN}✓ Calculated confidence: $final_confidence${NC}"
-    echo "$final_confidence"
-}
-
-# Store results in Redis if available
-store_confidence_result() {
-    local confidence="$1"
-
-    if command -v redis-cli >/dev/null 2>&1; then
-        # Store detailed breakdown
-        local breakdown=$(cat << EOF
-{
-  "task_id": "$TASK_ID",
-  "agent_id": "$AGENT_ID",
-  "calculated_confidence": $confidence,
-  "calculation_method": "deliverable-based",
-  "timestamp": "$(date -Iseconds)",
-  "working_directory": "$WORKING_DIR",
-  "expected_deliverables": $EXPECTED_DELIVERABLES
-}
-EOF
-        )
-
-        redis-cli set "${TASK_ID}:${AGENT_ID}:confidence-breakdown" "$breakdown" >/dev/null 2>&1 || true
-        redis-cli set "${TASK_ID}:${AGENT_ID}:confidence-score" "$confidence" >/dev/null 2>&1 || true
-
-        echo -e "📦 ${BLUE}Stored confidence breakdown in Redis:${NC} ${TASK_ID}:${AGENT_ID}:confidence-breakdown"
-    fi
-}
-
-# Execute main function
-if [ "$#" -lt 3 ]; then
-    echo "Usage: $0 <task_id> <agent_id> <expected_deliverables_json> [working_directory]"
-    echo "Example: $0 task-123 agent-1 '[\"file1.txt\", \"script.sh\", \"docs/\"]' /path/to/project"
-    exit 1
-fi
-
-final_confidence=$(main "$@")
-
-# Store results
-store_confidence_result "$final_confidence"
-
-echo "$final_confidence"