claude-flow-novice 2.8.1 → 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/complexity-estimator/SKILL.md

@@ -1,96 +0,0 @@
-# Task Complexity Estimator
-
-**Version:** 1.0.0
-**Purpose:** Estimate task complexity and predict iteration requirements for CFN v3
-
-## Overview
-
-Analyzes task description to estimate:
-- Complexity level (low, medium, high)
-- Estimated iterations (2-7 range)
-- Confidence in estimate
-
-## Complexity Factors
-
-### Factor 1: Step Count
-- Count distinct action verbs
-- Count deliverable files mentioned
-- Count integration points
-
-### Factor 2: Security/Compliance
-- Security keywords → +1 complexity
-- Compliance requirements → +1 complexity
-- Authentication/authorization → +1 complexity
-
-### Factor 3: Scope
-- Single file → low
-- Multiple files (2-5) → medium
-- System-wide (>5 files) → high
-
-### Factor 4: Dependencies
-- External APIs → +1 complexity
-- Database changes → +1 complexity
-- Multiple services → +1 complexity
-
-### Factor 5: Technology Stack
-- Familiar tech → -1 complexity
-- New/unfamiliar tech → +1 complexity
-- Cutting-edge/experimental → +2 complexity
-
-## Estimation Formula
-
-```
-Base Iterations = 2
-
-+ Step Count / 3
-+ Security factor (0-2)
-+ Scope factor (0-3)
-+ Dependencies factor (0-3)
-+ Tech stack factor (-1 to +2)
-
-Capped at: 7 iterations (high complexity max)
-```
-
-## Complexity Mapping
-
-| Total Score | Complexity | Estimated Iterations |
-|-------------|------------|---------------------|
-| 0-2 | Low | 2 |
-| 3-4 | Medium | 3-4 |
-| 5+ | High | 5-7 |
-
-## Usage
-
-```bash
-ESTIMATE=$(./.claude/skills/complexity-estimator/estimate-complexity.sh \
-  --task-type "software-development" \
-  --description "Implement JWT authentication with refresh tokens and RBAC")
-
-echo "$ESTIMATE" | jq '.complexity'           # "high"
-echo "$ESTIMATE" | jq '.estimated_iterations' # 5
-echo "$ESTIMATE" | jq '.confidence'           # 0.75
-```
-
-## Output Format
-
-```json
-{
-  "complexity": "low|medium|high",
-  "estimated_iterations": 2-7,
-  "confidence": 0.0-1.0,
-  "factors": {
-    "step_count": 2,
-    "security": 1,
-    "scope": 2,
-    "dependencies": 1,
-    "tech_stack": 0
-  },
-  "reasoning": "High complexity due to security requirements (JWT, RBAC), multiple integration points, and estimated 6+ file changes."
-}
-```
-
-## Integration
-
-Used by:
-- `.claude/agents/cfn-v3-coordinator.md` - Set max_iterations, estimated_iterations
-- Playbook system - Store complexity patterns

package/.claude/skills/complexity-estimator/estimate-complexity.sh

