claude-flow-novice 2.18.6 → 2.18.8

package/claude-assets/cfn-extras/skills/deprecated/cfn-agent-discovery/discover-agents.py

@@ -1,184 +0,0 @@
-#!/usr/bin/env python3
-
-import os
-import re
-import sys
-import json
-import logging
-from datetime import datetime
-
-import yaml  # Make sure to `pip install PyYAML`
-
-AGENTS_DIR = "/mnt/c/Users/masha/Documents/claude-flow-novice/.claude/agents"
-OUTPUT_FILE = "/mnt/c/Users/masha/Documents/claude-flow-novice/.claude/skills/agent-discovery/agents-registry.json"
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s: %(message)s',
-    datefmt='%Y-%m-%d %H:%M:%S'
-)
-logger = logging.getLogger(__name__)
-
-# Mapping agent types to loops
-LOOP_MAPPING = {
-    "backend-dev": "loop3",
-    "frontend-dev": "loop3",
-    "coder": "loop3",
-    "developer": "loop3",
-    "api-designer": "loop3",
-    "devops-engineer": "loop3",
-    "security-specialist": "loop3",
-    "researcher": "loop3",
-    "reviewer": "loop2",
-    "tester": "loop2",
-    "validator": "loop2",
-    "auditor": "loop2",
-    "coordinator": "coordinator",
-    "strategic": "strategic"
-}
-
-def clean_windows_endings(content):
-    """Remove Windows line endings."""
-    return content.replace('\r', '')
-
-def extract_frontmatter(file_path):
-    """
-    Extract and parse frontmatter from markdown file using PyYAML.
-    Handles multiline descriptions and Windows line endings.
-    """
-    try:
-        with open(file_path, 'r', encoding='utf-8') as f:
-            content = clean_windows_endings(f.read())
-            match = re.search(r'^---\n(.*?)\n---', content, re.DOTALL | re.MULTILINE)
-
-            if not match:
-                logger.warning(f"No frontmatter found in {file_path}")
-                return None
-
-            frontmatter_str = match.group(1)
-
-            # Use PyYAML for robust parsing
-            try:
-                frontmatter = yaml.safe_load(frontmatter_str)
-                return frontmatter
-            except yaml.YAMLError as e:
-                logger.error(f"YAML parsing error in {file_path}: {e}")
-                return None
-
-    except Exception as e:
-        logger.error(f"Error reading {file_path}: {e}")
-        return None
-
-def determine_loop(agent_type):
-    """Determine the loop for an agent type."""
-    agent_type = str(agent_type).lower()
-    return LOOP_MAPPING.get(agent_type, "strategic")
-
-def relative_path_from_agents(file_path):
-    """
-    Convert absolute file path to relative path from .claude/agents/
-    Maintain flat namespace
-    """
-    base_len = len(AGENTS_DIR)
-    relative_path = file_path[base_len+1:]
-    return relative_path
-
-def process_agents():
-    """Process all agent files and generate registry."""
-    agents = []
-    skipped_files = []
-
-    # Use os.walk to recursively search for .md files
-    for root, dirs, files in os.walk(AGENTS_DIR):
-        # Skip hidden directories
-        dirs[:] = [d for d in dirs if not d.startswith('.')]
-
-        for filename in files:
-            if not filename.endswith('.md'):
-                continue
-
-            # Skip documentation files
-            if filename in ['AGENT_LIFECYCLE.md', 'CLAUDE.md', 'README.md', 'README-VALIDATION.md', 'index.md']:
-                continue
-
-            file_path = os.path.join(root, filename)
-
-            # Skip git files
-            if '/.git/' in file_path:
-                continue
-
-            frontmatter = extract_frontmatter(file_path)
-
-            if not frontmatter:
-                skipped_files.append(file_path)
-                continue
-
-            # Extract required fields with fallbacks
-            name = str(frontmatter.get('name', filename.replace('.md', '')))
-            description = str(frontmatter.get('description', ''))
-            agent_type = str(frontmatter.get('type', 'specialist'))
-            keywords = frontmatter.get('keywords', [])
-
-            # Handle potential list conversion
-            if not isinstance(keywords, list):
-                keywords = [keywords] if keywords else []
-
-            # Determine loop
-            loop = determine_loop(agent_type)
-
-            # Create agent entry
-            agent_entry = {
-                "name": name,
-                "description": description,
-                "type": agent_type,
-                "loop": loop,
-                "keywords": keywords,
-                "file": relative_path_from_agents(file_path)  # Relative path from .claude/agents/
-            }
-
-            logger.info(f"Processing agent: {name}")
-            logger.debug(f"Agent details: {json.dumps(agent_entry, indent=2)}")
-
-            agents.append(agent_entry)
-
-    # Prepare registry
-    registry = {
-        "agents": agents,
-        "last_updated": datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%SZ'),
-        "total_agents": len(agents)
-    }
-
-    # Ensure output directory exists
-    os.makedirs(os.path.dirname(OUTPUT_FILE), exist_ok=True)
-
-    # Write to file
-    try:
-        with open(OUTPUT_FILE, 'w', encoding='utf-8') as f:
-            json.dump(registry, f, indent=2)
-
-        logger.info(f"Agent registry generated: {OUTPUT_FILE}")
-        logger.info(f"Total agents discovered: {len(agents)}")
-
-        if skipped_files:
-            logger.warning(f"Skipped files: {', '.join(skipped_files)}")
-
-        # Verify file was written
-        if os.path.getsize(OUTPUT_FILE) > 0:
-            logger.info("File successfully generated and not empty.")
-        else:
-            raise ValueError("Output file is empty.")
-
-    except Exception as e:
-        logger.error(f"Error writing registry: {e}")
-        sys.exit(1)
-
-def main():
-    try:
-        process_agents()
-    except Exception as e:
-        logger.critical(f"Unhandled exception: {e}", exc_info=True)
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main()

