claude-flow-novice 2.15.11 → 2.16.0

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

@@ -1,359 +0,0 @@
-#!/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-ts.sh

@@ -1,123 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# Deliverable Verifier (TypeScript Wrapper)
-# Verifies expected deliverables exist (prevents "consensus on vapor")
-#
-# Usage:
-#   deliverable-verifier-ts.sh --files <file1,file2,...> \
-#                              [--expected-types <.ext1,.ext2,...>] \
-#                              [--task-type <description>] \
-#                              [--require-git-changes]
-#
-# Returns:
-#   Exit 0: Deliverables verified
-#   Exit 1: Missing deliverables or validation failed
-##############################################################################
-
-set -euo pipefail
-
-# Get script directory
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-HELPERS_DIR="$SCRIPT_DIR/../src/helpers"
-
-# Parameters
-FILES=""
-EXPECTED_TYPES=""
-TASK_TYPE=""
-REQUIRE_GIT_CHANGES="false"
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --files) FILES="$2"; shift 2 ;;
-    --expected-types) EXPECTED_TYPES="$2"; shift 2 ;;
-    --task-type) TASK_TYPE="$2"; shift 2 ;;
-    --require-git-changes) REQUIRE_GIT_CHANGES="true"; shift 1 ;;
-    *) echo "Unknown option: $1" >&2; exit 1 ;;
-  esac
-done
-
-# Convert comma-separated files to JSON array
-if [ -n "$FILES" ]; then
-  IFS=',' read -ra FILE_ARRAY <<< "$FILES"
-  FILES_JSON="["
-  for i in "${!FILE_ARRAY[@]}"; do
-    if [ $i -gt 0 ]; then
-      FILES_JSON+=","
-    fi
-    FILES_JSON+="\"${FILE_ARRAY[$i]}\""
-  done
-  FILES_JSON+="]"
-else
-  FILES_JSON="[]"
-fi
-
-# Convert comma-separated types to JSON array
-if [ -n "$EXPECTED_TYPES" ]; then
-  IFS=',' read -ra TYPE_ARRAY <<< "$EXPECTED_TYPES"
-  TYPES_JSON="["
-  for i in "${!TYPE_ARRAY[@]}"; do
-    if [ $i -gt 0 ]; then
-      TYPES_JSON+=","
-    fi
-    TYPES_JSON+="\"${TYPE_ARRAY[$i]}\""
-  done
-  TYPES_JSON+="]"
-else
-  TYPES_JSON="undefined"
-fi
-
-# Build TypeScript invocation
-TS_CODE="
-import { verifyDeliverables } from './deliverable-verifier';
-
-const result = verifyDeliverables({
-  files: $FILES_JSON,
-  ${EXPECTED_TYPES:+expectedTypes: $TYPES_JSON,}
-  ${TASK_TYPE:+taskType: '$TASK_TYPE',}
-  requireGitChanges: $REQUIRE_GIT_CHANGES
-});
-
-console.log('Deliverable Verification:');
-console.log(\`  Files checked: \${result.files.length}\`);
-console.log(\`  Found: \${result.found.length}\`);
-console.log(\`  Missing: \${result.missing.length}\`);
-if (result.gitChanges !== undefined) {
-  console.log(\`  Git changes: \${result.gitChanges}\`);
-}
-console.log();
-
-if (result.found.length > 0) {
-  console.log('Found files:');
-  result.found.forEach(file => console.log(\`  ✅ \${file}\`));
-  console.log();
-}
-
-if (result.missing.length > 0) {
-  console.log('Missing files:');
-  result.missing.forEach(file => console.log(\`  ❌ \${file}\`));
-  console.log();
-}
-
-if (result.typeErrors && result.typeErrors.length > 0) {
-  console.log('Type errors:');
-  result.typeErrors.forEach(file => console.log(\`  ⚠️  \${file}\`));
-  console.log();
-}
-
-if (result.verified) {
-  console.log('✅ Deliverable verification PASSED');
-  process.exit(0);
-} else {
-  console.log('❌ Deliverable verification FAILED');
-  if (result.reason) {
-    console.log(\`   Reason: \${result.reason}\`);
-  }
-  process.exit(1);
-}
-"
-
-# Execute TypeScript code
-cd "$HELPERS_DIR"
-ts-node -e "$TS_CODE"

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

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

@@ -1,56 +0,0 @@
-#!/usr/bin/env bash
-##############################################################################
-# Gate Check - TypeScript Wrapper
-# Validates Loop 3 self-assessment using test pass rate thresholds
-#
-# This is a wrapper script that delegates to the TypeScript implementation
-# for better type safety and maintainability.
-#
-# Usage:
-#   gate-check.sh --pass-rate <0.0-1.0> \
-#                 [--threshold <0.0-1.0>] \
-#                 [--mode <mvp|standard|enterprise>]
-#
-# Mode-Specific Thresholds:
-#   - mvp:        0.70 (70% pass rate)
-#   - standard:   0.95 (95% pass rate) [default]
-#   - enterprise: 0.98 (98% pass rate)
-#
-# Returns JSON:
-#   {
-#     "passed": true|false,
-#     "passRate": 0.96,
-#     "threshold": 0.95,
-#     "mode": "standard",
-#     "gap": 0.0,
-#     "reason": "Gate PASSED: ..."
-#   }
-#
-# Exit Codes:
-#   0: Gate passed
-#   1: Gate failed
-##############################################################################
-
-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/gate-check.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/iteration-manager-ts.sh

@@ -1,89 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# Iteration Manager (TypeScript Wrapper)
-# Prepares next iteration and generates wake signals
-#
-# Usage:
-#   iteration-manager-ts.sh --current-iteration <n> \
-#                           --agents <agent1,agent2,...> \
-#                           [--feedback <json>]
-#
-# Returns:
-#   Next iteration metadata (JSON)
-##############################################################################
-
-set -euo pipefail
-
-# Get script directory
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-HELPERS_DIR="$SCRIPT_DIR/../src/helpers"
-
-# Parameters
-CURRENT_ITERATION=""
-AGENTS=""
-FEEDBACK="{}"
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --current-iteration) CURRENT_ITERATION="$2"; shift 2 ;;
-    --agents) AGENTS="$2"; shift 2 ;;
-    --feedback) FEEDBACK="$2"; shift 2 ;;
-    *) echo "Unknown option: $1" >&2; exit 1 ;;
-  esac
-done
-
-# Validation
-if [ -z "$CURRENT_ITERATION" ] || [ -z "$AGENTS" ]; then
-  echo "Error: Missing required parameters" >&2
-  exit 1
-fi
-
-# Convert comma-separated agents to JSON array
-IFS=',' read -ra AGENT_ARRAY <<< "$AGENTS"
-AGENTS_JSON="["
-for i in "${!AGENT_ARRAY[@]}"; do
-  if [ $i -gt 0 ]; then
-    AGENTS_JSON+=","
-  fi
-  AGENTS_JSON+="\"${AGENT_ARRAY[$i]}\""
-done
-AGENTS_JSON+="]"
-
-# Build TypeScript invocation
-TS_CODE="
-import { prepareIteration, wakeAgents } from './iteration-manager';
-
-const iteration = prepareIteration({
-  currentIteration: $CURRENT_ITERATION,
-  feedback: $FEEDBACK
-});
-
-console.log('Iteration Preparation:');
-console.log(\`  Next Iteration: \${iteration.nextIteration}\`);
-console.log(\`  Timestamp: \${iteration.timestamp}\`);
-console.log();
-
-const agentIds = $AGENTS_JSON;
-const wake = wakeAgents(agentIds);
-
-console.log('Wake Signals Generated:');
-wake.signals.forEach((signal, idx) => {
-  console.log(\`  [\${idx + 1}] \${signal}\`);
-});
-console.log();
-console.log(\`✅ Prepared iteration \${iteration.nextIteration} for \${agentIds.length} agents\`);
-
-// Output JSON for programmatic consumption
-console.log();
-console.log('JSON_OUTPUT:', JSON.stringify({
-  nextIteration: iteration.nextIteration,
-  timestamp: iteration.timestamp,
-  signals: wake.signals
-}));
-"
-
-# Execute TypeScript code
-cd "$HELPERS_DIR"
-ts-node -e "$TS_CODE"