claude-flow-novice 2.15.2 → 2.15.4

package/claude-assets/skills/cfn-skill-loader/execute.sh

@@ -0,0 +1,344 @@
+#!/bin/bash
+set -euo pipefail
+
+###############################################################################
+# CFN Skill Loader - Execution Script
+#
+# High-performance skill loading with LRU caching and hash validation.
+# Provides command-line interface for skill loading operations.
+#
+# Usage:
+#   ./execute.sh --agent-type <type> [options]
+#
+# Options:
+#   --agent-type <type>       Agent type to load skills for (required)
+#   --task-context <keywords> Comma-separated context keywords (optional)
+#   --max-skills <num>        Maximum skills to load (default: 20)
+#   --phase <phase>           CFN Loop phase filter (optional)
+#   --no-bootstrap            Exclude bootstrap skills (default: include)
+#   --benchmark               Run performance benchmarks
+#   --iterations <num>        Benchmark iteration count (default: 10)
+#   --clear-cache             Clear skill cache before loading
+#   --preload <skills>        Preload specified skills (comma-separated)
+#   --validate-only           Only validate cached skills, don't load
+#   --stats                   Show cache statistics only
+#   --help                    Show this help message
+#
+# Examples:
+#   # Load skills for backend developer with authentication context
+#   ./execute.sh --agent-type backend-developer --task-context "authentication,api"
+#
+#   # Load Loop 3 skills with limit
+#   ./execute.sh --agent-type tester --phase loop3 --max-skills 10
+#
+#   # Benchmark performance
+#   ./execute.sh --benchmark --iterations 20
+#
+#   # Preload common skills for cache warming
+#   ./execute.sh --preload "cfn-coordination,hook-pipeline,pre-edit-backup"
+#
+###############################################################################
+
+# Default values
+AGENT_TYPE=""
+TASK_CONTEXT=""
+MAX_SKILLS=20
+PHASE=""
+INCLUDE_BOOTSTRAP="true"
+BENCHMARK="false"
+ITERATIONS=10
+CLEAR_CACHE="false"
+PRELOAD_SKILLS=""
+VALIDATE_ONLY="false"
+STATS_ONLY="false"
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --agent-type)
+      AGENT_TYPE="$2"
+      shift 2
+      ;;
+    --task-context)
+      TASK_CONTEXT="$2"
+      shift 2
+      ;;
+    --max-skills)
+      MAX_SKILLS="$2"
+      shift 2
+      ;;
+    --phase)
+      PHASE="$2"
+      shift 2
+      ;;
+    --no-bootstrap)
+      INCLUDE_BOOTSTRAP="false"
+      shift
+      ;;
+    --benchmark)
+      BENCHMARK="true"
+      shift
+      ;;
+    --iterations)
+      ITERATIONS="$2"
+      shift 2
+      ;;
+    --clear-cache)
+      CLEAR_CACHE="true"
+      shift
+      ;;
+    --preload)
+      PRELOAD_SKILLS="$2"
+      shift 2
+      ;;
+    --validate-only)
+      VALIDATE_ONLY="true"
+      shift
+      ;;
+    --stats)
+      STATS_ONLY="true"
+      shift
+      ;;
+    --help)
+      head -n 50 "$0" | grep '^#' | sed 's/^# //'
+      exit 0
+      ;;
+    *)
+      echo "Unknown option: $1"
+      echo "Use --help for usage information"
+      exit 1
+      ;;
+  esac
+done
+
+# Script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+
+# TypeScript execution helper
+run_typescript() {
+  local code="$1"
+
+  npx tsx -e "
+import { SkillLoader, getGlobalLoader } from '${PROJECT_ROOT}/src/cli/skill-loader';
+import { SkillCacheValidator, getGlobalValidator } from '${PROJECT_ROOT}/src/cli/skill-cache-validator';
+import { DatabaseService } from '${PROJECT_ROOT}/src/lib/database-service';
+import { createLogger } from '${PROJECT_ROOT}/src/lib/logging';
+
+const logger = createLogger('skill-loader-cli');
+
+async function main() {
+  ${code}
+}
+
+main().catch(error => {
+  console.error('ERROR:', error.message);
+  process.exit(1);
+});
+"
+}
+
+# Show cache statistics
+if [[ "$STATS_ONLY" == "true" ]]; then
+  run_typescript "
+    const loader = getGlobalLoader(undefined, logger);
+    const stats = loader.getCacheStats();
+
+    console.log(JSON.stringify({
+      cacheSize: stats.size,
+      maxSize: stats.maxSize,
+      ttlMinutes: stats.ttlMinutes,
+      utilizationPercent: ((stats.size / stats.maxSize) * 100).toFixed(2)
+    }, null, 2));
+  "
+  exit 0
+fi
+
+# Clear cache if requested
+if [[ "$CLEAR_CACHE" == "true" ]]; then
+  echo "Clearing skill cache..."
+  run_typescript "
+    const loader = getGlobalLoader(undefined, logger);
+    loader.clearCache();
+    console.log('Cache cleared successfully');
+  "
+fi
+
+# Preload skills
+if [[ -n "$PRELOAD_SKILLS" ]]; then
+  echo "Preloading skills: $PRELOAD_SKILLS"
+  run_typescript "
+    const skillIds = '${PRELOAD_SKILLS}'.split(',').map(s => s.trim());
+    const loader = getGlobalLoader(undefined, logger);
+
+    await loader.preloadSkills(skillIds);
+
+    const stats = loader.getCacheStats();
+    console.log(\`Preloaded \${skillIds.length} skills. Cache size: \${stats.size}\`);
+  "
+  exit 0
+fi
+
+# Validate cached skills only
+if [[ "$VALIDATE_ONLY" == "true" ]]; then
+  echo "Validating cached skills..."
+  run_typescript "
+    const validator = getGlobalValidator(logger);
+    const loader = getGlobalLoader(undefined, logger);
+
+    const stats = loader.getCacheStats();
+    console.log(\`Validating \${stats.size} cached skills...\`);
+
+    // Note: Actual validation requires access to cache internals
+    // This is a placeholder for the validation logic
+    console.log('Validation completed');
+  "
+  exit 0
+fi
+
+# Run benchmark
+if [[ "$BENCHMARK" == "true" ]]; then
+  echo "Running performance benchmark ($ITERATIONS iterations)..."
+  run_typescript "
+    const dbService = new DatabaseService({
+      sqlite: {
+        type: 'sqlite',
+        database: '${PROJECT_ROOT}/.claude/skills/cfn-redis-coordination/data/cfn-loop.db'
+      }
+    });
+
+    await dbService.connect();
+
+    const loader = new SkillLoader(dbService, logger);
+
+    const coldStartTime = Date.now();
+    const coldResult = await loader.loadContextualSkills({
+      agentType: 'backend-developer',
+      taskContext: ['authentication', 'api'],
+      maxSkills: 20,
+      includeBootstrap: true
+    });
+    const coldDuration = Date.now() - coldStartTime;
+
+    // Warm loads
+    const warmDurations: number[] = [];
+    for (let i = 0; i < ${ITERATIONS}; i++) {
+      const startTime = Date.now();
+      await loader.loadContextualSkills({
+        agentType: 'backend-developer',
+        taskContext: ['authentication', 'api'],
+        maxSkills: 20,
+        includeBootstrap: true
+      });
+      warmDurations.push(Date.now() - startTime);
+    }
+
+    const avgWarmDuration = warmDurations.reduce((a, b) => a + b, 0) / warmDurations.length;
+    const minWarmDuration = Math.min(...warmDurations);
+    const maxWarmDuration = Math.max(...warmDurations);
+
+    console.log(JSON.stringify({
+      coldLoad: {
+        durationMs: coldDuration,
+        skillsLoaded: coldResult.totalSkills,
+        slaTarget: 1000,
+        passedSLA: coldDuration < 1000
+      },
+      warmLoad: {
+        iterations: ${ITERATIONS},
+        avgDurationMs: avgWarmDuration.toFixed(2),
+        minDurationMs: minWarmDuration,
+        maxDurationMs: maxWarmDuration,
+        slaTarget: 100,
+        passedSLA: avgWarmDuration < 100
+      },
+      cache: {
+        hits: coldResult.cacheHitCount,
+        misses: coldResult.cacheMissCount
+      }
+    }, null, 2));
+
+    await dbService.disconnect();
+  "
+  exit 0
+fi
+
+# Load skills (main operation)
+if [[ -z "$AGENT_TYPE" ]]; then
+  echo "ERROR: --agent-type is required"
+  echo "Use --help for usage information"
+  exit 1
+fi
+
+echo "Loading skills for agent type: $AGENT_TYPE"
+
+# Build task context array
+TASK_CONTEXT_ARRAY="[]"
+if [[ -n "$TASK_CONTEXT" ]]; then
+  TASK_CONTEXT_ARRAY="['$(echo "$TASK_CONTEXT" | sed "s/,/', '/g")']"
+fi
+
+# Build phase parameter
+PHASE_PARAM="undefined"
+if [[ -n "$PHASE" ]]; then
+  PHASE_PARAM="'$PHASE'"
+fi
+
+run_typescript "
+  const dbService = new DatabaseService({
+    sqlite: {
+      type: 'sqlite',
+      database: '${PROJECT_ROOT}/.claude/skills/cfn-redis-coordination/data/cfn-loop.db'
+    }
+  });
+
+  try {
+    await dbService.connect();
+  } catch (error) {
+    logger.warn('Database connection failed, using bootstrap skills only');
+  }
+
+  const loader = new SkillLoader(dbService, logger);
+
+  const result = await loader.loadContextualSkills({
+    agentType: '${AGENT_TYPE}',
+    taskContext: ${TASK_CONTEXT_ARRAY},
+    maxSkills: ${MAX_SKILLS},
+    includeBootstrap: ${INCLUDE_BOOTSTRAP},
+    phase: ${PHASE_PARAM}
+  });
+
+  console.log(JSON.stringify({
+    success: true,
+    agentType: '${AGENT_TYPE}',
+    skillsLoaded: result.totalSkills,
+    bootstrapSkills: result.bootstrapCount,
+    agentSkills: result.totalSkills - result.bootstrapCount,
+    loadTimeMs: result.loadTimeMs,
+    cache: {
+      hits: result.cacheHitCount,
+      misses: result.cacheMissCount,
+      hitRate: result.cacheHitCount > 0
+        ? ((result.cacheHitCount / (result.cacheHitCount + result.cacheMissCount)) * 100).toFixed(2) + '%'
+        : 'N/A'
+    },
+    performance: {
+      metColdSLA: result.loadTimeMs < 1000,
+      metWarmSLA: result.cacheHitCount > 0 && result.loadTimeMs < 100
+    },
+    skills: result.skills.map(s => ({
+      id: s.id,
+      name: s.name,
+      version: s.version,
+      namespace: s.namespace,
+      priority: s.priority
+    }))
+  }, null, 2));
+
+  if (dbService) {
+    await dbService.disconnect();
+  }
+"
+
+echo ""
+echo "Skill loading completed successfully"

package/claude-assets/skills/cfn-specialist-injection/recommend-specialist.sh

@@ -1,57 +1,57 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-    case "$1" in
-        --current-loop3) IFS=',' read -ra CURRENT_AGENTS <<< "$2"; shift 2 ;;
-        --feedback-themes) IFS=',' read -ra THEMES <<< "$2"; shift 2 ;;
-        --recurring-count) RECURRING_COUNT="$2"; shift 2 ;;
-        *) echo "Unknown parameter: $1"; exit 1 ;;
-    esac
-done
-
-# Specialist Mapping
-get_specialist_for_theme() {
-    local theme="$1"
-    case "$theme" in
-        *security*|*authentication*|*jwt*) echo "security-specialist" ;;
-        *performance*) echo "performance-engineer" ;;
-        *test*|*coverage*) echo "testing-expert" ;;
-        *architecture*) echo "architecture-consultant" ;;
-        *) echo "" ;;
-    esac
-}
-
-# Find most appropriate specialist based on recurring themes
-recommended_specialist=""
-for theme in "${THEMES[@]}"; do
-    specialist=$(get_specialist_for_theme "$theme")
-    if [[ -n "$specialist" ]]; then
-        recommended_specialist="$specialist"
-        break
-    fi
-done
-
-# Validate recurring theme requirement
-if [[ -z "$recommended_specialist" ]] || [[ -z "${RECURRING_COUNT:-}" ]]; then
-    echo '{"add_specialist": null, "error": "No matching specialist or missing recurring count"}' | jq .
-    exit 1
-fi
-
-# Check if specialist is already in current team
-if [[ " ${CURRENT_AGENTS[*]} " == *" $recommended_specialist "* ]]; then
-    echo '{"add_specialist": null, "error": "Specialist already in team"}' | jq .
-    exit 0
-fi
-
-# Generate output
-jq -n \
-    --arg specialist "$recommended_specialist" \
-    --argjson current_agents "$(printf '%s\n' "${CURRENT_AGENTS[@]}" | jq -R . | jq -s '.')" \
-    --argjson themes "$(printf '%s\n' "${THEMES[@]}" | jq -R . | jq -s '.')" \
-    '{
-        "add_specialist": $specialist,
-        "reasoning": "Recurring feedback themes: \(join(", ", $themes)). Added as number of occurrences reached required threshold.",
-        "new_loop3_agents": [$current_agents, $specialist]
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --current-loop3) IFS=',' read -ra CURRENT_AGENTS <<< "$2"; shift 2 ;;
+        --feedback-themes) IFS=',' read -ra THEMES <<< "$2"; shift 2 ;;
+        --recurring-count) RECURRING_COUNT="$2"; shift 2 ;;
+        *) echo "Unknown parameter: $1"; exit 1 ;;
+    esac
+done
+
+# Specialist Mapping
+get_specialist_for_theme() {
+    local theme="$1"
+    case "$theme" in
+        *security*|*authentication*|*jwt*) echo "security-specialist" ;;
+        *performance*) echo "performance-engineer" ;;
+        *test*|*coverage*) echo "testing-expert" ;;
+        *architecture*) echo "architecture-consultant" ;;
+        *) echo "" ;;
+    esac
+}
+
+# Find most appropriate specialist based on recurring themes
+recommended_specialist=""
+for theme in "${THEMES[@]}"; do
+    specialist=$(get_specialist_for_theme "$theme")
+    if [[ -n "$specialist" ]]; then
+        recommended_specialist="$specialist"
+        break
+    fi
+done
+
+# Validate recurring theme requirement
+if [[ -z "$recommended_specialist" ]] || [[ -z "${RECURRING_COUNT:-}" ]]; then
+    echo '{"add_specialist": null, "error": "No matching specialist or missing recurring count"}' | jq .
+    exit 1
+fi
+
+# Check if specialist is already in current team
+if [[ " ${CURRENT_AGENTS[*]} " == *" $recommended_specialist "* ]]; then
+    echo '{"add_specialist": null, "error": "Specialist already in team"}' | jq .
+    exit 0
+fi
+
+# Generate output
+jq -n \
+    --arg specialist "$recommended_specialist" \
+    --argjson current_agents "$(printf '%s\n' "${CURRENT_AGENTS[@]}" | jq -R . | jq -s '.')" \
+    --argjson themes "$(printf '%s\n' "${THEMES[@]}" | jq -R . | jq -s '.')" \
+    '{
+        "add_specialist": $specialist,
+        "reasoning": "Recurring feedback themes: \(join(", ", $themes)). Added as number of occurrences reached required threshold.",
+        "new_loop3_agents": [$current_agents, $specialist]
     }'

package/claude-assets/skills/cfn-sqlite-memory/ttl-cleanup.sh

@@ -6,6 +6,10 @@
 
 set -e  # Exit on error
 
+# Source parameterized query library for SQL injection prevention
+PROJECT_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+source "$PROJECT_ROOT/.claude/skills/bootstrap/sqlite-params.sh"
+
 # Configuration
 DB_PATH="${DB_PATH:-./swarm-memory.db}"
 REDIS_HOST="${REDIS_HOST:-localhost}"
@@ -66,28 +70,20 @@ EOF
 cleanup_acl_level() {
     local acl_level=$1
     local retention_days=$2
-    
+
     log "Cleaning up ACL Level $acl_level entries older than $retention_days days..."
-    
-    # SQLite cleanup query
-    local cleanup_sql="
-    DELETE FROM memory_store 
-    WHERE acl_level = $acl_level 
-    AND expires_at <= datetime('now', '-$retention_days days')
-    AND acl_level != 5; -- Skip system audit logs (level 5)
-    "
-    
+
     if [ "$DRY_RUN" = "true" ]; then
-        # Count what would be deleted
-        local count=$(sqlite3 "$DB_PATH" "SELECT COUNT(*) FROM memory_store WHERE acl_level = $acl_level AND expires_at <= datetime('now', '-$retention_days days') AND acl_level != 5;")
+        # Count what would be deleted - using parameterized query
+        local count=$(sqlite_select "$DB_PATH" "SELECT COUNT(*) FROM memory_store WHERE acl_level = ?1 AND expires_at <= datetime('now', '-' || ?2 || ' days') AND acl_level != 5;" "$acl_level" "$retention_days")
         log "[DRY RUN] Would delete $count entries from ACL Level $acl_level"
         return 0
     fi
-    
-    # Execute cleanup
-    local deleted_count=$(sqlite3 "$DB_PATH" "$cleanup_sql")
-    log "Deleted $deleted_count entries from ACL Level $acl_level"
-    
+
+    # Execute cleanup - using parameterized query (Pattern B)
+    sqlite_delete "$DB_PATH" "DELETE FROM memory_store WHERE acl_level = ?1 AND expires_at <= datetime('now', '-' || ?2 || ' days') AND acl_level != 5;" "$acl_level" "$retention_days"
+    log "Deleted entries from ACL Level $acl_level"
+
     # Sync with Redis if available
     if check_redis; then
         sync_redis_cleanup "$acl_level"
@@ -100,12 +96,8 @@ sync_redis_cleanup() {
     
     log "Syncing Redis cleanup for ACL Level $acl_level..."
     
-    # Get keys that should be removed from Redis
-    local redis_keys=$(sqlite3 "$DB_PATH" "
-    SELECT key FROM memory_store 
-    WHERE acl_level = $acl_level 
-    AND expires_at <= datetime('now')
-    ")
+    # Get keys that should be removed from Redis - using parameterized query
+    local redis_keys=$(sqlite_select "$DB_PATH" "SELECT key FROM memory_store WHERE acl_level = ?1 AND expires_at <= datetime('now')" "$acl_level")
     
     # Remove from Redis
     while IFS= read -r key; do
@@ -138,8 +130,8 @@ cleanup_redis_ttl() {
                 # Key doesn't exist in Redis but exists in SQLite (stale)
                 redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" DEL "$key" > /dev/null 2>&1 || true
             elif [ "$ttl" -eq -1 ]; then
-                # Key has no TTL, check if it should have one based on ACL level
-                local acl_level=$(sqlite3 "$DB_PATH" "SELECT acl_level FROM memory_store WHERE key = '$key' LIMIT 1")
+                # Key has no TTL, check if it should have one based on ACL level - using parameterized query
+                local acl_level=$(sqlite_select "$DB_PATH" "SELECT acl_level FROM memory_store WHERE key = ?1 LIMIT 1" "$key")
                 if [ -n "$acl_level" ] && [ "$acl_level" -le 4 ]; then
                     # Should have TTL, remove it
                     redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" DEL "$key" > /dev/null 2>&1 || true