package/claude-assets/cfn-extras/skills/deprecated/cfn-agent-discovery/discover-agents.sh

@@ -1,87 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Logging function
-log() {
-    echo "[$(date +'%Y-%m-%d %H:%M:%S')] $*" >&2
-}
-
-# Error handler
-handle_error() {
-    log "ERROR: An error occurred in line $1"
-    log "Last command failed: $BASH_COMMAND"
-    exit 1
-}
-
-# Trap errors
-trap 'handle_error $LINENO' ERR
-
-# Path to Python script
-PYTHON_SCRIPT="/mnt/c/Users/masha/Documents/claude-flow-novice/.claude/skills/cfn-agent-discovery/discover-agents.py"
-
-# Output file
-OUTPUT_FILE="/mnt/c/Users/masha/Documents/claude-flow-novice/.claude/skills/cfn-agent-discovery/agents-registry.json"
-
-# Logging file
-LOG_FILE="/tmp/agent-discovery.log"
-
-log "Starting agent discovery process"
-
-# Check Python is available
-if ! command -v python3 &> /dev/null; then
-    log "ERROR: Python3 is not installed"
-    exit 1
-fi
-
-# Ensure we have required packages
-log "Installing required Python packages"
-
-# Try multiple methods to install PyYAML
-install_methods=(
-    "python3 -m pip install --user --break-system-packages pyyaml"
-    "python3 -m venv /tmp/pyenv && /tmp/pyenv/bin/pip install pyyaml"
-    "pip3 install --user pyyaml"
-    "pip install --user pyyaml"
-)
-
-installed=false
-for method in "${install_methods[@]}"; do
-    log "Trying installation method: $method"
-    if $method; then
-        installed=true
-        break
-    fi
-done
-
-if [ "$installed" = false ]; then
-    log "ERROR: Could not install PyYAML"
-    exit 1
-fi
-
-# Run Python discovery script with logging
-log "Running discovery script"
-python3 "$PYTHON_SCRIPT" 2>&1 | tee "$LOG_FILE"
-
-# Check script succeeded
-if [ ! -f "$OUTPUT_FILE" ]; then
-    log "ERROR: Output file was not generated"
-    exit 1
-fi
-
-# Optional: Run jq to validate JSON (if jq is available)
-if command -v jq &> /dev/null; then
-    log "Validating JSON output"
-    if jq '.' "$OUTPUT_FILE" > /dev/null 2>&1; then
-        log "✅ JSON is valid"
-    else
-        log "❌ Invalid JSON"
-        exit 1
-    fi
-fi
-
-# Show total agents
-total_agents=$(jq '.total_agents' "$OUTPUT_FILE" 2>/dev/null || echo 0)
-log "Total agents discovered: $total_agents"
-
-# Final success log
-log "Agent discovery completed successfully"

package/claude-assets/cfn-extras/skills/deprecated/cfn-agent-discovery/invoke-registry.sh

@@ -1,11 +0,0 @@
-#!/usr/bin/env bash
-# Invoke Agent Registry Discovery
-
-# Ensure script runs from project root
-cd "$(git rev-parse --show-toplevel)" || exit 1
-
-# Run discovery script
-./skills/agent-discovery/discover-agents.py
-
-# Optional: output registry to stdout
-cat .claude/skills/cfn-agent-discovery/agents-registry.json

