claude-flow-novice 2.9.1 → 2.10.1

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

@@ -0,0 +1,142 @@
+#!/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
+}

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

@@ -0,0 +1,359 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Context Lookup Helper - ACE System Integration Phase 1.2
+# Extracts keywords from task description and queries historical context
+#
+# Usage:
+#   ./context-lookup.sh --task-id TASK_ID --description "Task description"
+#
+# Arguments:
+#   --task-id              Unique task identifier (required)
+#   --description          Task description for keyword extraction (required)
+#   --similarity-threshold Minimum similarity (0.0-1.0, default: 0.70)
+#   --max-results          Maximum results (default: 5)
+#
+# Output:
+#   Stores results in Redis: cfn_loop:{TASK_ID}:historical_context
+#   TTL: 1 hour (3600 seconds)
+#   Logs to: .artifacts/logs/context-lookup-{TASK_ID}.log
+##############################################################################
+
+set -euo pipefail
+
+# Script directory and project root
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+ACE_SKILL_DIR="$PROJECT_ROOT/.claude/skills/cfn-ace-system"
+
+# Default values
+TASK_ID=""
+DESCRIPTION=""
+SIMILARITY_THRESHOLD=0.70
+MAX_RESULTS=5
+LOG_DIR="$PROJECT_ROOT/.artifacts/logs"
+MEMORY_PATH="$PROJECT_ROOT/.artifacts/database/swarm-memory.db"
+
+# Domain classification keywords
+declare -A DOMAIN_KEYWORDS=(
+  [frontend]="react,vue,angular,ui,component,jsx,tsx,css,html,dom,browser,frontend"
+  [backend]="api,server,database,sql,route,endpoint,auth,middleware,backend,express,node"
+  [security]="auth,security,encryption,jwt,oauth,vulnerability,xss,csrf,permission,access"
+  [devops]="deploy,docker,kubernetes,ci,cd,pipeline,infrastructure,aws,azure,gcp,monitoring"
+  [testing]="test,spec,jest,mocha,cypress,e2e,integration,unit,coverage,assertion"
+)
+
+##############################################################################
+# Input Sanitization
+# Prevents command injection, SQL injection via keywords
+##############################################################################
+sanitize_input() {
+  local input="$1"
+  # Remove shell metacharacters and special characters
+  # Only allow alphanumeric, spaces, hyphens, underscores, periods
+  echo "$input" | tr -cd '[:alnum:][:space:]-_.'
+}
+
+##############################################################################
+# Logging
+##############################################################################
+log() {
+  local level="$1"
+  shift
+  local message="$*"
+  local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
+
+  if [ -n "$TASK_ID" ]; then
+    local log_file="$LOG_DIR/context-lookup-${TASK_ID}.log"
+    mkdir -p "$LOG_DIR"
+    echo "[$timestamp] [$level] $message" | tee -a "$log_file"
+  else
+    echo "[$timestamp] [$level] $message"
+  fi
+}
+
+##############################################################################
+# Keyword Extraction
+# Uses regex to extract meaningful terms (3+ chars, excluding common words)
+##############################################################################
+extract_keywords() {
+  local text="$1"
+  local keywords=()
+
+  # Convert to lowercase and extract words
+  local words=$(echo "$text" | tr '[:upper:]' '[:lower:]' | grep -oE '\b[a-z0-9]{3,}\b' || true)
+
+  # Common stopwords to exclude
+  local stopwords="the|and|for|with|from|that|this|are|was|were|been|have|has|had|but|not|you|all|can|will|what|when|who|how"
+
+  # Filter out stopwords and collect unique keywords
+  for word in $words; do
+    if ! echo "$word" | grep -qE "^($stopwords)$"; then
+      # Add to keywords if not already present
+      if [[ ! " ${keywords[@]} " =~ " ${word} " ]]; then
+        keywords+=("$word")
+      fi
+    fi
+  done
+
+  # Return comma-separated keywords
+  IFS=','
+  echo "${keywords[*]}"
+}
+
+##############################################################################
+# Domain Classification
+# Classifies task domain based on keyword matching
+##############################################################################
+classify_domain() {
+  local keywords="$1"
+  local max_score=0
+  local detected_domain="general"
+
+  # Score each domain based on keyword overlap
+  for domain in "${!DOMAIN_KEYWORDS[@]}"; do
+    local domain_kw="${DOMAIN_KEYWORDS[$domain]}"
+    local score=0
+
+    # Count matching keywords
+    IFS=',' read -ra kw_array <<< "$keywords"
+    for kw in "${kw_array[@]}"; do
+      if echo "$domain_kw" | grep -q "$kw"; then
+        ((score++))
+      fi
+    done
+
+    # Track highest scoring domain
+    if [ $score -gt $max_score ]; then
+      max_score=$score
+      detected_domain="$domain"
+    fi
+  done
+
+  # Calculate accuracy estimate
+  local total_keywords=$(echo "$keywords" | tr ',' '\n' | wc -l)
+  local accuracy=0
+  if [ $total_keywords -gt 0 ]; then
+    accuracy=$(echo "scale=2; ($max_score / $total_keywords) * 100" | bc)
+  fi
+
+  log "INFO" "Domain classification: $detected_domain (score: $max_score/$total_keywords, accuracy: ${accuracy}%)"
+  echo "$detected_domain"
+}
+
+##############################################################################
+# Query Historical Context
+# Calls invoke-context-query.sh with extracted keywords
+# Includes graceful fallback if query fails
+##############################################################################
+query_historical_context() {
+  local keywords="$1"
+  local query_script="$ACE_SKILL_DIR/invoke-context-query.sh"
+
+  if [ ! -f "$query_script" ]; then
+    log "ERROR" "invoke-context-query.sh not found at $query_script"
+    log "WARN" "Falling back to empty results due to missing query script"
+    echo "[]"
+    return 0
+  fi
+
+  log "INFO" "Querying historical context with keywords: $keywords"
+
+  # Call ACE query script with error handling
+  local results
+  local query_error=""
+
+  if ! results=$("$query_script" \
+    --keywords "$keywords" \
+    --similarity-threshold "$SIMILARITY_THRESHOLD" \
+    --max-results "$MAX_RESULTS" \
+    --memory-path "$MEMORY_PATH" 2>&1); then
+    query_error="$results"
+    log "ERROR" "Context query failed: $query_error"
+    log "WARN" "Falling back to empty results due to query failure"
+    echo "[]"
+    return 0
+  fi
+
+  # Validate JSON output
+  if ! echo "$results" | jq . > /dev/null 2>&1; then
+    log "ERROR" "Invalid JSON from context query"
+    log "WARN" "Falling back to empty results due to invalid JSON"
+    echo "[]"
+    return 0
+  fi
+
+  # Count results
+  local result_count=$(echo "$results" | jq 'length')
+  log "INFO" "Retrieved $result_count similar contexts (threshold: $SIMILARITY_THRESHOLD)"
+
+  echo "$results"
+}
+
+##############################################################################
+# Store Results in Redis
+# Stores query results with metadata and TTL
+# Includes warning flag if results are empty due to query failure
+##############################################################################
+store_in_redis() {
+  local keywords="$1"
+  local domain="$2"
+  local results="$3"
+  local redis_key="cfn_loop:${TASK_ID}:historical_context"
+
+  # Detect if results are empty (query failure fallback)
+  local result_count=$(echo "$results" | jq 'length')
+  local has_error="false"
+  if [ "$result_count" -eq 0 ]; then
+    has_error="true"
+    log "WARN" "Storing empty results - ACE query may have failed"
+  fi
+
+  # Create metadata object with error flag
+  local metadata=$(jq -n \
+    --arg keywords "$keywords" \
+    --arg domain "$domain" \
+    --arg timestamp "$(date -Iseconds)" \
+    --argjson results "$results" \
+    --argjson has_error "$has_error" \
+    '{
+      keywords: $keywords,
+      domain: $domain,
+      timestamp: $timestamp,
+      similarity_threshold: '"$SIMILARITY_THRESHOLD"',
+      max_results: '"$MAX_RESULTS"',
+      query_error: $has_error,
+      results: $results
+    }')
+
+  # Store in Redis with TTL
+  if ! redis-cli SET "$redis_key" "$metadata" EX 3600 > /dev/null 2>&1; then
+    log "ERROR" "Failed to store results in Redis"
+    return 1
+  fi
+
+  log "INFO" "Stored results in Redis: $redis_key (TTL: 3600s)"
+
+  # Verify storage
+  if ! redis-cli EXISTS "$redis_key" > /dev/null 2>&1; then
+    log "ERROR" "Redis key verification failed"
+    return 1
+  fi
+
+  log "INFO" "Redis storage verified successfully"
+}
+
+##############################################################################
+# Argument Parsing
+##############################################################################
+parse_arguments() {
+  while [[ $# -gt 0 ]]; do
+    case $1 in
+      --task-id)
+        TASK_ID="$2"
+        shift 2
+        ;;
+      --description)
+        DESCRIPTION="$2"
+        shift 2
+        ;;
+      --similarity-threshold)
+        SIMILARITY_THRESHOLD="$2"
+        shift 2
+        ;;
+      --max-results)
+        MAX_RESULTS="$2"
+        shift 2
+        ;;
+      *)
+        log "ERROR" "Unknown option: $1"
+        echo "Usage: $0 --task-id TASK_ID --description 'Task description' [OPTIONS]"
+        exit 1
+        ;;
+    esac
+  done
+
+  # Validation
+  if [ -z "$TASK_ID" ]; then
+    log "ERROR" "--task-id is required"
+    exit 1
+  fi
+
+  if [ -z "$DESCRIPTION" ]; then
+    log "ERROR" "--description is required"
+    exit 1
+  fi
+}
+
+##############################################################################
+# Main Execution
+##############################################################################
+main() {
+  parse_arguments "$@"
+
+  log "INFO" "Starting context lookup for task: $TASK_ID"
+  log "INFO" "Description: $DESCRIPTION"
+
+  # Step 0: Sanitize input
+  local sanitized_description
+  sanitized_description=$(sanitize_input "$DESCRIPTION")
+  log "INFO" "Sanitized description: $sanitized_description"
+
+  # Step 1: Extract keywords
+  local keywords
+  keywords=$(extract_keywords "$sanitized_description")
+
+  local keyword_count=$(echo "$keywords" | tr ',' '\n' | wc -l)
+  log "INFO" "Extracted $keyword_count keywords: $keywords"
+
+  if [ $keyword_count -lt 3 ]; then
+    log "WARN" "Only extracted $keyword_count keywords (requirement: ≥3)"
+  fi
+
+  # Step 2: Classify domain
+  local domain
+  domain=$(classify_domain "$keywords")
+
+  # Step 3: Query historical context
+  local results
+  if ! results=$(query_historical_context "$keywords"); then
+    log "ERROR" "Context query failed"
+    exit 1
+  fi
+
+  # Step 4: Store in Redis
+  if ! store_in_redis "$keywords" "$domain" "$results"; then
+    log "ERROR" "Redis storage failed"
+    exit 1
+  fi
+
+  # Summary
+  log "INFO" "Context lookup complete"
+  log "INFO" "Keywords: $keyword_count extracted"
+  log "INFO" "Domain: $domain"
+  log "INFO" "Results: $(echo "$results" | jq 'length') similar contexts"
+  log "INFO" "Redis: cfn_loop:${TASK_ID}:historical_context (TTL: 3600s)"
+
+  # Calculate confidence score
+  local confidence=0.75
+
+  # Boost confidence based on success criteria
+  if [ $keyword_count -ge 3 ]; then
+    confidence=$(echo "$confidence + 0.05" | bc)
+  fi
+
+  if [ "$(echo "$results" | jq 'length')" -gt 0 ]; then
+    confidence=$(echo "$confidence + 0.10" | bc)
+  fi
+
+  # Cap at 1.0
+  confidence=$(echo "if ($confidence > 1.0) 1.0 else $confidence" | bc)
+
+  log "INFO" "Self-confidence score: $confidence"
+
+  # Return success
+  exit 0
+}
+
+# Execute main
+main "$@"

