claude-flow-novice 2.5.2 → 2.8.1

package/.claude/skills/redis-coordination/semantic-match-tfidf.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+"""
+TF-IDF Semantic Agent Matcher
+
+Purpose: Use semantic similarity (TF-IDF + cosine similarity) to match
+         task descriptions to optimal agents.
+
+Usage:
+    ./semantic-match-tfidf.py "Build user dashboard" 0.5
+    ./semantic-match-tfidf.py "Create auth system" --threshold 0.6 --json
+
+Output:
+    agent1,agent2,agent3  (default)
+    {"agents": [...]}     (--json)
+"""
+
+import sys
+import json
+import argparse
+
+try:
+    from sklearn.feature_extraction.text import TfidfVectorizer
+    from sklearn.metrics.pairwise import cosine_similarity
+except ImportError:
+    print("Error: scikit-learn not installed", file=sys.stderr)
+    print("Install: pip install scikit-learn", file=sys.stderr)
+    sys.exit(1)
+
+
+# Agent Registry with Enhanced Semantic Descriptions
+# Each description includes keywords, domains, and related concepts
+AGENTS = {
+    "react-frontend-engineer": (
+        "React frontend UI components dashboard interface SPA web application "
+        "user interface client-side JavaScript TypeScript hooks state management "
+        "responsive design web pages forms interactive"
+    ),
+    "ui-designer": (
+        "UI design user experience UX interface design visual design wireframes "
+        "mockups prototypes accessibility usability user flows style guide branding"
+    ),
+    "backend-dev": (
+        "API server backend endpoint REST GraphQL database business logic "
+        "server-side Node.js Python Java authentication authorization data processing "
+        "microservices integration middleware"
+    ),
+    "rust-developer": (
+        "Rust systems programming memory safety concurrency performance "
+        "low-level programming async tokio cargo ownership borrowing compiler "
+        "systems language native speed"
+    ),
+    "rust-mvp-developer": (
+        "Rust MVP prototype proof-of-concept quick implementation basic features "
+        "simple rapid development starter code minimal viable product"
+    ),
+    "rust-enterprise-developer": (
+        "Rust production enterprise advanced optimization performance critical "
+        "production-grade scalable robust high-performance mission-critical"
+    ),
+    "mobile-dev": (
+        "React Native mobile iOS Android app development cross-platform "
+        "smartphone tablet native modules mobile UI touch gestures mobile UX "
+        "app store deployment mobile navigation"
+    ),
+    "devops-engineer": (
+        "infrastructure deployment Docker Kubernetes AWS cloud CI/CD pipeline "
+        "automation orchestration containerization cloud infrastructure Terraform "
+        "monitoring logging provisioning infrastructure-as-code"
+    ),
+    "security-specialist": (
+        "security authentication encryption RBAC vulnerabilities penetration testing "
+        "threat analysis security audit compliance access control authorization "
+        "cybersecurity secure coding SSL/TLS security review"
+    ),
+    "system-architect": (
+        "architecture system design component design API design database schema "
+        "high-level design scalability patterns microservices architecture decisions "
+        "technical leadership design patterns distributed systems"
+    ),
+    "tester": (
+        "testing test unit-test integration-test TDD quality-assurance QA "
+        "test-coverage Jest Mocha pytest test-strategy validation verification "
+        "automated testing regression testing"
+    ),
+    "reviewer": (
+        "code-review quality-assessment technical-debt code-analysis quality-metrics "
+        "code-standards linting static-analysis best-practices code-quality "
+        "peer-review refactoring suggestions"
+    ),
+    "researcher": (
+        "research explore investigate analyze study evaluation comparison "
+        "proof-of-concept feasibility analysis technical-research documentation "
+        "exploration discovery learning experimentation"
+    ),
+    "coder": (
+        "implementation feature-development bug-fix coding general-development "
+        "problem-solving code-implementation feature-completion programming "
+        "general-purpose development writing code"
+    ),
+    "perf-analyzer": (
+        "performance optimization profiling benchmarking speed efficiency "
+        "performance-tuning latency throughput resource-optimization "
+        "scalability load-testing stress-testing performance-metrics"
+    ),
+    "accessibility-advocate": (
+        "accessibility WCAG screen-readers keyboard-navigation ARIA semantic-HTML "
+        "inclusive-design disability-access a11y accessibility-testing "
+        "accessibility-compliance universal-design"
+    ),
+    "code-quality-validator": (
+        "quality-validation architecture-compliance code-standards advanced-quality "
+        "deep-analysis compliance-checking quality-gates code-metrics "
+        "technical-excellence validation comprehensive-review"
+    ),
+    "performance-benchmarker": (
+        "performance-benchmarking metrics analysis load-testing stress-testing "
+        "profiling performance-monitoring benchmark-suite performance-validation "
+        "throughput-testing latency-analysis"
+    ),
+    "product-owner": (
+        "product strategy business decisions scope management priorities "
+        "stakeholder requirements roadmap planning strategic-decisions "
+        "product-vision business-value feature-prioritization"
+    ),
+}
+
+
+def semantic_match(task: str, threshold: float = 0.5, top_n: int = None):
+    """
+    Match task description to agents using TF-IDF semantic similarity.
+
+    Args:
+        task: Task description string
+        threshold: Minimum similarity score (0.0-1.0)
+        top_n: Return top N matches (None = all above threshold)
+
+    Returns:
+        List of dicts: [{"agent": "name", "score": 0.85}, ...]
+    """
+    if not task or not task.strip():
+        return []
+
+    # Build corpus: agent descriptions + task
+    corpus = list(AGENTS.values()) + [task]
+
+    # Vectorize using TF-IDF
+    vectorizer = TfidfVectorizer(
+        lowercase=True,
+        stop_words='english',
+        ngram_range=(1, 2),  # Unigrams + bigrams
+        max_df=0.85,  # Ignore very common terms
+        min_df=1
+    )
+
+    try:
+        tfidf = vectorizer.fit_transform(corpus)
+    except ValueError as e:
+        # Handle edge case: empty vocabulary
+        print(f"Warning: {e}", file=sys.stderr)
+        return []
+
+    # Compute cosine similarity
+    task_vector = tfidf[-1]  # Last item is the task
+    agent_vectors = tfidf[:-1]  # All others are agents
+    similarities = cosine_similarity(task_vector, agent_vectors)[0]
+
+    # Build results
+    results = []
+    for agent_name, score in zip(AGENTS.keys(), similarities):
+        if score >= threshold:
+            results.append({
+                "agent": agent_name,
+                "score": float(score)
+            })
+
+    # Sort by score (descending)
+    results.sort(key=lambda x: x["score"], reverse=True)
+
+    # Limit to top N if specified
+    if top_n is not None:
+        results = results[:top_n]
+
+    return results
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Semantic agent matching using TF-IDF"
+    )
+    parser.add_argument(
+        "task",
+        nargs="?",
+        default="",
+        help="Task description to match against agents"
+    )
+    parser.add_argument(
+        "-t", "--threshold",
+        type=float,
+        default=0.5,
+        help="Minimum similarity threshold (0.0-1.0, default: 0.5)"
+    )
+    parser.add_argument(
+        "-n", "--top-n",
+        type=int,
+        default=None,
+        help="Return top N matches (default: all above threshold)"
+    )
+    parser.add_argument(
+        "-j", "--json",
+        action="store_true",
+        help="Output as JSON instead of CSV"
+    )
+    parser.add_argument(
+        "-v", "--verbose",
+        action="store_true",
+        help="Show scores for all matches"
+    )
+
+    args = parser.parse_args()
+
+    # Get task from args or stdin
+    task = args.task
+    if not task and not sys.stdin.isatty():
+        task = sys.stdin.read().strip()
+
+    if not task:
+        parser.print_help()
+        sys.exit(1)
+
+    # Perform matching
+    matches = semantic_match(task, args.threshold, args.top_n)
+
+    # Output results
+    if args.json:
+        # JSON output
+        print(json.dumps({
+            "task": task,
+            "threshold": args.threshold,
+            "matches": matches
+        }, indent=2))
+    elif args.verbose:
+        # Verbose output with scores
+        for match in matches:
+            print(f"{match['agent']}: {match['score']:.3f}")
+    else:
+        # CSV output (agent names only)
+        agent_names = [m["agent"] for m in matches]
+        print(",".join(agent_names))
+
+
+if __name__ == "__main__":
+    main()