package/claude-assets/cfn-extras/skills/deprecated/cfn-agent-selector/SKILL.md

@@ -1,91 +0,0 @@
-# Agent Selector Skill
-
-**Version:** 1.0.0
-**Purpose:** Select optimal agents for CFN Loop v3 based on task type and requirements
-
-## Overview
-
-Recommends Loop 3 (producers) and Loop 2 (evaluators) agents based on:
-- Task type (from task-classifier)
-- Task description keywords
-- Complexity requirements
-
-## Usage
-
-```bash
-AGENTS=$(./.claude/skills/cfn-agent-selector/select-agents.sh \
-  --task-type "software-development" \
-  --description "Implement JWT authentication with refresh tokens")
-
-echo "$AGENTS" | jq '.loop3[]'  # ["backend-dev", "security-specialist"]
-echo "$AGENTS" | jq '.loop2[]'  # ["reviewer", "tester", "security-auditor"]
-```
-
-## Output Format
-
-```json
-{
-  "loop3": ["agent1", "agent2", "agent3"],
-  "loop2": ["validator1", "validator2", "validator3"],
-  "loop4": "product-owner",
-  "reasoning": "Explanation of agent selection"
-}
-```
-
-## Agent Selection Rules
-
-### Software Development
-**Base Loop 3:** backend-dev, coder
-**Add if keywords:**
-- "security", "authentication", "JWT" → security-specialist
-- "database", "SQL", "schema" → database-engineer (if exists)
-- "deploy", "CI/CD", "infrastructure" → devops-engineer
-- "frontend", "React", "UI" → react-frontend-engineer
-
-**Loop 2:** reviewer, tester, security-auditor
-
-### Content Creation
-**Base Loop 3:** copywriter, content-strategist
-**Add if keywords:**
-- "SEO", "search", "keywords" → seo-specialist
-- "technical", "documentation" → technical-writer (if exists)
-
-**Loop 2:** editor, brand-reviewer, compliance-checker
-
-### Research
-**Base Loop 3:** researcher, data-analyst
-**Add if keywords:**
-- "statistics", "data analysis" → statistician (if exists)
-- "domain-specific" → domain-expert
-
-**Loop 2:** fact-checker, methodology-reviewer, statistician
-
-### Design
-**Base Loop 3:** ui-designer, ux-researcher
-**Add if keywords:**
-- "visual", "branding" → visual-designer
-- "accessibility" → accessibility-advocate
-
-**Loop 2:** accessibility-advocate, design-critic, user-tester
-
-### Infrastructure
-**Base Loop 3:** devops-engineer, terraform-engineer
-**Add if keywords:**
-- "Kubernetes", "k8s", "container" → kubernetes-architect
-- "network", "security" → network-engineer (if exists)
-
-**Loop 2:** security-auditor, cost-optimizer, compliance-checker
-
-### Data Engineering
-**Base Loop 3:** data-engineer, pipeline-builder
-**Add if keywords:**
-- "ETL", "transformation" → etl-specialist
-- "streaming", "real-time" → streaming-specialist (if exists)
-
-**Loop 2:** data-quality-validator, schema-reviewer, performance-tester
-
-## Integration
-
-Used by:
-- `.claude/agents/cfn-v3-coordinator.md` - Agent selection
-- `.claude/skills/cfn-agent-selector/select-agents.sh` - Primary selection script

package/claude-assets/cfn-extras/skills/deprecated/cfn-agent-selector/select-agents.sh