package/.claude/skills/cfn-loop-orchestration/helpers/deliverable-verifier.sh

@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Deliverable Verifier
+# Verifies expected deliverables were created (prevents "consensus on vapor")
+#
+# Usage:
+#   deliverable-verifier.sh --expected-files <file1,file2,...> \
+#                           --task-type <keyword-detection>
+#
+# Returns:
+#   Exit 0: Deliverables verified
+#   Exit 1: Missing deliverables
+##############################################################################
+
+set -euo pipefail
+
+# Parameters
+EXPECTED_FILES=""
+TASK_TYPE=""
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --expected-files) EXPECTED_FILES="$2"; shift 2 ;;
+    --task-type) TASK_TYPE="$2"; shift 2 ;;
+    *) echo "Unknown option: $1"; exit 1 ;;
+  esac
+done
+
+# Check git status for file changes
+GIT_CHANGES=$(git status --short | wc -l)
+
+echo "Deliverable Verification:"
+echo "  Git changes detected: $GIT_CHANGES files"
+
+# If expected files specified, check them explicitly
+if [ -n "$EXPECTED_FILES" ]; then
+  IFS=',' read -ra FILE_ARRAY <<< "$EXPECTED_FILES"
+  MISSING_COUNT=0
+
+  for file in "${FILE_ARRAY[@]}"; do
+    if [ -f "$file" ]; then
+      echo "  ✅ Found: $file"
+    else
+      echo "  ❌ Missing: $file"
+      MISSING_COUNT=$((MISSING_COUNT + 1))
+    fi
+  done
+
+  if [ $MISSING_COUNT -gt 0 ]; then
+    echo "❌ Deliverable verification FAILED: $MISSING_COUNT missing files"
+    exit 1
+  fi
+fi
+
+# Keyword-based task type detection
+if [ -n "$TASK_TYPE" ]; then
+  if [[ "$TASK_TYPE" =~ (create|build|implement|add|generate) ]]; then
+    # Implementation tasks require file changes
+    if [ $GIT_CHANGES -eq 0 ]; then
+      echo "❌ Implementation task detected but no files created"
+      echo "   Task type: $TASK_TYPE"
+      echo "   This is 'consensus on vapor' - forcing iteration"
+      exit 1
+    fi
+  fi
+fi
+
+echo "✅ Deliverable verification PASSED"
+exit 0

