claude-flow-novice 2.15.11 → 2.16.1

package/.claude/skills/cfn-loop-orchestration/helpers/iteration-manager.sh

@@ -1,87 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# Iteration Manager
-# Manages iteration cycles and feedback injection
-#
-# Usage:
-#   iteration-manager.sh --task-id <id> \
-#                        --iteration <n> \
-#                        --agents <agent1,agent2,...> \
-#                        --feedback-source <redis-key-prefix>
-#
-# Returns:
-#   Exit 0: Agents awakened for next iteration
-#   Exit 1: Error during wake process
-##############################################################################
-
-set -euo pipefail
-
-# Parameters
-TASK_ID=""
-ITERATION=""
-AGENTS=""
-FEEDBACK_SOURCE=""
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --task-id) TASK_ID="$2"; shift 2 ;;
-    --iteration) ITERATION="$2"; shift 2 ;;
-    --agents) AGENTS="$2"; shift 2 ;;
-    --feedback-source) FEEDBACK_SOURCE="$2"; shift 2 ;;
-    *) echo "Unknown option: $1"; exit 1 ;;
-  esac
-done
-
-# Validation
-if [ -z "$TASK_ID" ] || [ -z "$ITERATION" ] || [ -z "$AGENTS" ]; then
-  echo "Error: Missing required parameters"
-  exit 1
-fi
-
-# Use Redis Coordination skill for wake operations
-SKILL_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.claude/skills/cfn-cfn-.." && pwd)"
-REDIS_COORD_SKILL="$SKILL_DIR/redis-coordination"
-
-echo "Starting Iteration $ITERATION"
-echo "Agents to wake: $AGENTS"
-
-# Convert comma-separated agents to array
-IFS=',' read -ra AGENT_ARRAY <<< "$AGENTS"
-
-# Wake each agent with feedback
-for agent_id in "${AGENT_ARRAY[@]}"; do
-  # Retrieve agent-specific feedback if feedback source provided using Redis coordination primitive
-  FEEDBACK=""
-  if [ -n "$FEEDBACK_SOURCE" ]; then
-    # Retrieve context from Redis using primitive
-    FEEDBACK_JSON=$("$REDIS_COORD_SKILL/retrieve-context.sh" \
-      --task-id "$TASK_ID" \
-      --key "$agent_id" \
-      --namespace "$FEEDBACK_SOURCE" 2>/dev/null || echo "{}")
-
-    # Extract feedback message from JSON (try multiple field names)
-    FEEDBACK=$(echo "$FEEDBACK_JSON" | jq -r '.message // .feedback // .data // ""' 2>/dev/null || echo "")
-  fi
-
-  # Default feedback if none exists
-  if [ -z "$FEEDBACK" ]; then
-    FEEDBACK="Continue iteration $ITERATION with quality improvements"
-  fi
-
-  echo "Waking $agent_id with feedback: ${FEEDBACK:0:80}..."
-
-  # Wake agent using Redis Coordination skill
-  "$REDIS_COORD_SKILL/invoke-waiting-mode.sh" wake \
-    --task-id "$TASK_ID" \
-    --agent-id "$agent_id" \
-    --reason "cfn_loop_iteration" \
-    --iteration "$ITERATION" \
-    --feedback "$FEEDBACK" || {
-    echo "Warning: Failed to wake $agent_id"
-  }
-done
-
-echo "✅ All agents awakened for iteration $ITERATION"
-exit 0

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

