claude-flow-novice 2.9.1 → 2.10.0

package/.claude/skills/cfn-ace-system/add-bullet.sh

@@ -0,0 +1,145 @@
+#!/bin/bash
+# Add new bullet to adaptive_context table
+# Usage: ./add-bullet.sh --bullet-id STRAT-007 --category strategy --content "..." --confidence 0.85
+
+set -e
+
+# Default values
+DB_PATH="${ACE_DB_PATH:-./.artifacts/database/swarm-memory.db}"
+BULLET_ID=""
+CATEGORY=""
+CONTENT=""
+CONFIDENCE=0.5
+PRIORITY=5
+TAGS="[]"
+SOURCE_CONTEXT=""
+SOURCE_TASK_ID=""
+ACL_LEVEL=4
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --bullet-id)
+      BULLET_ID="$2"
+      shift 2
+      ;;
+    --category)
+      CATEGORY="$2"
+      shift 2
+      ;;
+    --content)
+      CONTENT="$2"
+      shift 2
+      ;;
+    --confidence)
+      CONFIDENCE="$2"
+      shift 2
+      ;;
+    --priority)
+      PRIORITY="$2"
+      shift 2
+      ;;
+    --tags)
+      TAGS="$2"
+      shift 2
+      ;;
+    --source-context)
+      SOURCE_CONTEXT="$2"
+      shift 2
+      ;;
+    --source-task-id)
+      SOURCE_TASK_ID="$2"
+      shift 2
+      ;;
+    --acl-level)
+      ACL_LEVEL="$2"
+      shift 2
+      ;;
+    *)
+      echo "Unknown option: $1"
+      exit 1
+      ;;
+  esac
+done
+
+# Validate required parameters
+if [ -z "$BULLET_ID" ] || [ -z "$CATEGORY" ] || [ -z "$CONTENT" ]; then
+  echo "Error: Missing required parameters"
+  echo "Usage: $0 --bullet-id <id> --category <cat> --content <text>"
+  exit 1
+fi
+
+# Validate category
+case $CATEGORY in
+  strategy|pattern|edge_case|domain_insight|anti_pattern|optimization)
+    ;;
+  *)
+    echo "Error: Invalid category. Must be: strategy, pattern, edge_case, domain_insight, anti_pattern, or optimization"
+    exit 1
+    ;;
+esac
+
+# Generate unique ID
+UNIQUE_ID="$(echo -n "$BULLET_ID" | md5sum | cut -d' ' -f1)"
+
+# Insert bullet into database
+sqlite3 "$DB_PATH" <<EOF
+-- Ensure table exists
+CREATE TABLE IF NOT EXISTS adaptive_context (
+    id TEXT PRIMARY KEY,
+    bullet_id TEXT NOT NULL UNIQUE,
+    category TEXT NOT NULL CHECK (category IN ('strategy', 'pattern', 'edge_case', 'domain_insight', 'anti_pattern', 'optimization')),
+    content TEXT NOT NULL,
+    helpful_count INTEGER DEFAULT 0,
+    harmful_count INTEGER DEFAULT 0,
+    confidence_score REAL DEFAULT 0.5 CHECK (confidence_score BETWEEN 0.0 AND 1.0),
+    source_context TEXT NOT NULL,
+    source_task_id TEXT,
+    source_agent_id TEXT,
+    tags TEXT,
+    embedding_vector TEXT,
+    parent_bullet_id TEXT,
+    version INTEGER DEFAULT 1,
+    acl_level INTEGER NOT NULL DEFAULT 4 CHECK (acl_level BETWEEN 1 AND 6),
+    swarm_id TEXT,
+    project_id TEXT,
+    is_active BOOLEAN DEFAULT 1,
+    is_validated BOOLEAN DEFAULT 0,
+    validation_metadata TEXT,
+    priority INTEGER DEFAULT 5 CHECK (priority BETWEEN 1 AND 10),
+    last_used_at DATETIME,
+    usage_count INTEGER DEFAULT 0,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    archived_at DATETIME
+);
+
+-- Insert bullet
+INSERT INTO adaptive_context (
+  id, bullet_id, category, content, confidence_score, priority, tags,
+  source_context, source_task_id, acl_level, is_active
+) VALUES (
+  '${UNIQUE_ID}',
+  '${BULLET_ID}',
+  '${CATEGORY}',
+  '${CONTENT}',
+  ${CONFIDENCE},
+  ${PRIORITY},
+  '${TAGS}',
+  '${SOURCE_CONTEXT:-Unknown source}',
+  $([ -n "$SOURCE_TASK_ID" ] && echo "'$SOURCE_TASK_ID'" || echo "NULL"),
+  ${ACL_LEVEL},
+  1
+);
+EOF
+
+# Verify insertion
+COUNT=$(sqlite3 "$DB_PATH" "SELECT COUNT(*) FROM adaptive_context WHERE bullet_id = '${BULLET_ID}';")
+
+if [ "$COUNT" -eq 1 ]; then
+  echo "{\"status\":\"success\",\"bullet_id\":\"${BULLET_ID}\",\"category\":\"${CATEGORY}\",\"confidence\":${CONFIDENCE}}"
+  exit 0
+else
+  echo "{\"status\":\"error\",\"message\":\"Bullet insertion failed\"}"
+  exit 1
+fi