package/.claude/skills/cfn-loop-orchestration/helpers/gate-check.sh

@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Gate Check Helper
+# Validates Loop 3 self-assessment against gate threshold
+#
+# Usage:
+#   gate-check.sh --task-id <id> \
+#                 --agents <agent1,agent2,...> \
+#                 --threshold <0.0-1.0> \
+#                 --min-quorum <n|n%|0.n>
+#
+# Returns:
+#   Exit 0: Gate passed (Loop 3 meets threshold)
+#   Exit 1: Gate failed (Loop 3 needs iteration)
+##############################################################################
+
+set -euo pipefail
+
+# 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 confidence scores
+SKILL_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.claude/skills/cfn-cfn-.." && pwd)"
+REDIS_COORD_SKILL="$SKILL_DIR/redis-coordination"
+
+echo "Gate Check Configuration:"
+echo "  Task ID: $TASK_ID"
+echo "  Agent IDs: $AGENTS"
+echo "  Min Quorum: $MIN_QUORUM"
+echo ""
+
+# Collect Loop 3 confidence scores
+# Note: invoke-waiting-mode.sh outputs consensus to stdout and verbose messages to stderr
+# We capture only stdout to get the numeric consensus value
+CONSENSUS=$("$REDIS_COORD_SKILL/invoke-waiting-mode.sh" collect \
+  --task-id "$TASK_ID" \
+  --agent-ids "$AGENTS" \
+  --min-quorum "$MIN_QUORUM") || {
+  echo "❌ Error: Failed to collect Loop 3 confidence 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 3 Gate Check:"
+echo "  Consensus: $CONSENSUS"
+echo "  Threshold: $THRESHOLD"
+echo "  Required: >= $THRESHOLD"
+
+# Compare consensus to gate threshold
+if (( $(echo "$CONSENSUS >= $THRESHOLD" | bc -l) )); then
+  echo "✅ Gate PASSED - Loop 3 self-validation successful"
+
+  # NOTE: Orchestrator controls Loop 2 spawn timing directly (orchestrate.sh line 520)
+  # No signal broadcast needed - Loop 2 agents spawn after this helper returns 0
+
+  exit 0
+else
+  echo "❌ Gate FAILED - Loop 3 needs improvement"
+  echo "   Gap: $(echo "$THRESHOLD - $CONSENSUS" | bc -l)"
+  exit 1
+fi