claude-flow-novice 2.6.0 → 2.9.0

package/.claude/skills/cfn-loop-validation/validate-iteration.sh

@@ -1,134 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# CFN Loop Validation CLI Wrapper v2.1.0
-# Agent-friendly interface for validating CFN loop iterations with claim support
-#
-# Usage:
-#   ./validate-iteration.sh --mode <mvp|standard|enterprise> \
-#                          --iteration <n> \
-#                          --confidence <score> \
-#                          [--consensus <score>] \
-#                          [--task-id <id>] \
-#                          [--agent-id <id>] \
-#                          [--claims <json_array>] \
-#                          [--json]
-#
-# Returns: JSON validation result with pass/fail status, claim validation details
-##############################################################################
-
-set -euo pipefail
-
-# ... [Previous existing code remains the same] ...
-
-# New function to validate claims
-validate_claims() {
-    local claims_json="$1"
-    local result_json
-
-    # Validate claims JSON
-    if ! echo "$claims_json" | jq empty &>/dev/null; then
-        echo "Error: Invalid JSON for claims" >&2
-        exit 3
-    fi
-
-    # Compute claim validation metrics
-    local claims_count
-    local valid_claims_count
-    local invalid_claims_count
-    local claims_confidence
-
-    claims_count=$(echo "$claims_json" | jq 'length')
-    valid_claims_count=$(echo "$claims_json" | jq '[.[] | select(.confidence >= 0.8)] | length')
-    invalid_claims_count=$((claims_count - valid_claims_count))
-    claims_confidence=$(echo "scale=4; $valid_claims_count / $claims_count" | bc)
-
-    # Detailed claim validation
-    local claim_details
-    claim_details=$(echo "$claims_json" | jq '
-        map({
-            id: .id,
-            description: .description,
-            confidence: .confidence,
-            valid: (.confidence >= 0.8),
-            strategy: .strategy // null
-        })
-    ')
-
-    result_json=$(jq -n \
-        --argjson claims_count "$claims_count" \
-        --argjson valid_claims_count "$valid_claims_count" \
-        --argjson invalid_claims_count "$invalid_claims_count" \
-        --argjson claims_confidence "$claims_confidence" \
-        --argjson claim_details "$claim_details" \
-        '{
-            claims: {
-                total_count: $claims_count,
-                valid_count: $valid_claims_count,
-                invalid_count: $invalid_claims_count,
-                confidence: $claims_confidence,
-                details: $claim_details
-            }
-        }')
-
-    echo "$result_json"
-}
-
-# Update parse_args to support claims
-parse_args() {
-    # ... [Previous parse_args logic remains the same] ...
-    local CLAIMS=""
-    while [[ $# -gt 0 ]]; do
-        case "$1" in
-            # ... [Previous cases remain the same] ...
-            --claims)
-                CLAIMS="$2"
-                shift 2
-                ;;
-            *)
-                # ... [Previous unknown argument handling remains the same] ...
-        esac
-    done
-
-    # Optional: add claims validation if provided
-    if [[ -n "$CLAIMS" ]]; then
-        CLAIM_VALIDATION=$(validate_claims "$CLAIMS")
-        log_verbose "Claim Validation: $CLAIM_VALIDATION"
-    fi
-}
-
-# Update validate_iteration to incorporate claims
-validate_iteration() {
-    local result_json
-    local base_result
-    local claim_result
-
-    # [Existing base validation logic remains the same]
-    base_result=$(... existing validation result ...)
-
-    # Merge base result with claim validation if available
-    if [[ -n "$CLAIM_VALIDATION" ]]; then
-        result_json=$(echo "$base_result" | jq --argjson claim_validation "$CLAIM_VALIDATION" '. + $claim_validation')
-    else
-        result_json="$base_result"
-    fi
-
-    # Output result as before
-    if [[ "$JSON_OUTPUT" == true ]]; then
-        echo "$result_json"
-    else
-        echo "$result_json" | jq .
-    fi
-}
-
-# ... [Rest of the script remains the same] ...
-
-main() {
-    # Main execution remains the same, with support for claims
-    parse_args "$@"
-
-    # Existing main logic ...
-    # Claims validation integrated into standard flow
-}
-
-main "$@"

package/.claude/skills/cfn-loop-validation.sh

@@ -1,70 +0,0 @@
-#!/usr/bin/env bash
-
-# CFN Loop Validation Script
-# Handles intelligent auto-retry with progressive complexity
-
-CFN_VALIDATION_MODE="${1:-standard}"
-MAX_ITERATIONS=10
-CURRENT_ITERATION=0
-CONSENSUS_THRESHOLD=0.90
-GATE_THRESHOLD=0.75
-
-# Validation Function
-validate_loop() {
-    local task_id="$1"
-    local mode="$2"
-
-    # Invoke consensus calculator
-    local validation_result=$(node consensus-calculator.js \
-        --task-id "$task_id" \
-        --mode "$mode")
-
-    # Parse validation metrics
-    local confidence=$(echo "$validation_result" | jq '.confidence')
-    local consensus=$(echo "$validation_result" | jq '.consensus')
-    local gate_score=$(echo "$validation_result" | jq '.gate_score')
-
-    # Validation decision tree
-    if (( $(echo "$confidence >= $CONSENSUS_THRESHOLD" | bc -l) )) &&
-       (( $(echo "$gate_score >= $GATE_THRESHOLD" | bc -l) )); then
-        return 0  # Success
-    else
-        return 1  # Retry needed
-    }
-}
-
-# Main Validation Loop
-while [[ $CURRENT_ITERATION -lt $MAX_ITERATIONS ]]; do
-    if validate_loop "$TASK_ID" "$CFN_VALIDATION_MODE"; then
-        # Successful validation
-        redis-cli lpush "swarm:validation:complete" \
-            "$(jq -n \
-                --arg task "$TASK_ID" \
-                --arg mode "$CFN_VALIDATION_MODE" \
-                '{task: $task, mode: $mode, status: "success"}')"
-        exit 0
-    else
-        # Increment iteration, potential escalation
-        CURRENT_ITERATION=$((CURRENT_ITERATION + 1))
-
-        # Optional: Escalation strategy
-        if [[ $CURRENT_ITERATION -ge $((MAX_ITERATIONS * 0.8)) ]]; then
-            redis-cli lpush "swarm:validation:escalation" \
-                "$(jq -n \
-                    --arg task "$TASK_ID" \
-                    --arg mode "$CFN_VALIDATION_MODE" \
-                    '{task: $task, mode: $mode, status: "escalate"}')"
-        fi
-
-        # Exponential backoff
-        sleep $((2 ** CURRENT_ITERATION))
-    fi
-done
-
-# Final failure state
-redis-cli lpush "swarm:validation:failure" \
-    "$(jq -n \
-        --arg task "$TASK_ID" \
-        --arg mode "$CFN_VALIDATION_MODE" \
-        '{task: $task, mode: $mode, status: "failure"}')"
-exit 1

