claude-flow-novice 2.14.3 → 2.14.5

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

@@ -1,371 +0,0 @@
-#!/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-assets/skills/cfn-redis-coordination/semantic-match-tfidf.py

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