package/.claude/skills/cfn-ace-system/analyze-anti-pattern-effectiveness.sh

@@ -0,0 +1,56 @@
+#!/bin/bash
+# Extended ACE System Anti-Pattern Effectiveness Analysis
+
+set -euo pipefail
+
+analyze_ab_test_results() {
+    local task_id="${1:?Task ID required}"
+
+    # Retrieve A/B test results from Redis
+    local ab_results=$(redis-cli KEYS "ace:ab_test:${task_id}:*")
+
+    # SQLite query to calculate metrics
+    sqlite3 ace_system.db <<EOF
+    WITH ab_test_data AS (
+        SELECT
+            json_extract(data, '$.agent_id') as agent_id,
+            json_extract(data, '$.ace_enabled') as ace_enabled,
+            json_extract(data, '$.first_confidence') as first_confidence,
+            json_extract(data, '$.final_confidence') as final_confidence,
+            json_extract(data, '$.iterations') as iterations
+        FROM ace_effectiveness
+        WHERE task_id = '$task_id'
+    )
+    SELECT
+        CASE WHEN ace_enabled THEN 'ACE' ELSE 'Control' END AS group_name,
+        AVG(first_confidence) AS avg_first_confidence,
+        AVG(final_confidence) AS avg_final_confidence,
+        AVG(iterations) AS avg_iterations,
+        COUNT(*) AS sample_size
+    FROM ab_test_data
+    GROUP BY group_name;
+EOF
+}
+
+calculate_roi() {
+    local task_id="${1:?Task ID required}"
+
+    sqlite3 ace_system.db <<EOF
+    WITH timing_data AS (
+        SELECT
+            json_extract(data, '$.context_injection_time') as injection_time,
+            json_extract(data, '$.iteration_time') as iteration_time
+        FROM ace_performance
+        WHERE task_id = '$task_id'
+    )
+    SELECT
+        AVG(injection_time) as avg_injection_time,
+        AVG(iteration_time) as avg_iteration_time,
+        AVG(iteration_time - injection_time) as time_saved
+    FROM timing_data;
+EOF
+}
+
+# Main execution
+analyze_ab_test_results "$@"
+calculate_roi "$@"