package/.claude/skills/config-management/SKILL.md

@@ -1,34 +0,0 @@
-# Configuration Management Skill
-
-## Overview
-This skill provides a robust, type-safe configuration management system for the Claude Flow Novice project.
-
-## Key Features
-- Type-safe configuration management
-- Schema validation
-- Export/Import configurations
-- Centralized configuration storage
-- Dependency checking
-
-## Interfaces
-- Get configuration values
-- Set configuration values
-- List all configurations
-- Reset to defaults
-- Validate configuration schema
-
-## Usage Guidelines
-- Always validate configuration before setting
-- Use TypeScript for type safety
-- Leverage JSON schema for validation
-- Minimal external dependencies
-
-## Integration
-- Accessible via CLI
-- Supports agent-based configuration updates
-- Redis coordination for distributed config management
-
-## Security Considerations
-- Sanitize input
-- Prevent arbitrary code execution
-- Validate configuration schemas strictly

package/.claude/skills/config-management/check-dependencies.sh

@@ -1,56 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Dependency Checker for Config Management
-
-# Required and optional dependencies
-REQUIRED_DEPENDENCIES=("jq")
-OPTIONAL_DEPENDENCIES=("ajv")
-
-check_dependency() {
-    if ! command -v "$1" &> /dev/null; then
-        echo "Dependency not found: $1"
-        return 1
-    fi
-}
-
-install_optional_dependencies() {
-    local missing_optional=()
-
-    for dep in "${OPTIONAL_DEPENDENCIES[@]}"; do
-        if ! check_dependency "$dep"; then
-            missing_optional+=("$dep")
-        fi
-    done
-
-    if [ ${#missing_optional[@]} -gt 0 ]; then
-        echo "Note: Optional dependencies not found: ${missing_optional[*]}"
-        echo "Some advanced features may be limited."
-        return 0  # Not a hard failure
-    fi
-}
-
-main() {
-    local missing_required=()
-
-    # Check required dependencies
-    for dep in "${REQUIRED_DEPENDENCIES[@]}"; do
-        if ! check_dependency "$dep"; then
-            missing_required+=("$dep")
-        fi
-    done
-
-    if [ ${#missing_required[@]} -gt 0 ]; then
-        echo "ERROR: Missing critical dependencies: ${missing_required[*]}"
-        echo "Please install these dependencies to use the config management skill."
-        exit 1
-    fi
-
-    # Check optional dependencies (non-blocking)
-    install_optional_dependencies
-
-    echo "Dependencies check passed."
-    exit 0
-}
-
-main "$@"

package/.claude/skills/config-management/config.json

@@ -1,32 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-07/schema#",
-    "title": "Claude Flow Novice Configuration",
-    "type": "object",
-    "properties": {
-        "redis": {
-            "type": "object",
-            "properties": {
-                "host": {"type": "string", "default": "localhost"},
-                "port": {"type": "number", "default": 6379},
-                "password": {"type": "string"}
-            },
-            "required": ["host", "port"]
-        },
-        "agent": {
-            "type": "object",
-            "properties": {
-                "default_strategy": {"type": "string", "default": "development"},
-                "max_concurrent_agents": {"type": "number", "default": 5},
-                "log_level": {"type": "string", "enum": ["debug", "info", "warn", "error"], "default": "info"}
-            }
-        },
-        "security": {
-            "type": "object",
-            "properties": {
-                "enabled": {"type": "boolean", "default": true},
-                "max_retry_attempts": {"type": "number", "default": 3}
-            }
-        }
-    },
-    "required": ["redis", "agent"]
-}

package/.claude/skills/config-management/manage-config.sh

@@ -1,113 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Config Management CLI Wrapper with Nested Support
-
-CONFIG_FILE="${HOME}/.claude-flow-config.json"
-SCHEMA_FILE="/mnt/c/Users/masha/Documents/claude-flow-novice/.claude/skills/config-management/config.json"
-
-# Validate JSON against schema
-validate_config() {
-    if command -v ajv &> /dev/null; then
-        ajv validate -s "$SCHEMA_FILE" -d "$1"
-    else
-        echo "Warning: JSON schema validation skipped. Install 'ajv' for full validation."
-        return 0
-    fi
-}
-
-# Get nested configuration value
-get_config() {
-    local key="$1"
-    jq -r "$key" "$CONFIG_FILE" 2>/dev/null || echo "Key not found: $key"
-}
-
-# Set nested configuration value with advanced handling
-set_config() {
-    local key="$1"
-    local value="$2"
-
-    # Temp file for atomic write
-    temp_file=$(mktemp)
-
-    # Handle nested key updates
-    jq "$key = $value" "$CONFIG_FILE" > "$temp_file"
-
-    # Validate before overwriting
-    if validate_config "$temp_file"; then
-        mv "$temp_file" "$CONFIG_FILE"
-        echo "Configuration updated successfully."
-    else
-        rm "$temp_file"
-        echo "Invalid configuration. Update rejected."
-        exit 1
-    fi
-}
-
-# Merge configurations
-merge_config() {
-    local config_to_merge="$1"
-
-    # Temp file for atomic write
-    temp_file=$(mktemp)
-
-    # Deep merge using jq
-    jq -s '.[0] * .[1]' "$CONFIG_FILE" "$config_to_merge" > "$temp_file"
-
-    # Validate before overwriting
-    if validate_config "$temp_file"; then
-        mv "$temp_file" "$CONFIG_FILE"
-        echo "Configuration merged successfully."
-    else
-        rm "$temp_file"
-        echo "Invalid merged configuration. Update rejected."
-        exit 1
-    fi
-}
-
-# List all configurations
-list_config() {
-    cat "$CONFIG_FILE"
-}
-
-# Reset to defaults
-reset_config() {
-    cp "$SCHEMA_FILE" "$CONFIG_FILE"
-    echo "Configuration reset to defaults."
-}
-
-# Create config file if it doesn't exist
-ensure_config_file() {
-    if [ ! -f "$CONFIG_FILE" ]; then
-        reset_config
-    fi
-}
-
-# Main command dispatcher
-main() {
-    ensure_config_file
-
-    case "$1" in
-        get)
-            get_config "$2"
-            ;;
-        set)
-            set_config "$2" "$3"
-            ;;
-        merge)
-            merge_config "$2"
-            ;;
-        list)
-            list_config
-            ;;
-        reset)
-            reset_config
-            ;;
-        *)
-            echo "Usage: $0 {get|set|merge|list|reset} [key] [value]"
-            exit 1
-            ;;
-    esac
-}
-
-main "$@"