package/.claude/skills/redis-coordination/send-heartbeat.sh

@@ -1,73 +1,165 @@
-#!/bin/bash
-# Redis Coordination Skill - Agent Heartbeat Sender
-# Version: 1.0.0
-# Last Updated: 2025-10-19
-
-# Strict error handling
-set -euo pipefail
-
-# Default values
-TASK_ID=""
-AGENT_ID=""
-STATUS="active"
-TTL=60
-DETAILS='{}'
-
-# Parse command-line arguments
-while [[ $# -gt 0 ]]; do
-    case "$1" in
-        --task-id)
-            TASK_ID="$2"
-            shift 2
-            ;;
-        --agent-id)
-            AGENT_ID="$2"
-            shift 2
-            ;;
-        --status)
-            STATUS="$2"
-            shift 2
-            ;;
-        --ttl)
-            TTL="$2"
-            shift 2
-            ;;
-        --details)
-            DETAILS="$2"
-            shift 2
-            ;;
-        *)
-            echo "Unknown parameter: $1"
-            exit 1
-            ;;
-    esac
-done
-
-# Validate required parameters
-if [[ -z "$TASK_ID" || -z "$AGENT_ID" ]]; then
-    echo "Error: task-id and agent-id are required"
-    exit 1
-fi
-
-# Generate heartbeat payload
-HEARTBEAT_PAYLOAD=$(jq -n \
-    --arg timestamp "$(date +%s)" \
-    --arg status "$STATUS" \
-    --arg task_id "$TASK_ID" \
-    --arg agent_id "$AGENT_ID" \
-    --argjson details "$DETAILS" \
-    '{
-        "timestamp": $timestamp,
-        "status": $status,
-        "task_id": $task_id,
-        "agent_id": $agent_id,
-        "details": $details
-    }')
-
-# Send heartbeat via Redis
-redis-cli setex "swarm:${TASK_ID}:${AGENT_ID}:heartbeat" "$TTL" "$HEARTBEAT_PAYLOAD"
-
-# Log heartbeat
-echo "[$(date -u)] Heartbeat sent: task=${TASK_ID}, agent=${AGENT_ID}, status=${STATUS}" >> /var/log/claude-flow/heartbeats.log
-
+#!/bin/bash
+# Redis Coordination Skill - Agent Heartbeat Sender
+# Version: 2.0.0
+# Last Updated: 2025-10-20
+#
+# Usage:
+#   # One-shot heartbeat (original behavior)
+#   ./send-heartbeat.sh --task-id <id> --agent-id <id>
+#
+#   # Start continuous heartbeat loop
+#   ./send-heartbeat.sh start --task-id <id> --agent-id <id> --interval 30 &
+#   HEARTBEAT_PID=$!
+#
+#   # Stop heartbeat loop
+#   ./send-heartbeat.sh stop --task-id <id> --agent-id <id> --pid $HEARTBEAT_PID
+
+# Strict error handling
+set -euo pipefail
+
+# Default values
+ACTION=""
+TASK_ID=""
+AGENT_ID=""
+STATUS="active"
+TTL=60
+INTERVAL=30  # For continuous mode
+HEARTBEAT_PID=""
+DETAILS='{}'
+
+# Parse command-line arguments
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        start|stop|once)
+            ACTION="$1"
+            shift
+            ;;
+        --task-id)
+            TASK_ID="$2"
+            shift 2
+            ;;
+        --agent-id)
+            AGENT_ID="$2"
+            shift 2
+            ;;
+        --status)
+            STATUS="$2"
+            shift 2
+            ;;
+        --ttl)
+            TTL="$2"
+            shift 2
+            ;;
+        --interval)
+            INTERVAL="$2"
+            shift 2
+            ;;
+        --pid)
+            HEARTBEAT_PID="$2"
+            shift 2
+            ;;
+        --details)
+            DETAILS="$2"
+            shift 2
+            ;;
+        *)
+            echo "Unknown parameter: $1"
+            exit 1
+            ;;
+    esac
+done
+
+# Validate required parameters
+if [[ -z "$TASK_ID" || -z "$AGENT_ID" ]]; then
+    echo "Error: task-id and agent-id are required"
+    exit 1
+fi
+
+# If no action specified, default to one-shot (backward compatibility)
+if [ -z "$ACTION" ]; then
+    ACTION="once"
+fi
+
+HEARTBEAT_KEY="swarm:${TASK_ID}:${AGENT_ID}:heartbeat"
+MARKER_FILE="/tmp/heartbeat-${TASK_ID}-${AGENT_ID}.active"
+
+##############################################################################
+# Send single heartbeat
+##############################################################################
+function send_heartbeat() {
+    # Generate heartbeat payload
+    HEARTBEAT_PAYLOAD=$(jq -n \
+        --arg timestamp "$(date +%s)" \
+        --arg status "$STATUS" \
+        --arg task_id "$TASK_ID" \
+        --arg agent_id "$AGENT_ID" \
+        --argjson details "$DETAILS" \
+        '{
+            "timestamp": $timestamp,
+            "status": $status,
+            "task_id": $task_id,
+            "agent_id": $agent_id,
+            "details": $details
+        }')
+
+    # Send heartbeat via Redis with auto-expiration
+    redis-cli setex "$HEARTBEAT_KEY" "$TTL" "$HEARTBEAT_PAYLOAD" >/dev/null
+}
+
+##############################################################################
+# Start continuous heartbeat loop
+##############################################################################
+function start_heartbeat() {
+    # Create marker file
+    touch "$MARKER_FILE"
+
+    # Background heartbeat loop
+    (
+        while [ -f "$MARKER_FILE" ]; do
+            send_heartbeat
+            sleep "$INTERVAL"
+        done
+    ) &
+
+    echo "✓ Heartbeat started for $AGENT_ID (PID: $!, interval: ${INTERVAL}s)" >&2
+}
+
+##############################################################################
+# Stop heartbeat loop
+##############################################################################
+function stop_heartbeat() {
+    # Remove marker file to stop loop
+    rm -f "$MARKER_FILE"
+
+    # Kill heartbeat process if PID provided
+    if [ -n "$HEARTBEAT_PID" ] && kill -0 "$HEARTBEAT_PID" 2>/dev/null; then
+        kill "$HEARTBEAT_PID" 2>/dev/null || true
+    fi
+
+    # Clean up heartbeat key
+    redis-cli DEL "$HEARTBEAT_KEY" >/dev/null
+
+    echo "✓ Heartbeat stopped for $AGENT_ID" >&2
+}
+
+##############################################################################
+# Main
+##############################################################################
+case "$ACTION" in
+    start)
+        start_heartbeat
+        ;;
+    stop)
+        stop_heartbeat
+        ;;
+    once)
+        send_heartbeat
+        echo "✓ Heartbeat sent for $AGENT_ID" >&2
+        ;;
+    *)
+        echo "Error: Invalid action: $ACTION"
+        exit 1
+        ;;
+esac
+
 exit 0