@@ -1,144 +0,0 @@
-#!/bin/bash
-
-# Task Complexity Estimator for CFN v3
-# Removed set -o pipefail for compatibility
-
-TASK_TYPE=""
-DESCRIPTION=""
-
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --task-type) TASK_TYPE="$2"; shift 2 ;;
-    --description) DESCRIPTION="$2"; shift 2 ;;
-    *) echo "Unknown: $1"; exit 1 ;;
-  esac
-done
-
-if [ -z "$DESCRIPTION" ]; then
-  echo "Usage: estimate-complexity.sh --task-type TYPE --description 'text'" >&2
-  exit 1
-fi
-
-DESC_LOWER=$(echo "$DESCRIPTION" | tr '[:upper:]' '[:lower:]')
-
-# Helper function to check keyword
-has_keyword() {
-  local keyword="$1"
-  echo "$DESC_LOWER" | grep -qi "$keyword"
-  return $?
-}
-
-# Factor 1: Step Count
-# Count action verbs
-ACTION_VERBS="implement build create add update modify refactor deploy configure setup integrate test"
-STEP_COUNT=0
-for verb in $ACTION_VERBS; do
-  if has_keyword "$verb"; then
-    ((STEP_COUNT++)) || true
-  fi
-done
-
-STEP_SCORE=$((STEP_COUNT / 3))
-
-# Factor 2: Security/Compliance
-SECURITY_SCORE=0
-if has_keyword "security\|authentication\|authorization\|jwt\|oauth\|rbac"; then
-  ((SECURITY_SCORE++))
-fi
-if has_keyword "compliance\|gdpr\|hipaa\|pci\|sox"; then
-  ((SECURITY_SCORE++))
-fi
-if has_keyword "encryption\|ssl\|tls\|certificate"; then
-  ((SECURITY_SCORE++))
-fi
-
-# Factor 3: Scope
-SCOPE_SCORE=0
-if has_keyword "file\|files"; then
-  FILE_COUNT=$(echo "$DESC_LOWER" | grep -o "file" | wc -l)
-  if [ "$FILE_COUNT" -gt 5 ]; then
-    SCOPE_SCORE=3
-  elif [ "$FILE_COUNT" -ge 2 ]; then
-    SCOPE_SCORE=2
-  else
-    SCOPE_SCORE=1
-  fi
-fi
-if has_keyword "system-wide\|entire system\|all"; then
-  SCOPE_SCORE=3
-fi
-
-# Factor 4: Dependencies
-DEPENDENCY_SCORE=0
-if has_keyword "api\|external service\|third-party"; then
-  ((DEPENDENCY_SCORE++))
-fi
-if has_keyword "database\|sql\|schema\|migration"; then
-  ((DEPENDENCY_SCORE++))
-fi
-if has_keyword "microservice\|services\|distributed"; then
-  ((DEPENDENCY_SCORE++))
-fi
-
-# Factor 5: Tech Stack
-TECH_SCORE=0
-if has_keyword "new technology\|learning\|unfamiliar"; then
-  ((TECH_SCORE++))
-fi
-if has_keyword "experimental\|cutting-edge\|beta"; then
-  TECH_SCORE=2
-fi
-if has_keyword "legacy\|migration\|refactor"; then
-  ((TECH_SCORE++))
-fi
-
-# Calculate total score
-TOTAL_SCORE=$((STEP_SCORE + SECURITY_SCORE + SCOPE_SCORE + DEPENDENCY_SCORE + TECH_SCORE))
-
-# Determine complexity and iterations
-if [ "$TOTAL_SCORE" -le 2 ]; then
-  COMPLEXITY="low"
-  ESTIMATED_ITERATIONS=2
-  CONFIDENCE=0.80
-elif [ "$TOTAL_SCORE" -le 4 ]; then
-  COMPLEXITY="medium"
-  ESTIMATED_ITERATIONS=$((TOTAL_SCORE))
-  CONFIDENCE=0.75
-else
-  COMPLEXITY="high"
-  ESTIMATED_ITERATIONS=$((TOTAL_SCORE))
-  if [ "$ESTIMATED_ITERATIONS" -gt 7 ]; then
-    ESTIMATED_ITERATIONS=7
-  fi
-  CONFIDENCE=0.70
-fi
-
-# Build reasoning
-REASONING="Complexity: $COMPLEXITY"
-if [ "$SECURITY_SCORE" -gt 0 ]; then
-  REASONING="$REASONING. Security requirements detected ($SECURITY_SCORE factors)."
-fi
-if [ "$SCOPE_SCORE" -ge 2 ]; then
-  REASONING="$REASONING. Multi-file or system-wide scope."
-fi
-if [ "$DEPENDENCY_SCORE" -gt 0 ]; then
-  REASONING="$REASONING. External dependencies ($DEPENDENCY_SCORE)."
-fi
-
-# Build JSON output
-cat <<EOF
-{
-  "complexity": "$COMPLEXITY",
-  "estimated_iterations": $ESTIMATED_ITERATIONS,
-  "confidence": $CONFIDENCE,
-  "factors": {
-    "step_count": $STEP_COUNT,
-    "security": $SECURITY_SCORE,
-    "scope": $SCOPE_SCORE,
-    "dependencies": $DEPENDENCY_SCORE,
-    "tech_stack": $TECH_SCORE,
-    "total": $TOTAL_SCORE
-  },
-  "reasoning": "$REASONING"
-}
-EOF

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 "$@"