claude-flow-novice 2.9.0 → 2.10.0

package/.claude/skills/cfn-redis-coordination/select-specialist-agent.sh

@@ -0,0 +1,371 @@
+#!/bin/bash
+
+# select-specialist-agent.sh
+# Adaptive agent specialization based on feedback type
+# Part of CFN Loop Robustness & Validation Enhancement
+
+set -euo pipefail
+
+# Script configuration
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SPECIALIST_REGISTRY="$SCRIPT_DIR/specialist-registry.json"
+
+# Default agent when no specialist match found
+DEFAULT_AGENT="general-dev"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Logging function
+log() {
+    echo -e "${BLUE}[$(date +'%Y-%m-%d %H:%M:%S')] SPECIALIST-SELECTOR:${NC} $1"
+}
+
+error() {
+    echo -e "${RED}[ERROR]${NC} $1" >&2
+}
+
+success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+warning() {
+    echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+# Show usage information
+show_usage() {
+    cat << EOF
+Adaptive Agent Specialist Selector
+
+USAGE:
+    $0 --feedback-type <TYPE> [OPTIONS]
+    $0 --feedback-text <TEXT> [OPTIONS]
+
+REQUIRED:
+    --feedback-type <TYPE>     Direct feedback category (CRITICAL|WARNING|SUGGESTION|PERFORMANCE|SECURITY|ARCHITECTURE|TESTING|DOCUMENTATION)
+    --feedback-text <TEXT>     Analyze feedback text to categorize
+
+OPTIONS:
+    --task-id <ID>             Task identifier for logging
+    --iteration <N>            Iteration number (default: 1)
+    --confidence <SCORE>       Confidence threshold for auto-selection (default: 0.7)
+    --default-agent <AGENT>    Fallback agent when no match (default: general-dev)
+    --dry-run                  Show selection without spawning
+    --verbose                  Detailed logging output
+    --help                     Show this help message
+
+EXAMPLES:
+    # Direct feedback type selection
+    $0 --feedback-type SECURITY --task-id "task-123" --iteration 2
+
+    # Analyze feedback text automatically
+    $0 --feedback-text "Memory leak detected in authentication module" --task-id "task-123"
+
+    # Dry run to test selection logic
+    $0 --feedback-text "Database query is slow" --dry-run --verbose
+
+SPECIALIST CATEGORIES:
+    SECURITY        → security-specialist
+    PERFORMANCE     → performance-specialist
+    ARCHITECTURE    → architecture-specialist
+    TESTING         → testing-specialist
+    DOCUMENTATION   → documentation-specialist
+    CRITICAL        → security-specialist (default for critical issues)
+    WARNING         → architecture-specialist (default for warnings)
+    SUGGESTION      → general-dev (default for suggestions)
+
+EOF
+}
+
+# Parse command line arguments
+parse_args() {
+    FEEDBACK_TYPE=""
+    FEEDBACK_TEXT=""
+    TASK_ID=""
+    ITERATION="1"
+    CONFIDENCE="0.7"
+    DRY_RUN=false
+    VERBOSE=false
+
+    while [[ $# -gt 0 ]]; do
+        case $1 in
+            --feedback-type)
+                FEEDBACK_TYPE="$2"
+                shift 2
+                ;;
+            --feedback-text)
+                FEEDBACK_TEXT="$2"
+                shift 2
+                ;;
+            --task-id)
+                TASK_ID="$2"
+                shift 2
+                ;;
+            --iteration)
+                ITERATION="$2"
+                shift 2
+                ;;
+            --confidence)
+                CONFIDENCE="$2"
+                shift 2
+                ;;
+            --default-agent)
+                DEFAULT_AGENT="$2"
+                shift 2
+                ;;
+            --dry-run)
+                DRY_RUN=true
+                shift
+                ;;
+            --verbose)
+                VERBOSE=true
+                shift
+                ;;
+            --help)
+                show_usage
+                exit 0
+                ;;
+            *)
+                error "Unknown option: $1"
+                show_usage
+                exit 1
+                ;;
+        esac
+    done
+
+    # Validate required arguments
+    if [[ -z "$FEEDBACK_TYPE" && -z "$FEEDBACK_TEXT" ]]; then
+        error "Either --feedback-type or --feedback-text is required"
+        show_usage
+        exit 1
+    fi
+}
+
+# Analyze feedback text to determine category
+analyze_feedback_text() {
+    local text="$1"
+    local feedback_type=""
+    
+    if [[ "$VERBOSE" == true ]]; then
+        log "Analyzing feedback text: '$text'"
+    fi
+
+    # Security keywords
+    if echo "$text" | grep -qiE "(security|vulnerability|auth|password|token|injection|xss|csrf|encryption|ssl|tls|hack|breach|malicious)"; then
+        feedback_type="SECURITY"
+    # Performance keywords
+    elif echo "$text" | grep -qiE "(performance|slow|memory|leak|cpu|optimization|cache|bottleneck|latency|throughput|scale|efficiency)"; then
+        feedback_type="PERFORMANCE"
+    # Architecture keywords
+    elif echo "$text" | grep -qiE "(architecture|design|pattern|structure|modular|coupling|cohesion|scalability|maintainability|refactor|component)"; then
+        feedback_type="ARCHITECTURE"
+    # Testing keywords
+    elif echo "$text" | grep -qiE "(test|testing|coverage|unit|integration|e2e|tdd|assert|mock|fixture|spec|validate)"; then
+        feedback_type="TESTING"
+    # Documentation keywords
+    elif echo "$text" | grep -qiE "(documentation|doc|readme|guide|manual|comment|explain|clarify|instruction|tutorial)"; then
+        feedback_type="DOCUMENTATION"
+    # Critical severity indicators
+    elif echo "$text" | grep -qiE "(critical|urgent|broken|failed|crash|error|exception|blocker|showstopper)"; then
+        feedback_type="CRITICAL"
+    # Warning indicators
+    elif echo "$text" | grep -qiE "(warning|caution|risk|potential|should|recommend|consider|improve)"; then
+        feedback_type="WARNING"
+    else
+        feedback_type="SUGGESTION"
+    fi
+
+    if [[ "$VERBOSE" == true ]]; then
+        log "Detected feedback type: $feedback_type"
+    fi
+
+    echo "$feedback_type"
+}
+
+# Initialize specialist registry
+initialize_registry() {
+    if [[ ! -f "$SPECIALIST_REGISTRY" ]]; then
+        log "Creating specialist registry"
+        mkdir -p "$(dirname "$SPECIALIST_REGISTRY")"
+        cat > "$SPECIALIST_REGISTRY" << 'EOF'
+{
+  "specialists": {
+    "security": {
+      "agent": "security-specialist",
+      "keywords": ["security", "vulnerability", "auth", "password", "token", "injection", "xss", "csrf", "encryption", "ssl", "tls", "hack", "breach", "malicious"],
+      "feedback_types": ["SECURITY", "CRITICAL"],
+      "capabilities": ["Security analysis", "Vulnerability assessment", "Authentication/Authorization", "Encryption implementation", "Security testing"],
+      "confidence_threshold": 0.8
+    },
+    "performance": {
+      "agent": "performance-specialist",
+      "keywords": ["performance", "slow", "memory", "leak", "cpu", "optimization", "cache", "bottleneck", "latency", "throughput", "scale", "efficiency"],
+      "feedback_types": ["PERFORMANCE"],
+      "capabilities": ["Performance profiling", "Memory optimization", "Caching strategies", "Load testing", "Benchmarking"],
+      "confidence_threshold": 0.75
+    },
+    "architecture": {
+      "agent": "architecture-specialist",
+      "keywords": ["architecture", "design", "pattern", "structure", "modular", "coupling", "cohesion", "scalability", "maintainability", "refactor", "component"],
+      "feedback_types": ["ARCHITECTURE", "WARNING"],
+      "capabilities": ["System design", "Pattern implementation", "Refactoring", "Modularity", "Scalability planning"],
+      "confidence_threshold": 0.7
+    },
+    "testing": {
+      "agent": "testing-specialist",
+      "keywords": ["test", "testing", "coverage", "unit", "integration", "e2e", "tdd", "assert", "mock", "fixture", "spec", "validate"],
+      "feedback_types": ["TESTING"],
+      "capabilities": ["Test design", "Test automation", "Coverage analysis", "Test-driven development", "Quality assurance"],
+      "confidence_threshold": 0.75
+    },
+    "documentation": {
+      "agent": "documentation-specialist",
+      "keywords": ["documentation", "doc", "readme", "guide", "manual", "comment", "explain", "clarify", "instruction", "tutorial"],
+      "feedback_types": ["DOCUMENTATION"],
+      "capabilities": ["Technical writing", "API documentation", "User guides", "Code comments", "Tutorial creation"],
+      "confidence_threshold": 0.65
+    }
+  },
+  "fallback_mappings": {
+    "CRITICAL": "security",
+    "WARNING": "architecture",
+    "SUGGESTION": "general"
+  },
+  "version": "1.0.0",
+  "last_updated": "2025-06-17"
+}
+EOF
+        log "Specialist registry initialized at $SPECIALIST_REGISTRY"
+    fi
+}
+
+# Select specialist agent based on feedback type
+select_specialist() {
+    local feedback_type="$1"
+    local specialist_type=""
+    local selected_agent=""
+    local confidence=""
+
+    # Normalize feedback type
+    feedback_type=$(echo "$feedback_type" | tr '[:lower:]' '[:upper:]')
+
+    if [[ "$VERBOSE" == true ]]; then
+        log "Selecting specialist for feedback type: $feedback_type"
+    fi
+
+    # Load specialist registry
+    if [[ -f "$SPECIALIST_REGISTRY" ]]; then
+        # Try direct mapping to specialist type
+        specialist_type=$(jq -r ".specialists | to_entries[] | select(.value.feedback_types[] | test(\"^$feedback_type$\"; \"i\")) | .key" "$SPECIALIST_REGISTRY" 2>/dev/null || echo "")
+        
+        # If no direct match, try fallback mappings
+        if [[ -z "$specialist_type" ]]; then
+            specialist_type=$(jq -r ".fallback_mappings[\"$feedback_type\"] // empty" "$SPECIALIST_REGISTRY" 2>/dev/null || echo "")
+        fi
+
+        # Get agent and confidence if specialist type found
+        if [[ -n "$specialist_type" && "$specialist_type" != "null" ]]; then
+            selected_agent=$(jq -r ".specialists[\"$specialist_type\"].agent // empty" "$SPECIALIST_REGISTRY" 2>/dev/null || echo "")
+            confidence=$(jq -r ".specialists[\"$specialist_type\"].confidence_threshold // $CONFIDENCE" "$SPECIALIST_REGISTRY" 2>/dev/null || echo "$CONFIDENCE")
+        fi
+    fi
+
+    # Fallback to default agent if no specialist found
+    if [[ -z "$selected_agent" || "$selected_agent" == "null" ]]; then
+        selected_agent="$DEFAULT_AGENT"
+        confidence="$CONFIDENCE"
+        warning "No specialist found for feedback type '$feedback_type', using default agent: $DEFAULT_AGENT"
+    else
+        success "Selected specialist: $selected_agent (confidence: $confidence)"
+    fi
+
+    echo "$selected_agent:$confidence:$specialist_type"
+}
+
+# Spawn specialist agent
+spawn_specialist() {
+    local agent="$1"
+    local task_id="$2"
+    local iteration="$3"
+    local specialist_type="$4"
+    
+    if [[ "$DRY_RUN" == true ]]; then
+        log "[DRY RUN] Would spawn specialist agent: $agent"
+        log "[DRY RUN] Task ID: $task_id"
+        log "[DRY RUN] Iteration: $iteration"
+        log "[DRY RUN] Specialist type: $specialist_type"
+        return 0
+    fi
+
+    log "Spawning specialist agent: $agent"
+    
+    # Spawn agent using CLI
+    if command -v npx >/dev/null 2>&1; then
+        npx claude-flow-novice spawn agent "$agent" \
+            --task-id "$task_id" \
+            --iteration "$iteration" \
+            --specialist-type "$specialist_type" \
+            --feedback-type "$FEEDBACK_TYPE" || {
+                error "Failed to spawn specialist agent: $agent"
+                return 1
+            }
+        success "Specialist agent spawned successfully: $agent"
+    else
+        error "npx command not found. Cannot spawn specialist agent."
+        return 1
+    fi
+}
+
+# Main execution
+main() {
+    parse_args "$@"
+    
+    # Initialize registry
+    initialize_registry
+    
+    # Determine feedback type
+    if [[ -z "$FEEDBACK_TYPE" ]]; then
+        FEEDBACK_TYPE=$(analyze_feedback_text "$FEEDBACK_TEXT")
+    fi
+    
+    # Select specialist
+    local result=$(select_specialist "$FEEDBACK_TYPE")
+    local selected_agent=$(echo "$result" | cut -d: -f1)
+    local confidence_score=$(echo "$result" | cut -d: -f2)
+    local specialist_type=$(echo "$result" | cut -d: -f3)
+    
+    # Log selection details
+    if [[ "$VERBOSE" == true ]]; then
+        log "Feedback Type: $FEEDBACK_TYPE"
+        log "Selected Agent: $selected_agent"
+        log "Confidence Score: $confidence_score"
+        log "Specialist Type: $specialist_type"
+        log "Task ID: ${TASK_ID:-N/A}"
+        log "Iteration: $ITERATION"
+    fi
+    
+    # Check confidence threshold
+    if (( $(echo "$confidence_score >= $CONFIDENCE" | bc -l) )); then
+        # Spawn specialist
+        spawn_specialist "$selected_agent" "$TASK_ID" "$ITERATION" "$specialist_type"
+        
+        # Return result for orchestrator
+        echo "{\"selected_agent\":\"$selected_agent\",\"confidence\":$confidence_score,\"specialist_type\":\"$specialist_type\",\"feedback_type\":\"$FEEDBACK_TYPE\"}"
+    else
+        warning "Confidence score ($confidence_score) below threshold ($CONFIDENCE), using default agent"
+        if [[ "$DRY_RUN" != true ]]; then
+            spawn_specialist "$DEFAULT_AGENT" "$TASK_ID" "$ITERATION" "general"
+        fi
+        echo "{\"selected_agent\":\"$DEFAULT_AGENT\",\"confidence\":$confidence_score,\"specialist_type\":\"general\",\"feedback_type\":\"$FEEDBACK_TYPE\"}"
+    fi
+}
+
+# Execute main function
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    main "$@"
+fi

package/.claude/skills/cfn-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()