@@ -1,112 +0,0 @@
-#!/usr/bin/env bash
-# Dynamic Agent Selection with JSON Registry
-
-set -euo pipefail
-
-# Paths
-REGISTRY_PATH=".claude/skills/cfn-agent-discovery/agents-registry.json"
-LOG_PATH="/tmp/agent_selection_$(date +%s).log"
-
-# Validate inputs
-if [[ $# -lt 2 ]]; then
-    echo "Usage: $0 --task-type TYPE --description 'task description'" >&2
-    exit 1
-fi
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-    case "$1" in
-        --task-type) TASK_TYPE="$2"; shift 2 ;;
-        --description) DESCRIPTION="$2"; shift 2 ;;
-        *) echo "Unknown parameter: $1" >&2; exit 1 ;;
-    esac
-done
-
-# Validate registry
-if [[ ! -f "$REGISTRY_PATH" ]]; then
-    echo "Error: Agent registry not found at $REGISTRY_PATH. Run agent discovery first." >&2
-    exit 1
-fi
-
-# Score agents function with improved flat namespace matching
-score_agents() {
-    local registry_path="$1"
-    local description="$2"
-    local task_type="$3"
-
-    # Complex JQ query for flexible matching
-    jq -r --arg desc "$description" --arg task_type "$task_type" '
-        [
-            .agents[]
-            | select(
-                # Type match using flat namespace
-                (
-                    # Direct type match
-                    .type == $task_type or
-                    # Case-insensitive substring match
-                    (.type | ascii_downcase | contains($task_type | ascii_downcase))
-                )
-            )
-            | {
-                name: .name,
-                file: .file,
-                score: (
-                    # Base type match score
-                    10 +
-                    # Filename-based scoring (flat namespace detection)
-                    (
-                        if (.file | ascii_downcase | contains($task_type | ascii_downcase))
-                        then 5
-                        else 0
-                        end
-                    ) +
-                    # Keyword matching
-                    (
-                        [.keywords[]]
-                        | map(select(
-                            ($desc | ascii_downcase | contains(. | ascii_downcase))
-                        ))
-                        | length * 3
-                    )
-                )
-            }
-        ]
-        | sort_by(.score)
-        | reverse
-        | .[0:3]
-        | map(.name)
-    ' "$registry_path"
-}
-
-# Score agents with strategic fallback
-LOOP3_AGENTS=$(score_agents "$REGISTRY_PATH" "$DESCRIPTION" "coder,developer")
-LOOP2_AGENTS=$(score_agents "$REGISTRY_PATH" "$DESCRIPTION" "reviewer,validator")
-
-# Default fallback
-if [[ -z "$LOOP3_AGENTS" || "$LOOP3_AGENTS" == "[]" ]]; then
-    LOOP3_AGENTS='["product-owner"]'
-fi
-
-if [[ -z "$LOOP2_AGENTS" || "$LOOP2_AGENTS" == "[]" ]]; then
-    LOOP2_AGENTS='["product-owner"]'
-fi
-
-# Log the results
-{
-    echo "Task Description: $DESCRIPTION"
-    echo "Loop 3 Agents: $LOOP3_AGENTS"
-    echo "Loop 2 Agents: $LOOP2_AGENTS"
-} >> "$LOG_PATH"
-
-# Output JSON result with detailed reasoning
-jq -n \
-    --argjson loop3 "$LOOP3_AGENTS" \
-    --argjson loop2 "$LOOP2_AGENTS" \
-    --arg desc "$DESCRIPTION" \
-    '{
-        "loop3": $loop3,
-        "loop2": $loop2,
-        "loop4": "product-owner",
-        "reasoning": "Selected agents by scoring against task description: \($desc)",
-        "log_path": "'"$LOG_PATH"'"
-    }'

package/claude-assets/cfn-extras/skills/deprecated/cfn-cli-setup/validate-cli-environment.sh