package/.claude/skills/consensus-calculator.js

@@ -1,45 +0,0 @@
-const calculateConsensus = (taskMetrics) => {
-    const {
-        validatorScores,
-        confidenceScores,
-        gateways
-    } = taskMetrics;
-
-    const consensusScore = calculateWeightedConsensus(validatorScores);
-    const confidenceScore = calculateConfidenceMetric(confidenceScores);
-    const gateScore = calculateGatewayScore(gateways);
-
-    return {
-        consensus: consensusScore,
-        confidence: confidenceScore,
-        gate_score: gateScore,
-        recommendation: decideNextAction(consensusScore, confidenceScore, gateScore)
-    };
-};
-
-function calculateWeightedConsensus(validatorScores) {
-    // Implement weighted consensus calculation
-    return validatorScores.reduce((a, b) => a + b, 0) / validatorScores.length;
-}
-
-function calculateConfidenceMetric(confidenceScores) {
-    // Implement confidence metric calculation
-    return Math.min(confidenceScores.reduce((a, b) => a * b, 1), 1);
-}
-
-function calculateGatewayScore(gateways) {
-    // Implement gateway score calculation
-    return gateways.reduce((a, b) => a * b, 1);
-}
-
-function decideNextAction(consensusScore, confidenceScore, gateScore) {
-    if (consensusScore >= 0.90 && gateScore >= 0.75) {
-        return 'success';
-    } else if (consensusScore >= 0.75) {
-        return 'retry_with_specialists';
-    } else {
-        return 'manual_review';
-    }
-}
-
-module.exports = { calculateConsensus };