@@ -1,104 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# Bash Wrapper for TypeScript Orchestrator
-# Provides backward compatibility with bash-based orchestration
-# Routes all calls to TypeScript implementation
-#
-# Usage:
-#   ./orchestrate-ts.sh --task-id <id> \
-#                       --mode <mvp|standard|enterprise> \
-#                       --max-iterations <n>
-##############################################################################
-
-set -euo pipefail
-
-# Determine script directory and project root
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-ORCHESTRATION_SKILL="$SCRIPT_DIR/.."
-
-# Input validation
-sanitize_input() {
-  local input="$1"
-  local max_length="${2:-256}"
-
-  input="${input:0:$max_length}"
-  echo "$input" | sed 's/[^a-zA-Z0-9._:, /-]//g'
-}
-
-# Configuration
-TASK_ID=""
-MODE="standard"
-MAX_ITERATIONS=10
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --task-id)
-      if [[ $# -lt 2 ]]; then
-        echo "Error: --task-id requires a value" >&2
-        exit 1
-      fi
-      TASK_ID=$(sanitize_input "$2") || { echo "Invalid task ID"; exit 1; }
-      shift 2
-      ;;
-    --mode)
-      if [[ $# -lt 2 ]]; then
-        echo "Error: --mode requires a value" >&2
-        exit 1
-      fi
-      MODE="$2"
-      if [[ ! "$MODE" =~ ^(mvp|standard|enterprise)$ ]]; then
-        echo "Invalid mode. Must be mvp, standard, or enterprise." >&2
-        exit 1
-      fi
-      shift 2
-      ;;
-    --max-iterations)
-      if [[ $# -lt 2 ]]; then
-        echo "Error: --max-iterations requires a value" >&2
-        exit 1
-      fi
-      if [[ ! "$2" =~ ^[1-9][0-9]*$ ]]; then
-        echo "Max iterations must be a positive integer" >&2
-        exit 1
-      fi
-      if [[ "$2" -gt 100 ]]; then
-        echo "Max iterations cannot exceed 100" >&2
-        exit 1
-      fi
-      MAX_ITERATIONS="$2"
-      shift 2
-      ;;
-    *)
-      echo "Error: Unknown option: '$1'" >&2
-      echo "Usage: $0 --task-id <id> --mode <mode> --max-iterations <n>" >&2
-      exit 1
-      ;;
-  esac
-done
-
-# Validate required arguments
-if [ -z "$TASK_ID" ]; then
-  echo "Error: --task-id is required" >&2
-  exit 1
-fi
-
-# Ensure TypeScript is compiled
-if [ ! -d "$ORCHESTRATION_SKILL/dist" ]; then
-  echo "Building TypeScript orchestrator..." >&2
-  cd "$ORCHESTRATION_SKILL"
-  npm run build >/dev/null 2>&1 || {
-    echo "Error: Failed to build TypeScript orchestrator" >&2
-    exit 1
-  }
-fi
-
-# Execute TypeScript orchestrator via Node
-node "$ORCHESTRATION_SKILL/dist/orchestrate.js" \
-  --task-id "$TASK_ID" \
-  --mode "$MODE" \
-  --max-iterations "$MAX_ITERATIONS"
-
-exit $?

package/.claude/skills/cfn-loop-orchestration/helpers/parse-test-results.sh

@@ -1,56 +0,0 @@
-#!/usr/bin/env bash
-##############################################################################
-# Parse Test Results - TypeScript Wrapper
-# Parses test output from multiple testing frameworks
-#
-# This is a wrapper script that delegates to the TypeScript implementation
-# for better type safety and maintainability.
-#
-# Usage:
-#   parse-test-results.sh <framework|auto> <output_file_or_string>
-#
-# Frameworks:
-#   - jest: Jest testing framework
-#   - mocha: Mocha testing framework
-#   - pytest: Python pytest
-#   - tap: TAP (Test Anything Protocol)
-#   - go: Go test output
-#   - auto: Auto-detect framework
-#
-# Returns JSON:
-#   {
-#     "framework": "jest",
-#     "total": 10,
-#     "passed": 8,
-#     "failed": 2,
-#     "skipped": 0,
-#     "passRate": 0.8,
-#     "durationMs": 1234,
-#     "failedTestNames": ["test1", "test2"],
-#     "raw": "..."
-#   }
-##############################################################################
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-SKILL_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
-
-# Path to compiled TypeScript
-TS_DIST="$SKILL_ROOT/dist/helpers/parse-test-results.js"
-
-# Check if TypeScript implementation exists
-if [ ! -f "$TS_DIST" ]; then
-  echo "❌ Error: TypeScript implementation not found at: $TS_DIST" >&2
-  echo "   Run 'npm run build' in .claude/skills/cfn-loop-orchestration/" >&2
-  exit 1
-fi
-
-# Check if node is available
-if ! command -v node &>/dev/null; then
-  echo "❌ Error: Node.js is required but not found in PATH" >&2
-  exit 1
-fi
-
-# Execute TypeScript implementation
-exec node "$TS_DIST" "$@"

package/.claude/skills/cfn-loop-orchestration/helpers/spawn-agents.sh

@@ -1,290 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# Agent Spawning Helper with Context Injection - ACE System Phase 1.4
-# Spawns Loop 3 agents with enriched historical context from Redis
-#
-# Usage:
-#   ./spawn-agents.sh --task-id TASK_ID --iteration N --agents AGENTS --original-context '{...}'
-#
-# Arguments:
-#   --task-id           Unique task identifier (required)
-#   --iteration         Current iteration number (required)
-#   --agents            Comma-separated list of agent types (required)
-#   --original-context  Original task context string (required)
-#
-# Output:
-#   Spawns agents in background with enriched context
-#   Returns: 0 on success, 1 on failure
-#   Logs to: .artifacts/logs/spawn-agents-{TASK_ID}.log
-#
-# Performance:
-#   - Target injection overhead: < 200ms per agent
-#   - Graceful fallback to original context on injection failure
-##############################################################################
-
-set -euo pipefail
-
-# ⚠️ ANTI-023 MEMORY LEAK PROTECTION: Block Task Mode agents
-# Task Mode agents spawn via Task() tool and should NOT use agent spawning scripts
-if [[ -z "${TASK_ID:-}" || -z "${AGENTS:-}" ]]; then
-    echo "❌ TASK MODE DETECTED - Agent spawning forbidden" >&2
-    echo "🚨 ANTI-023: This script is for CLI-spawned coordinators only" >&2
-    echo "💡 Task Mode agent spawning should be handled directly by Main Chat" >&2
-    echo "🔧 Coordinator spawned via Task() tool - use Task() tool for agent spawning instead" >&2
-    exit 1
-fi
-
-# Script directory and project root
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../../.." && pwd)"
-
-# Default values
-TASK_ID=""
-ITERATION=""
-AGENTS=""
-ORIGINAL_CONTEXT=""
-LOG_DIR="$PROJECT_ROOT/.artifacts/logs"
-REDIS_COORD_SKILL="$PROJECT_ROOT/.claude/skills/cfn-redis-coordination"
-
-# Ensure log directory exists
-mkdir -p "$LOG_DIR"
-
-##############################################################################
-# Logging Functions
-##############################################################################
-
-log_info() {
-  local message="$1"
-  echo "[$(date '+%Y-%m-%d %H:%M:%S')] [INFO] $message" | tee -a "$LOG_DIR/spawn-agents-${TASK_ID}.log"
-}
-
-log_warn() {
-  local message="$1"
-  echo "[$(date '+%Y-%m-%d %H:%M:%S')] [WARN] $message" | tee -a "$LOG_DIR/spawn-agents-${TASK_ID}.log"
-}
-
-log_error() {
-  local message="$1"
-  echo "[$(date '+%Y-%m-%d %H:%M:%S')] [ERROR] $message" | tee -a "$LOG_DIR/spawn-agents-${TASK_ID}.log"
-}
-
-##############################################################################
-# Helper Functions
-##############################################################################
-
-sanitize_input() {
-  local input="$1"
-  # Remove dangerous characters (only allow alphanumeric, dash, underscore, dot, comma, colon)
-  echo "$input" | sed 's/[^a-zA-Z0-9._:,-]//g'
-}
-
-enrich_context_for_agent() {
-  local task_id="$1"
-  local agent_type="$2"
-  local original_context="$3"
-
-  # Measure injection time
-  local start_time=$(date +%s%3N)
-
-  # Call context-injection.sh
-  local enriched_context
-  enriched_context=$("$SCRIPT_DIR/context-injection.sh" \
-    --task-id "$task_id" \
-    --agent-type "$agent_type" \
-    --original-context "$original_context" 2>&1)
-
-  local exit_code=$?
-  local end_time=$(date +%s%3N)
-  local duration=$((end_time - start_time))
-
-  # Check if injection succeeded
-  if [ $exit_code -eq 0 ] && echo "$enriched_context" | jq . >/dev/null 2>&1; then
-    # Validate JSON structure
-    if echo "$enriched_context" | jq -e '.historical_context' >/dev/null 2>&1; then
-      log_info "Context injection successful for $agent_type: ${duration}ms"
-
-      # Log context size
-      local hist_size=$(echo "$enriched_context" | jq -r '.historical_context' | wc -c)
-      log_injection_metrics "$agent_type" "$duration" "$hist_size"
-
-      # Warn if injection is slow
-      if [ "$duration" -gt 200 ]; then
-        log_warn "Context injection exceeded 200ms threshold: ${duration}ms"
-      fi
-
-      echo "$enriched_context"
-      return 0
-    fi
-  fi
-
-  # Injection failed - log and return original context
-  log_warn "Context injection failed for $agent_type, using original context"
-  echo "$original_context"
-  return 1
-}
-
-log_injection_metrics() {
-  local agent="$1"
-  local duration_ms="$2"
-  local context_size="$3"
-
-  log_info "Agent $agent metrics: injection ${duration_ms}ms, historical ${context_size} chars"
-}
-
-##############################################################################
-# Main Spawning Function
-##############################################################################
-
-spawn_agents_with_context() {
-  local task_id="$1"
-  local iteration="$2"
-  local agents="$3"
-  local original_context="$4"
-
-  log_info "Starting agent spawning with context injection"
-  log_info "Task ID: $task_id, Iteration: $iteration"
-
-  # Convert comma-separated agents to array
-  IFS=',' read -ra AGENT_ARRAY <<< "$agents"
-
-  # Track agent instance counts for unique ID generation
-  declare -A AGENT_INSTANCE_COUNTS
-
-  # Spawn each agent
-  local spawned_count=0
-  local injection_success_count=0
-
-  for agent_type in "${AGENT_ARRAY[@]}"; do
-    # Trim whitespace
-    agent_type=$(echo "$agent_type" | xargs)
-
-    # Generate unique agent ID (agent-type-iteration-instance)
-    AGENT_INSTANCE_COUNTS["$agent_type"]=$((${AGENT_INSTANCE_COUNTS["$agent_type"]:-0} + 1))
-    INSTANCE_NUM="${AGENT_INSTANCE_COUNTS["$agent_type"]}"
-    UNIQUE_AGENT_ID="${agent_type}-${iteration}-${INSTANCE_NUM}"
-
-    log_info "Spawning agent: $agent_type (ID: $UNIQUE_AGENT_ID)"
-
-    # Sanitize inputs
-    local safe_agent_type safe_task_id safe_agent_id
-    safe_agent_type=$(sanitize_input "$agent_type") || {
-      log_error "Failed to sanitize agent type: $agent_type"
-      continue
-    }
-    safe_task_id=$(sanitize_input "$task_id") || {
-      log_error "Failed to sanitize task ID: $task_id"
-      continue
-    }
-    safe_agent_id=$(sanitize_input "$UNIQUE_AGENT_ID") || {
-      log_error "Failed to sanitize agent ID: $UNIQUE_AGENT_ID"
-      continue
-    }
-
-    # Enrich context with historical data
-    local context_to_use
-    context_to_use=$(enrich_context_for_agent "$safe_task_id" "$safe_agent_type" "$original_context")
-    local injection_status=$?
-
-    if [ $injection_status -eq 0 ]; then
-      ((injection_success_count++))
-    fi
-
-    # Set provider environment variables for this agent (custom routing support)
-    # Spawn in subshell to isolate provider env vars per agent
-    (
-      source .claude/skills/cfn-agent-spawning/get-agent-provider-env.sh "$safe_agent_type"
-
-      # Spawn agent in background with enriched context and custom provider
-      npx claude-flow-novice agent "$safe_agent_type" \
-        --task-id "$safe_task_id" \
-        --agent-id "$safe_agent_id" \
-        --iteration "$iteration" \
-        --context "$context_to_use" &
-
-      AGENT_PID=$!
-      echo $AGENT_PID
-    )
-
-    # Capture PID from subshell output
-    AGENT_PID=$(jobs -p | tail -1)
-    "$REDIS_COORD_SKILL/store-context.sh" \
-      --task-id "$task_id" \
-      --key "${UNIQUE_AGENT_ID}:pid" \
-      --value "{\"pid\": $AGENT_PID}" \
-      --namespace "swarm" >/dev/null
-
-    # Store agent ID mapping for later retrieval
-    redis-cli SADD "swarm:${task_id}:loop3:agent_ids:iteration${iteration}" "$UNIQUE_AGENT_ID" >/dev/null
-
-    log_info "Agent $safe_agent_type spawned (PID: $AGENT_PID)"
-    ((spawned_count++))
-  done
-
-  # Log summary
-  log_info "Agent spawning complete: $spawned_count agents spawned"
-  log_info "Context injection success rate: $injection_success_count/$spawned_count"
-
-  if [ "$spawned_count" -eq 0 ]; then
-    log_error "No agents were spawned"
-    return 1
-  fi
-
-  return 0
-}
-
-##############################################################################
-# Argument Parsing
-##############################################################################
-
-parse_arguments() {
-  while [[ $# -gt 0 ]]; do
-    case "$1" in
-      --task-id)
-        TASK_ID="$2"
-        shift 2
-        ;;
-      --iteration)
-        ITERATION="$2"
-        shift 2
-        ;;
-      --agents)
-        AGENTS="$2"
-        shift 2
-        ;;
-      --original-context)
-        ORIGINAL_CONTEXT="$2"
-        shift 2
-        ;;
-      *)
-        echo "Unknown argument: $1"
-        exit 1
-        ;;
-    esac
-  done
-
-  # Validate required arguments
-  if [ -z "$TASK_ID" ] || [ -z "$ITERATION" ] || [ -z "$AGENTS" ] || [ -z "$ORIGINAL_CONTEXT" ]; then
-    echo "Error: Missing required arguments"
-    echo "Usage: $0 --task-id TASK_ID --iteration N --agents AGENTS --original-context CONTEXT"
-    exit 1
-  fi
-}
-
-##############################################################################
-# Main Execution
-##############################################################################
-
-main() {
-  parse_arguments "$@"
-
-  # Execute spawning with context injection
-  spawn_agents_with_context "$TASK_ID" "$ITERATION" "$AGENTS" "$ORIGINAL_CONTEXT"
-
-  exit $?
-}
-
-# Run main function if script is executed directly
-if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
-  main "$@"
-fi

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