package/.claude/skills/redis-coordination/signal.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --key)
+            key="$2"
+            shift 2
+            ;;
+        --value)
+            value="$2"
+            shift 2
+            ;;
+        --ttl)
+            ttl="$2"
+            shift 2
+            ;;
+        *)
+            echo "Unknown argument: $1"
+            exit 1
+            ;;
+    esac
+done
+
+# Validate required arguments
+if [[ -z "$key" || -z "$value" ]]; then
+    echo "Error: Both key and value are required"
+    exit 1
+fi
+
+# Default TTL to 3600 if not provided
+ttl=${ttl:-3600}
+
+# Store signal in Redis with specified TTL
+redis-cli setex "$key" "$ttl" "$value"
+
+# Exit successfully
+exit 0

package/.claude/skills/redis-coordination/store-context.sh

@@ -0,0 +1,86 @@
+#!/bin/bash
+
+# Redis Context Storage Primitive
+# Updated interface to match orchestrator expectations
+# Supports both legacy (--key --context) and new (--task-id --key --value --namespace) interfaces
+
+# Initialize variables
+task_id=""
+key=""
+value=""
+namespace="swarm"
+ttl=3600
+append_mode=false
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --task-id)
+            task_id="$2"
+            shift 2
+            ;;
+        --key)
+            key="$2"
+            shift 2
+            ;;
+        --value)
+            value="$2"
+            shift 2
+            ;;
+        --context)
+            # Legacy support: --context is alias for --value
+            value="$2"
+            shift 2
+            ;;
+        --namespace)
+            namespace="$2"
+            shift 2
+            ;;
+        --ttl)
+            ttl="$2"
+            shift 2
+            ;;
+        --append)
+            append_mode=true
+            shift
+            ;;
+        *)
+            echo "Unknown argument: $1" >&2
+            exit 1
+            ;;
+    esac
+done
+
+# Construct Redis key based on interface mode
+if [[ -n "$task_id" ]]; then
+    # New interface: {namespace}:{task_id}:{key}
+    redis_key="${namespace}:${task_id}:${key}"
+else
+    # Legacy interface: key is used directly
+    redis_key="$key"
+fi
+
+# Validate required arguments
+if [[ -z "$redis_key" || -z "$value" ]]; then
+    echo "Error: Both key and value are required" >&2
+    echo "Usage: $0 --task-id <id> --key <key> --value <data> [--namespace <ns>] [--ttl <seconds>] [--append]" >&2
+    echo "   or: $0 --key <full-key> --context <data> [--ttl <seconds>]" >&2
+    exit 1
+fi
+
+# Handle append mode
+if [ "$append_mode" = true ]; then
+    # Get existing value
+    existing=$(redis-cli get "$redis_key" 2>/dev/null)
+
+    # Append new value (comma-separated)
+    if [[ -n "$existing" && "$existing" != "(nil)" ]]; then
+        value="${existing},${value}"
+    fi
+fi
+
+# Store in Redis with specified TTL
+redis-cli setex "$redis_key" "$ttl" "$value" >/dev/null
+
+# Exit successfully
+exit 0