@@ -1,192 +0,0 @@
-#!/bin/bash
-# CLI Environment Validation Script
-# Ensures required tools are available before agent deployment
-
-set -euo pipefail
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-# Required tools for CFN Loop CLI agents
-REQUIRED_TOOLS=(
-    "rg:ripgrep"
-    "git"
-    "node"
-    "npm"
-    "jq"
-    "redis-cli"
-    "find"
-    "grep"
-    "sed"
-    "awk"
-    "sort"
-    "uniq"
-    "head"
-    "tail"
-    "wc"
-    "xargs"
-)
-
-echo -e "${GREEN}🔧 CFN Loop CLI Environment Validation${NC}"
-
-# Function to check if a tool is available
-check_tool() {
-    local tool_name="$1"
-    local tool_description="$2"
-
-    if command -v "$tool_name" >/dev/null 2>&1; then
-        echo -e "  ${GREEN}✓${NC} $tool_name ($tool_description)"
-        return 0
-    else
-        echo -e "  ${RED}✗${NC} $tool_name ($tool_description) - ${YELLOW}MISSING${NC}"
-        return 1
-    fi
-}
-
-# Function to validate Node.js version
-validate_node_version() {
-    if command -v node >/dev/null 2>&1; then
-        local node_version=$(node --version 2>/dev/null | sed 's/v//')
-        local major_version=$(echo "$node_version" | cut -d. -f1)
-
-        if [ "$major_version" -ge 18 ]; then
-            echo -e "  ${GREEN}✓${NC} Node.js v$node_version (>= 18 required)"
-            return 0
-        else
-            echo -e "  ${RED}✗${NC} Node.js v$node_version (>= 18 required) - ${YELLOW}VERSION TOO OLD${NC}"
-            return 1
-        fi
-    else
-        echo -e "  ${RED}✗${NC} Node.js - ${YELLOW}NOT FOUND${NC}"
-        return 1
-    fi
-}
-
-# Function to check PATH for common development directories
-validate_path() {
-    echo -e "${YELLOW}Validating PATH...${NC}"
-
-    # Check for common development tool paths
-    local paths_to_check=(
-        "/usr/local/bin"
-        "/usr/bin"
-        "/bin"
-        "$HOME/.local/bin"
-        "$HOME/.cargo/bin"
-        "$HOME/.npm-global/bin"
-        "./node_modules/.bin"
-    )
-
-    local found_paths=0
-    for path in "${paths_to_check[@]}"; do
-        if [ -d "$path" ] && echo "$PATH" | grep -q "$path"; then
-            echo -e "  ${GREEN}✓${NC} $path in PATH"
-            ((found_paths++))
-        fi
-    done
-
-    if [ "$found_paths" -eq 0 ]; then
-        echo -e "  ${YELLOW}⚠${NC} Limited development directories in PATH"
-        return 1
-    fi
-
-    return 0
-}
-
-# Function to validate Redis connection
-validate_redis() {
-    echo -e "${YELLOW}Validating Redis connection...${NC}"
-
-    if redis-cli ping >/dev/null 2>&1; then
-        local redis_info=$(redis-cli info server 2>/dev/null | grep "redis_version" | cut -d: -f2 | tr -d '\r')
-        echo -e "  ${GREEN}✓${NC} Redis v$redis_info - Connected"
-        return 0
-    else
-        echo -e "  ${RED}✗${NC} Redis - ${YELLOW}NOT CONNECTED${NC}"
-        return 1
-    fi
-}
-
-# Function to validate working directory
-validate_working_directory() {
-    echo -e "${YELLOW}Validating working directory...${NC}"
-
-    # Check if we're in a git repository
-    if git rev-parse --git-dir >/dev/null 2>&1; then
-        echo -e "  ${GREEN}✓${NC} Git repository detected"
-    else
-        echo -e "  ${YELLOW}⚠${NC} Not in a git repository"
-    fi
-
-    # Check for claude-flow-novice installation
-    if [ -f "package.json" ] && grep -q "claude-flow-novice" package.json; then
-        echo -e "  ${GREEN}✓${NC} claude-flow-novice dependency found"
-    else
-        echo -e "  ${YELLOW}⚠${NC} claude-flow-novice not found in package.json"
-    fi
-
-    # Check for .claude directory
-    if [ -d ".claude" ]; then
-        echo -e "  ${GREEN}✓${NC} .claude directory found"
-    else
-        echo -e "  ${YELLOW}⚠${NC} .claude directory not found"
-    fi
-}
-
-# Function to install missing tools (suggestions)
-suggest_installations() {
-    echo -e "\n${YELLOW}Installation Suggestions:${NC}"
-    echo -e "  ${YELLOW}ripgrep:${NC} sudo apt-get install ripgrep  # Debian/Ubuntu"
-    echo -e "  ${YELLOW}ripgrep:${NC} brew install ripgrep              # macOS"
-    echo -e "  ${YELLOW}jq:${NC}      sudo apt-get install jq        # Debian/Ubuntu"
-    echo -e "  ${YELLOW}jq:${NC}      brew install jq                 # macOS"
-    echo -e "  ${YELLOW}Redis:${NC}   sudo systemctl start redis     # Linux"
-    echo -e "  ${YELLOW}Redis:${NC}   brew services start redis       # macOS"
-}
-
-# Main validation
-main() {
-    local failed=0
-
-    echo -e "${YELLOW}Checking required tools...${NC}"
-    for tool in "${REQUIRED_TOOLS[@]}"; do
-        local tool_name=$(echo "$tool" | cut -d: -f1)
-        local tool_description=$(echo "$tool" | cut -d: -f2)
-
-        if ! check_tool "$tool_name" "$tool_description"; then
-            ((failed++))
-        fi
-    done
-
-    echo -e "\n${YELLOW}Checking Node.js version...${NC}"
-    if ! validate_node_version; then
-        ((failed++))
-    fi
-
-    echo -e "\n${YELLOW}Checking environment configuration...${NC}"
-    if ! validate_path; then
-        ((failed++))
-    fi
-
-    if ! validate_redis; then
-        ((failed++))
-    fi
-
-    validate_working_directory
-
-    echo -e "\n${GREEN}=== Validation Summary ===${NC}"
-    if [ "$failed" -eq 0 ]; then
-        echo -e "${GREEN}✅ All validations passed! CLI environment is ready.${NC}"
-        return 0
-    else
-        echo -e "${RED}❌ $failed validation(s) failed. CLI environment needs setup.${NC}"
-        suggest_installations
-        return 1
-    fi
-}
-
-# Run validation
-main "$@"