package/.claude/skills/cfn-ace-system/classify-task.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+# ACE System - Task Classifier Wrapper
+# Delegates to cfn-task-classifier skill for domain classification
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CLASSIFIER_PATH="${SCRIPT_DIR}/../cfn-task-classifier/classify-task.sh"
+
+# Validate classifier exists
+if [[ ! -f "$CLASSIFIER_PATH" ]]; then
+  echo "ERROR: Task classifier not found at: $CLASSIFIER_PATH" >&2
+  exit 1
+fi
+
+# Delegate to task classifier with all arguments
+exec "$CLASSIFIER_PATH" "$@"

package/.claude/skills/cfn-ace-system/export-ace-metrics.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+# ACE System Metrics Dashboard Export
+
+set -euo pipefail
+
+EXPORT_DIR="${1:?Export directory required}"
+TIMEFRAME="${2:-7d}"
+
+# Function to generate JSON metrics
+generate_metrics_json() {
+    local task_id="$1"
+
+    # A/B Test Results
+    local ab_results=$(sqlite3 ace_system.db \
+        "SELECT json_group_array(
+            json_object(
+                'group', CASE WHEN ace_enabled THEN 'ACE' ELSE 'Control' END,
+                'avg_first_confidence', AVG(first_confidence),
+                'avg_final_confidence', AVG(final_confidence),
+                'avg_iterations', AVG(iterations)
+            )
+        ) FROM ace_effectiveness WHERE timestamp >= datetime('now', '-$TIMEFRAME')")
+
+    # Performance Metrics
+    local perf_metrics=$(sqlite3 ace_system.db \
+        "SELECT json_group_array(
+            json_object(
+                'injection_time', AVG(context_injection_time),
+                'iteration_time', AVG(iteration_time),
+                'time_saved', AVG(iteration_time - context_injection_time)
+            )
+        ) FROM ace_performance WHERE timestamp >= datetime('now', '-$TIMEFRAME')")
+
+    # Combine metrics
+    jq -n \
+        --argjson ab_results "$ab_results" \
+        --argjson perf_metrics "$perf_metrics" \
+        '{
+            "ab_test_results": $ab_results,
+            "performance_metrics": $perf_metrics,
+            "timestamp": now
+        }' > "${EXPORT_DIR}/ace_metrics_$(date +%Y%m%d_%H%M%S).json"
+}
+
+# Export metrics for each tracked task
+for task_id in $(sqlite3 ace_system.db "SELECT DISTINCT task_id FROM ace_effectiveness"); do
+    generate_metrics_json "$task_id"
+done

package/.claude/skills/cfn-ace-system/extract-tags.sh