@@ -1,47 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# Timeout Calculator (TypeScript Wrapper)
-# Calculates mode and phase-specific timeouts for agent execution
-#
-# Usage:
-#   timeout-calculator-ts.sh --mode <mvp|standard|enterprise> [--phase <phase-id>]
-#
-# Returns:
-#   Timeout value in seconds (stdout)
-##############################################################################
-
-set -euo pipefail
-
-# Get script directory
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-HELPERS_DIR="$SCRIPT_DIR/../src/helpers"
-
-# Parameters
-MODE="standard"
-PHASE=""
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --mode) MODE="$2"; shift 2 ;;
-    --phase) PHASE="$2"; shift 2 ;;
-    *) echo "Unknown option: $1" >&2; exit 1 ;;
-  esac
-done
-
-# Build TypeScript invocation
-TS_CODE="
-import { calculateTimeout } from './timeout-calculator';
-
-const timeout = calculateTimeout({
-  mode: '$MODE',
-  ${PHASE:+phase: '$PHASE'}
-});
-
-console.log(timeout);
-"
-
-# Execute TypeScript code
-cd "$HELPERS_DIR"
-ts-node -e "$TS_CODE"

package/.claude/skills/cfn-loop-orchestration/helpers/timeout-calculator.sh

@@ -1,51 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# Timeout Calculator
-# Calculates phase-specific timeouts for agent execution
-#
-# Usage:
-#   timeout-calculator.sh --phase-id <phase-identifier>
-#
-# Returns:
-#   Timeout value in seconds (stdout)
-##############################################################################
-
-set -euo pipefail
-
-# Parameters
-PHASE_ID=""
-DEFAULT_TIMEOUT=3600  # 60 minutes
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --phase-id) PHASE_ID="$2"; shift 2 ;;
-    *) echo "Unknown option: $1"; exit 1 ;;
-  esac
-done
-
-# Phase-specific timeout configuration
-# Based on empirical data from Sprint 6
-case "$PHASE_ID" in
-  phase-1)
-    # Backend work - relatively fast
-    echo 900  # 15 minutes
-    ;;
-  phase-2)
-    # React components - more complex
-    echo 3600  # 60 minutes
-    ;;
-  phase-3)
-    # Advanced components - complex
-    echo 3600  # 60 minutes
-    ;;
-  phase-4)
-    # Testing/integration - moderate
-    echo 1800  # 30 minutes
-    ;;
-  *)
-    # Unknown phase - use default
-    echo $DEFAULT_TIMEOUT
-    ;;
-esac