claude-flow-novice 2.15.11 → 2.16.0

package/.claude/skills/cfn-docker-redis-coordination/tsconfig.json

@@ -1,30 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es2020",
-    "module": "commonjs",
-    "lib": ["es2020"],
-    "declaration": true,
-    "declarationMap": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "allowSyntheticDefaultImports": true,
-    "moduleResolution": "node",
-    "isolatedModules": true,
-    "noImplicitAny": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "baseUrl": ".",
-    "paths": {
-      "@/*": ["src/*"]
-    }
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "tests"]
-}

package/.claude/skills/cfn-loop-orchestration/helpers/auto-tune-timeouts.sh

@@ -1,228 +0,0 @@
-#!/bin/bash
-#
-# Auto-Tune Timeouts Helper
-#
-# Dynamically calculates optimal timeouts for CFN Loop agents based on:
-# - Historical performance data
-# - Agent type (implementer vs validator)
-# - Task complexity
-# - Current system load
-#
-# Usage:
-#   auto-tune-timeouts.sh --agent-type <type> --task-complexity <low|medium|high> [--history-file <file>]
-#
-# Returns: Recommended timeout in seconds
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-# Default configuration
-DEFAULT_TIMEOUT=300
-MIN_TIMEOUT=60
-MAX_TIMEOUT=1800
-HISTORY_FILE="/tmp/cfn-agent-performance-history.json"
-
-# Baseline timeouts by agent type (seconds)
-declare -A BASELINE_TIMEOUTS=(
-  ["implementer"]=300
-  ["validator"]=180
-  ["coordinator"]=600
-  ["product-owner"]=120
-)
-
-# Complexity multipliers
-declare -A COMPLEXITY_MULTIPLIERS=(
-  ["low"]=0.7
-  ["medium"]=1.0
-  ["high"]=1.5
-)
-
-# Parse arguments
-AGENT_TYPE=""
-TASK_COMPLEXITY="medium"
-CUSTOM_HISTORY_FILE=""
-
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --agent-type)
-      AGENT_TYPE="$2"
-      shift 2
-      ;;
-    --task-complexity)
-      TASK_COMPLEXITY="$2"
-      shift 2
-      ;;
-    --history-file)
-      CUSTOM_HISTORY_FILE="$2"
-      shift 2
-      ;;
-    --help)
-      echo "Usage: auto-tune-timeouts.sh --agent-type <type> --task-complexity <low|medium|high> [--history-file <file>]"
-      echo ""
-      echo "Agent Types: implementer, validator, coordinator, product-owner"
-      echo "Task Complexity: low, medium, high"
-      echo ""
-      echo "Returns: Recommended timeout in seconds"
-      exit 0
-      ;;
-    *)
-      echo "Unknown argument: $1"
-      exit 1
-      ;;
-  esac
-done
-
-# Validation
-if [ -z "$AGENT_TYPE" ]; then
-  echo "Error: --agent-type is required"
-  exit 1
-fi
-
-if [[ ! "${BASELINE_TIMEOUTS[$AGENT_TYPE]+isset}" ]]; then
-  echo "Error: Unknown agent type '$AGENT_TYPE'"
-  echo "Valid types: ${!BASELINE_TIMEOUTS[@]}"
-  exit 1
-fi
-
-if [[ ! "${COMPLEXITY_MULTIPLIERS[$TASK_COMPLEXITY]+isset}" ]]; then
-  echo "Error: Unknown task complexity '$TASK_COMPLEXITY'"
-  echo "Valid complexities: ${!COMPLEXITY_MULTIPLIERS[@]}"
-  exit 1
-fi
-
-# Use custom history file if provided
-if [ -n "$CUSTOM_HISTORY_FILE" ]; then
-  HISTORY_FILE="$CUSTOM_HISTORY_FILE"
-fi
-
-# Function to get historical average execution time
-get_historical_avg() {
-  local agent_type=$1
-
-  if [ ! -f "$HISTORY_FILE" ]; then
-    echo "$DEFAULT_TIMEOUT"
-    return
-  fi
-
-  # Extract average execution time for this agent type
-  local avg_time=$(jq -r --arg type "$agent_type" \
-    '.history[]
-    | select(.agentType == $type)
-    | .executionTime
-    | select(. != null)' "$HISTORY_FILE" 2>/dev/null | \
-    awk '{ sum += $1; count++ } END { if (count > 0) print sum/count; else print 0 }')
-
-  if [ -z "$avg_time" ] || [ "$avg_time" = "0" ]; then
-    echo "$DEFAULT_TIMEOUT"
-  else
-    echo "$avg_time"
-  fi
-}
-
-# Function to get system load factor
-get_load_factor() {
-  # Check if on Linux
-  if [ -f /proc/loadavg ]; then
-    local load_1min=$(cat /proc/loadavg | awk '{print $1}')
-    local cpu_count=$(nproc 2>/dev/null || echo 1)
-
-    # Calculate load factor (load per CPU)
-    local load_factor=$(echo "scale=2; $load_1min / $cpu_count" | bc)
-
-    # Return multiplier (1.0 baseline, increase if high load)
-    if (( $(echo "$load_factor > 2.0" | bc -l) )); then
-      echo "1.5"  # High load, increase timeout by 50%
-    elif (( $(echo "$load_factor > 1.0" | bc -l) )); then
-      echo "1.2"  # Moderate load, increase timeout by 20%
-    else
-      echo "1.0"  # Normal load
-    fi
-  else
-    # Non-Linux or can't determine load
-    echo "1.0"
-  fi
-}
-
-# Function to get Redis latency factor
-get_redis_latency_factor() {
-  # Measure Redis ping latency
-  local start_ns=$(date +%s%N)
-  redis-cli PING >/dev/null 2>&1 || return
-  local end_ns=$(date +%s%N)
-
-  local latency_ns=$((end_ns - start_ns))
-  local latency_ms=$(echo "scale=2; $latency_ns / 1000000" | bc)
-
-  # If Redis is slow, increase timeout
-  if (( $(echo "$latency_ms > 100" | bc -l) )); then
-    echo "1.3"  # Very slow Redis, increase timeout by 30%
-  elif (( $(echo "$latency_ms > 50" | bc -l) )); then
-    echo "1.1"  # Slow Redis, increase timeout by 10%
-  else
-    echo "1.0"  # Normal Redis performance
-  fi
-}
-
-# Calculate base timeout
-baseline_timeout=${BASELINE_TIMEOUTS[$AGENT_TYPE]}
-
-# Get historical average
-historical_avg=$(get_historical_avg "$AGENT_TYPE")
-
-# If we have historical data, use weighted average
-if [ "$historical_avg" != "$DEFAULT_TIMEOUT" ]; then
-  # 70% historical, 30% baseline
-  base_timeout=$(echo "scale=0; ($historical_avg * 0.7) + ($baseline_timeout * 0.3)" | bc)
-else
-  base_timeout=$baseline_timeout
-fi
-
-# Apply complexity multiplier
-complexity_multiplier=${COMPLEXITY_MULTIPLIERS[$TASK_COMPLEXITY]}
-timeout_after_complexity=$(echo "scale=0; $base_timeout * $complexity_multiplier" | bc)
-
-# Apply system load factor
-load_factor=$(get_load_factor)
-timeout_after_load=$(echo "scale=0; $timeout_after_complexity * $load_factor" | bc)
-
-# Apply Redis latency factor
-redis_factor=$(get_redis_latency_factor)
-final_timeout=$(echo "scale=0; $timeout_after_load * $redis_factor" | bc)
-
-# Ensure timeout is within bounds
-if (( $(echo "$final_timeout < $MIN_TIMEOUT" | bc -l) )); then
-  final_timeout=$MIN_TIMEOUT
-fi
-
-if (( $(echo "$final_timeout > $MAX_TIMEOUT" | bc -l) )); then
-  final_timeout=$MAX_TIMEOUT
-fi
-
-# Round to integer
-final_timeout=$(printf "%.0f" "$final_timeout")
-
-# Output result (JSON format for easy parsing)
-cat <<EOF
-{
-  "agentType": "$AGENT_TYPE",
-  "taskComplexity": "$TASK_COMPLEXITY",
-  "recommendedTimeout": $final_timeout,
-  "calculation": {
-    "baselineTimeout": $baseline_timeout,
-    "historicalAverage": $historical_avg,
-    "complexityMultiplier": $complexity_multiplier,
-    "loadFactor": $load_factor,
-    "redisLatencyFactor": $redis_factor
-  },
-  "bounds": {
-    "min": $MIN_TIMEOUT,
-    "max": $MAX_TIMEOUT
-  }
-}
-EOF
-
-# Also output just the timeout value to stderr for easy shell capture
-echo "$final_timeout" >&2
-
-exit 0

package/.claude/skills/cfn-loop-orchestration/helpers/consensus-ts.sh

@@ -1,104 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# Consensus Checker (TypeScript Wrapper)
-# Collects and validates Loop 2 consensus scores
-#
-# Usage:
-#   consensus-ts.sh --scores <score1,score2,...> \
-#                   --threshold <0.0-1.0> \
-#                   --mode <mvp|standard|enterprise>
-#
-# Returns:
-#   Exit 0: Consensus reached
-#   Exit 1: Consensus failed
-##############################################################################
-
-set -euo pipefail
-
-# Get script directory
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-HELPERS_DIR="$SCRIPT_DIR/../src/helpers"
-
-# Parameters
-SCORES=""
-THRESHOLD=""
-MODE="standard"
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --scores) SCORES="$2"; shift 2 ;;
-    --threshold) THRESHOLD="$2"; shift 2 ;;
-    --mode) MODE="$2"; shift 2 ;;
-    *) echo "Unknown option: $1" >&2; exit 1 ;;
-  esac
-done
-
-# Validation
-if [ -z "$SCORES" ]; then
-  echo "Error: Missing required parameter --scores" >&2
-  exit 1
-fi
-
-# Convert comma-separated scores to JSON array
-IFS=',' read -ra SCORE_ARRAY <<< "$SCORES"
-SCORES_JSON="["
-for i in "${!SCORE_ARRAY[@]}"; do
-  if [ $i -gt 0 ]; then
-    SCORES_JSON+=","
-  fi
-  SCORES_JSON+="${SCORE_ARRAY[$i]}"
-done
-SCORES_JSON+="]"
-
-# Build TypeScript invocation
-TS_CODE="
-import { collectConsensus, validateConsensus } from './consensus';
-
-const scores = $SCORES_JSON;
-const mode = '$MODE';
-const threshold = ${THRESHOLD:-null};
-
-try {
-  const consensus = collectConsensus(scores);
-  console.log(\`Consensus Statistics:\`);
-  console.log(\`  Count: \${consensus.count}\`);
-  console.log(\`  Average: \${consensus.average.toFixed(3)}\`);
-  console.log(\`  Min: \${consensus.min.toFixed(3)}\`);
-  console.log(\`  Max: \${consensus.max.toFixed(3)}\`);
-  console.log();
-
-  const validationParams: any = {
-    average: consensus.average,
-    mode
-  };
-  if (threshold !== null) {
-    validationParams.threshold = threshold;
-  }
-  const validation = validateConsensus(validationParams);
-
-  console.log(\`Consensus Validation:\`);
-  console.log(\`  Mode: \${validation.mode}\`);
-  console.log(\`  Threshold: \${validation.threshold.toFixed(2)}\`);
-  console.log(\`  Average: \${validation.average.toFixed(3)}\`);
-  console.log(\`  Gap: \${validation.gap >= 0 ? '+' : ''}\${validation.gap.toFixed(3)}\`);
-  console.log(\`  Passed: \${validation.passed}\`);
-  console.log();
-
-  if (validation.passed) {
-    console.log('✅ Consensus REACHED - Loop 2 validation successful');
-    process.exit(0);
-  } else {
-    console.log('❌ Consensus FAILED - Iteration required');
-    process.exit(1);
-  }
-} catch (error: any) {
-  console.error('Error:', error.message);
-  process.exit(2);
-}
-"
-
-# Execute TypeScript code
-cd "$HELPERS_DIR"
-ts-node -e "$TS_CODE"

package/.claude/skills/cfn-loop-orchestration/helpers/consensus.sh

@@ -1,94 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# Consensus Checker
-# Collects and validates Loop 2 consensus scores
-#
-# Usage:
-#   consensus.sh --task-id <id> \
-#                --agents <agent1,agent2,...> \
-#                --threshold <0.0-1.0> \
-#                --min-quorum <n|n%|0.n>
-#
-# Returns:
-#   Exit 0: Consensus reached
-#   Exit 1: Consensus failed
-##############################################################################
-
-set -euo pipefail
-
-# ⚠️ ANTI-023 MEMORY LEAK PROTECTION: Block Task Mode agents
-# Task Mode agents spawn via Task() tool and should NOT use Redis coordination
-if [[ -z "${TASK_ID:-}" || -z "${MIN_QUORUM:-}" ]]; then
-    echo "❌ TASK MODE DETECTED - Consensus coordination forbidden" >&2
-    echo "🚨 ANTI-023: This script is for CLI-spawned orchestrators only" >&2
-    echo "💡 Task Mode consensus should be collected directly from agent outputs" >&2
-    echo "🔧 Coordinator spawned via Task() tool - use direct JSON processing instead" >&2
-    exit 1
-fi
-
-# Parameters
-TASK_ID=""
-AGENTS=""
-THRESHOLD=""
-MIN_QUORUM=""
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --task-id) TASK_ID="$2"; shift 2 ;;
-    --agents) AGENTS="$2"; shift 2 ;;
-    --threshold) THRESHOLD="$2"; shift 2 ;;
-    --min-quorum) MIN_QUORUM="$2"; shift 2 ;;
-    *) echo "Unknown option: $1"; exit 1 ;;
-  esac
-done
-
-# Validation
-if [ -z "$TASK_ID" ] || [ -z "$AGENTS" ] || [ -z "$THRESHOLD" ] || [ -z "$MIN_QUORUM" ]; then
-  echo "Error: Missing required parameters"
-  exit 1
-fi
-
-# Use Redis Coordination skill to collect consensus scores
-SKILL_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.claude/skills/cfn-cfn-.." && pwd)"
-REDIS_COORD_SKILL="$SKILL_DIR/redis-coordination"
-
-echo "Consensus Check Configuration:"
-echo "  Task ID: $TASK_ID"
-echo "  Agent IDs: $AGENTS"
-echo "  Min Quorum: $MIN_QUORUM"
-echo ""
-
-# Collect Loop 2 consensus scores
-CONSENSUS=$("$REDIS_COORD_SKILL/invoke-waiting-mode.sh" collect \
-  --task-id "$TASK_ID" \
-  --agent-ids "$AGENTS" \
-  --min-quorum "$MIN_QUORUM" 2>&1) || {
-  echo "❌ Error: Failed to collect Loop 2 consensus scores"
-  echo "   Agent IDs: $AGENTS"
-  echo "   Output: $CONSENSUS"
-  exit 1
-}
-
-# Validate consensus is a valid number
-if ! [[ "$CONSENSUS" =~ ^[0-9]+\.?[0-9]*$ ]]; then
-  echo "⚠️  WARNING: Invalid consensus value: $CONSENSUS (expected numeric)"
-  echo "   Defaulting to 0.0"
-  CONSENSUS="0.0"
-fi
-
-echo "Loop 2 Consensus Check:"
-echo "  Consensus: $CONSENSUS"
-echo "  Threshold: $THRESHOLD"
-echo "  Required: >= $THRESHOLD"
-
-# Compare consensus to threshold
-if (( $(echo "$CONSENSUS >= $THRESHOLD" | bc -l) )); then
-  echo "✅ Consensus REACHED - Loop 2 validation successful"
-  exit 0
-else
-  echo "❌ Consensus FAILED - Iteration required"
-  echo "   Gap: $(echo "$THRESHOLD - $CONSENSUS" | bc -l)"
-  exit 1
-fi

package/.claude/skills/cfn-loop-orchestration/helpers/context-injection.sh

@@ -1,142 +0,0 @@
-#!/usr/bin/env bash
-
-#!/usr/bin/env bash
-
-##############################################################################
-# CFN Loop Context Injection Helper - Phase 3.3 Integration
-# Unified ACE context injection using invoke-context-inject.sh
-#
-# Usage:
-#   source context-injection.sh
-#   inject_ace_context "$TASK_DESCRIPTION" "$TASK_TAGS" "$DOMAIN"
-##############################################################################
-
-set -euo pipefail
-
-# Get script directory
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-ACE_INJECT_SCRIPT="${PROJECT_ROOT}/.claude/skills/cfn-ace-system/invoke-context-inject.sh"
-
-##############################################################################
-# Inject ACE Context (Unified Positive + Negative)
-##############################################################################
-inject_ace_context() {
-  local task_description="$1"
-  local task_tags="${2:-}"
-  local domain="${3:-}"
-  local enable_ace="${4:-true}"
-  local output_file="${5:-}"
-
-  # Validate dependencies
-  if [ ! -f "$ACE_INJECT_SCRIPT" ]; then
-    echo "# ACE Context (Unavailable)"
-    echo ""
-    echo "_ACE context injection script not found._"
-    return 1
-  fi
-
-  # Build invocation parameters
-  local invoke_params="--task-description \"$task_description\""
-
-  if [ -n "$task_tags" ]; then
-    invoke_params="$invoke_params --task-tags \"$task_tags\""
-  fi
-
-  if [ -n "$domain" ]; then
-    invoke_params="$invoke_params --domain \"$domain\""
-  fi
-
-  invoke_params="$invoke_params --enable-ace $enable_ace"
-
-  if [ -n "$output_file" ]; then
-    invoke_params="$invoke_params --output \"$output_file\""
-  fi
-
-  # Execute unified context injection
-  eval "$ACE_INJECT_SCRIPT" $invoke_params 2>/dev/null || {
-    echo "# ACE Context (Error)"
-    echo ""
-    echo "_Failed to retrieve ACE context._"
-    return 1
-  }
-
-  return 0
-}
-
-##############################################################################
-# Extract Tags from Context (Helper for Orchestrator)
-##############################################################################
-extract_tags_from_context() {
-  local context_json="$1"
-
-  # Extract tags from deliverables, acceptance criteria, etc.
-  local extracted_tags
-  extracted_tags=$(echo "$context_json" | jq -r '
-    [
-      (.deliverables // [] | .[]),
-      (.acceptanceCriteria // [] | .[]),
-      (.epicGoal // "" | split(" ") | .[])
-    ] |
-    map(select(. != "")) |
-    unique |
-    join(",")
-  ' 2>/dev/null || echo "")
-
-  echo "$extracted_tags"
-}
-
-##############################################################################
-# Classify Domain from Task Description (Helper)
-##############################################################################
-classify_domain() {
-  local task_description="$1"
-
-  local classifier_script="${PROJECT_ROOT}/.claude/skills/cfn-task-classifier/classify-task.sh"
-
-  if [ ! -f "$classifier_script" ]; then
-    echo "general"
-    return
-  fi
-
-  local classification
-  classification=$("$classifier_script" "$task_description" --format json 2>/dev/null || echo '{"domains":["general"]}')
-
-  local primary_domain
-  primary_domain=$(echo "$classification" | jq -r '.domains[0] // "general"')
-
-  echo "$primary_domain"
-}
-
-##############################################################################
-# Main Context Injection Wrapper (For Orchestrator Use)
-##############################################################################
-inject_context_for_agent() {
-  local agent_type="$1"
-  local task_id="$2"
-  local iteration="${3:-1}"
-
-  # Retrieve task context from Redis
-  local task_context
-  if command -v redis-cli &> /dev/null; then
-    task_context=$(redis-cli HGET "cfn_loop:task:$task_id:context" "task_description" 2>/dev/null || echo "")
-  else
-    task_context=""
-  fi
-
-  if [ -z "$task_context" ]; then
-    echo "# ACE Context (No Task Description)"
-    echo ""
-    echo "_Task description not available for context injection._"
-    return 1
-  fi
-
-  # Extract tags and classify domain
-  local task_tags=$(extract_tags_from_context "$task_context")
-  local domain=$(classify_domain "$task_context")
-
-  # Inject unified context
-  inject_ace_context "$task_context" "$task_tags" "$domain" "true" ""
-
-  return 0
-}