@@ -0,0 +1,385 @@
+#!/usr/bin/env bash
+# extract-tags.sh - Automatic tag extraction from sprint execution data
+# Part of ACE System Phase 2.1
+
+set -euo pipefail
+
+# Default values
+TASK_DESCRIPTION=""
+FILES=""
+AGENTS=""
+OUTPUT_FORMAT="json"
+MIN_TAGS=5
+MAX_TAGS=15
+
+# Stopwords for keyword filtering
+STOPWORDS="the and or but for with from this that these those then than will can could should would"
+
+# Usage function
+usage() {
+    cat <<EOF
+Usage: $0 [OPTIONS]
+
+Extract tags from sprint execution data
+
+OPTIONS:
+    --task-description TEXT    Sprint task description
+    --files LIST              Comma-separated list of modified files
+    --agents LIST             Comma-separated list of agent types
+    --output FORMAT           Output format: json|text (default: json)
+    --min-tags NUM            Minimum tags to extract (default: 5)
+    --max-tags NUM            Maximum tags to extract (default: 15)
+    -h, --help                Show this help message
+
+EXAMPLES:
+    $0 --task-description "Implement JWT authentication" \\
+       --files "src/auth.ts,tests/auth.test.ts" \\
+       --agents "backend-dev,security-specialist" \\
+       --output json
+EOF
+    exit 1
+}
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --task-description)
+            TASK_DESCRIPTION="$2"
+            shift 2
+            ;;
+        --files)
+            FILES="$2"
+            shift 2
+            ;;
+        --agents)
+            AGENTS="$2"
+            shift 2
+            ;;
+        --output)
+            OUTPUT_FORMAT="$2"
+            shift 2
+            ;;
+        --min-tags)
+            MIN_TAGS="$2"
+            shift 2
+            ;;
+        --max-tags)
+            MAX_TAGS="$2"
+            shift 2
+            ;;
+        -h|--help)
+            usage
+            ;;
+        *)
+            echo "Unknown option: $1"
+            usage
+            ;;
+    esac
+done
+
+# Validate required parameters
+if [[ -z "$TASK_DESCRIPTION" ]]; then
+    echo "Error: --task-description is required"
+    usage
+fi
+
+# Extract keywords from task description (frequency-based)
+extract_keywords() {
+    local text="$1"
+    local keywords=()
+
+    # Convert to lowercase, extract words (3+ chars), filter stopwords
+    local words=$(echo "$text" | tr '[:upper:]' '[:lower:]' | tr -cs '[:alnum:]' '\n' | grep -E '^.{3,}$' || true)
+
+    # Filter stopwords and count frequencies
+    local filtered_words=""
+    while IFS= read -r word; do
+        if [[ -n "$word" ]] && ! echo "$STOPWORDS" | grep -wq "$word"; then
+            filtered_words="$filtered_words$word"$'\n'
+        fi
+    done <<< "$words"
+
+    # Get top keywords by frequency (unique + sorted)
+    if [[ -n "$filtered_words" ]]; then
+        keywords=($(echo "$filtered_words" | sort | uniq -c | sort -rn | head -10 | awk '{print $2}'))
+    fi
+
+    # Return as JSON array
+    if [[ ${#keywords[@]} -gt 0 ]]; then
+        printf '%s\n' "${keywords[@]}" | jq -R . | jq -s .
+    else
+        echo "[]"
+    fi
+}
+
+# Infer domains from file extensions and paths
+infer_domains_from_files() {
+    local files="$1"
+    local domains=()
+
+    if [[ -z "$files" ]]; then
+        echo "[]"
+        return
+    fi
+
+    # Split files by comma
+    IFS=',' read -ra file_array <<< "$files"
+
+    for file in "${file_array[@]}"; do
+        file=$(echo "$file" | xargs) # Trim whitespace
+
+        # Frontend patterns
+        if [[ "$file" =~ \.(tsx|jsx|css|html|scss|sass)$ ]] || [[ "$file" =~ /frontend/ ]] || [[ "$file" =~ /ui/ ]]; then
+            domains+=("frontend")
+        fi
+
+        # Backend patterns
+        if [[ "$file" =~ \.(ts|js|py|java|go|rb)$ ]] && [[ ! "$file" =~ \.(tsx|jsx)$ ]] && [[ "$file" =~ /(api|backend|server|services)/ ]]; then
+            domains+=("backend")
+        fi
+
+        # Security patterns
+        if [[ "$file" =~ /(auth|security|jwt|oauth)/ ]]; then
+            domains+=("security")
+        fi
+
+        # DevOps patterns
+        if [[ "$file" =~ \.(yaml|yml|dockerfile)$ ]] || [[ "$file" =~ /(docker|k8s|kubernetes|helm|terraform)/ ]]; then
+            domains+=("devops")
+        fi
+
+        # Testing patterns
+        if [[ "$file" =~ \.(test|spec)\. ]] || [[ "$file" =~ /__tests__/ ]] || [[ "$file" =~ /tests?/ ]]; then
+            domains+=("testing")
+        fi
+
+        # Database patterns
+        if [[ "$file" =~ /(database|db|migrations|models|schema)/ ]] || [[ "$file" =~ \.(sql)$ ]]; then
+            domains+=("database")
+        fi
+
+        # Documentation patterns
+        if [[ "$file" =~ \.(md|rst|txt)$ ]] || [[ "$file" =~ /(docs|documentation)/ ]]; then
+            domains+=("documentation")
+        fi
+    done
+
+    # Deduplicate and return as JSON array
+    if [[ ${#domains[@]} -gt 0 ]]; then
+        printf '%s\n' "${domains[@]}" | sort -u | jq -R . | jq -s .
+    else
+        echo "[]"
+    fi
+}
+
+# Infer domains from keywords
+infer_domains_from_keywords() {
+    local keywords_json="$1"
+    local domains=()
+
+    # Extract keywords from JSON array
+    local keywords=$(echo "$keywords_json" | jq -r '.[]')
+
+    while IFS= read -r keyword; do
+        [[ -z "$keyword" ]] && continue
+
+        # Security domain
+        if [[ "$keyword" =~ (auth|jwt|token|oauth|security|encryption|hash|password|credential) ]]; then
+            domains+=("security")
+        fi
+
+        # API domain
+        if [[ "$keyword" =~ (api|rest|graphql|endpoint|route|controller) ]]; then
+            domains+=("api")
+        fi
+
+        # Database domain
+        if [[ "$keyword" =~ (database|sql|query|migration|model|schema|orm) ]]; then
+            domains+=("database")
+        fi
+
+        # Testing domain
+        if [[ "$keyword" =~ (test|testing|spec|assertion|mock|coverage) ]]; then
+            domains+=("testing")
+        fi
+
+        # DevOps domain
+        if [[ "$keyword" =~ (docker|kubernetes|deploy|cicd|pipeline|container) ]]; then
+            domains+=("devops")
+        fi
+
+        # Performance domain
+        if [[ "$keyword" =~ (performance|optimization|cache|latency|speed) ]]; then
+            domains+=("performance")
+        fi
+    done <<< "$keywords"
+
+    # Deduplicate and return as JSON array
+    if [[ ${#domains[@]} -gt 0 ]]; then
+        printf '%s\n' "${domains[@]}" | sort -u | jq -R . | jq -s .
+    else
+        echo "[]"
+    fi
+}
+
+# Extract file type tags
+extract_file_tags() {
+    local files="$1"
+    local file_tags=()
+
+    if [[ -z "$files" ]]; then
+        echo "[]"
+        return
+    fi
+
+    # Split files by comma
+    IFS=',' read -ra file_array <<< "$files"
+
+    for file in "${file_array[@]}"; do
+        file=$(echo "$file" | xargs) # Trim whitespace
+
+        # Extract extension
+        if [[ "$file" =~ \.([^.]+)$ ]]; then
+            ext="${BASH_REMATCH[1]}"
+
+            case "$ext" in
+                ts|tsx)
+                    file_tags+=("typescript")
+                    ;;
+                js|jsx)
+                    file_tags+=("javascript")
+                    ;;
+                py)
+                    file_tags+=("python")
+                    ;;
+                java)
+                    file_tags+=("java")
+                    ;;
+                go)
+                    file_tags+=("golang")
+                    ;;
+                rb)
+                    file_tags+=("ruby")
+                    ;;
+                sh|bash)
+                    file_tags+=("bash")
+                    ;;
+                yaml|yml)
+                    file_tags+=("yaml")
+                    ;;
+                json)
+                    file_tags+=("json")
+                    ;;
+                md)
+                    file_tags+=("markdown")
+                    ;;
+            esac
+        fi
+    done
+
+    # Deduplicate and return as JSON array
+    if [[ ${#file_tags[@]} -gt 0 ]]; then
+        printf '%s\n' "${file_tags[@]}" | sort -u | jq -R . | jq -s .
+    else
+        echo "[]"
+    fi
+}
+
+# Extract agent tags
+extract_agent_tags() {
+    local agents="$1"
+    local agent_tags=()
+
+    if [[ -z "$agents" ]]; then
+        echo "[]"
+        return
+    fi
+
+    # Split agents by comma
+    IFS=',' read -ra agent_array <<< "$agents"
+
+    for agent in "${agent_array[@]}"; do
+        agent=$(echo "$agent" | xargs | tr '[:upper:]' '[:lower:]') # Trim and lowercase
+        [[ -n "$agent" ]] && agent_tags+=("$agent")
+    done
+
+    # Return as JSON array
+    if [[ ${#agent_tags[@]} -gt 0 ]]; then
+        printf '%s\n' "${agent_tags[@]}" | jq -R . | jq -s .
+    else
+        echo "[]"
+    fi
+}
+
+# Combine and deduplicate all tags
+combine_tags() {
+    local keywords_json="$1"
+    local domains_file_json="$2"
+    local domains_keyword_json="$3"
+    local file_tags_json="$4"
+    local agent_tags_json="$5"
+
+    # Merge all JSON arrays
+    local all_tags=$(jq -s 'add | unique' <(echo "$keywords_json") <(echo "$domains_file_json") <(echo "$domains_keyword_json") <(echo "$file_tags_json") <(echo "$agent_tags_json"))
+
+    # Limit to MIN_TAGS - MAX_TAGS range
+    local tag_count=$(echo "$all_tags" | jq 'length')
+
+    if [[ $tag_count -lt $MIN_TAGS ]]; then
+        # If below minimum, return all we have
+        echo "$all_tags"
+    elif [[ $tag_count -gt $MAX_TAGS ]]; then
+        # If above maximum, truncate to MAX_TAGS
+        echo "$all_tags" | jq ".[:$MAX_TAGS]"
+    else
+        echo "$all_tags"
+    fi
+}
+
+# Main execution
+main() {
+    # Extract components
+    local keywords_json=$(extract_keywords "$TASK_DESCRIPTION")
+    local domains_file_json=$(infer_domains_from_files "$FILES")
+    local domains_keyword_json=$(infer_domains_from_keywords "$keywords_json")
+    local file_tags_json=$(extract_file_tags "$FILES")
+    local agent_tags_json=$(extract_agent_tags "$AGENTS")
+
+    # Combine domains (file + keyword based)
+    local all_domains=$(jq -s 'add | unique' <(echo "$domains_file_json") <(echo "$domains_keyword_json"))
+
+    # Combine all tags
+    local combined_tags=$(combine_tags "$keywords_json" "$domains_file_json" "$domains_keyword_json" "$file_tags_json" "$agent_tags_json")
+
+    local tag_count=$(echo "$combined_tags" | jq 'length')
+
+    # Output format
+    if [[ "$OUTPUT_FORMAT" == "json" ]]; then
+        jq -n \
+            --argjson tags "$combined_tags" \
+            --argjson keywords "$keywords_json" \
+            --argjson domains "$all_domains" \
+            --argjson file_tags "$file_tags_json" \
+            --argjson agents "$agent_tags_json" \
+            --arg tag_count "$tag_count" \
+            '{
+                tags: $tags,
+                keywords: $keywords,
+                domains: $domains,
+                agents: $agents,
+                file_tags: $file_tags,
+                tag_count: ($tag_count | tonumber)
+            }'
+    else
+        # Text format
+        echo "Tags: $(echo "$combined_tags" | jq -r '.[]' | tr '\n' ',' | sed 's/,$//')"
+        echo "Keywords: $(echo "$keywords_json" | jq -r '.[]' | tr '\n' ',' | sed 's/,$//')"
+        echo "Domains: $(echo "$all_domains" | jq -r '.[]' | tr '\n' ',' | sed 's/,$//')"
+        echo "Agents: $(echo "$agent_tags_json" | jq -r '.[]' | tr '\n' ',' | sed 's/,$//')"
+        echo "File Tags: $(echo "$file_tags_json" | jq -r '.[]' | tr '\n' ',' | sed 's/,$//')"
+        echo "Tag Count: $tag_count"
+    fi
+}
+
+# Run main
+main