claude-flow-novice 2.5.2 → 2.8.1

package/.claude/skills/agent-discovery/discover-agents.py

@@ -0,0 +1,175 @@
+#!/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": "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 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": file_path  # Include file path for tracking
+            }
+
+            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/skills/agent-discovery/discover-agents.sh

@@ -0,0 +1,87 @@
+#!/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/agent-discovery/discover-agents.py"
+
+# Output file
+OUTPUT_FILE="/mnt/c/Users/masha/Documents/claude-flow-novice/.claude/skills/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/skills/agent-discovery/invoke-registry.sh

@@ -0,0 +1,11 @@
+#!/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/agent-discovery/agents-registry.json

package/.claude/skills/agent-execution/execute-agent.sh

@@ -0,0 +1,126 @@
+#!/usr/bin/env bash
+##############################################################################
+# Agent Execution Script
+#
+# Executes CLI-spawned agents by invoking Claude API with agent prompt.
+# Supports both Anthropic and z.ai provider routing.
+#
+# Environment Variables:
+#   AGENT_TYPE      - Agent type/name (e.g., "rust-enterprise-developer")
+#   AGENT_ID        - Unique agent identifier (e.g., "rust-enterprise-1")
+#   AGENT_MODEL     - Model to use (haiku, sonnet, opus)
+#   AGENT_TOOLS     - Comma-separated list of tools
+#   TASK_ID         - Task identifier for CFN Loop coordination
+#   ITERATION       - Current iteration number
+#   MODE            - Execution mode (cli, api, hybrid)
+#   PROMPT_FILE     - Path to file containing agent prompt
+#
+# Usage:
+#   ./execute-agent.sh
+##############################################################################
+
+set -euo pipefail
+
+# Validate required environment variables
+if [ -z "${AGENT_TYPE:-}" ]; then
+  echo "Error: AGENT_TYPE environment variable required" >&2
+  exit 1
+fi
+
+if [ -z "${PROMPT_FILE:-}" ] || [ ! -f "${PROMPT_FILE:-}" ]; then
+  echo "Error: PROMPT_FILE must be set and file must exist" >&2
+  exit 1
+fi
+
+# Default values
+AGENT_ID="${AGENT_ID:-${AGENT_TYPE}-1}"
+AGENT_MODEL="${AGENT_MODEL:-haiku}"
+TASK_ID="${TASK_ID:-}"
+ITERATION="${ITERATION:-1}"
+MODE="${MODE:-cli}"
+
+echo "=== Agent Execution ==="
+echo "Agent Type: $AGENT_TYPE"
+echo "Agent ID: $AGENT_ID"
+echo "Model: $AGENT_MODEL"
+echo "Task ID: ${TASK_ID:-N/A}"
+echo "Iteration: $ITERATION"
+echo "Mode: $MODE"
+echo ""
+
+# Read prompt from file
+PROMPT=$(cat "$PROMPT_FILE")
+
+# Determine API provider
+API_PROVIDER="anthropic"
+if [ -f ".claude/config/api-provider.json" ]; then
+  PROVIDER_CONFIG=$(cat .claude/config/api-provider.json)
+  if echo "$PROVIDER_CONFIG" | grep -q '"provider".*"zai"'; then
+    API_PROVIDER="zai"
+  fi
+fi
+
+if [ "${CLAUDE_API_PROVIDER:-}" = "zai" ]; then
+  API_PROVIDER="zai"
+fi
+
+echo "API Provider: $API_PROVIDER"
+echo ""
+
+# Map agent model to API model name
+case "$AGENT_MODEL" in
+  haiku)
+    API_MODEL="claude-3-5-haiku-20241022"
+    ;;
+  sonnet)
+    API_MODEL="claude-3-5-sonnet-20241022"
+    ;;
+  opus)
+    API_MODEL="claude-3-opus-20240229"
+    ;;
+  *)
+    echo "Warning: Unknown model '$AGENT_MODEL', defaulting to haiku" >&2
+    API_MODEL="claude-3-5-haiku-20241022"
+    ;;
+esac
+
+# For now, we'll simulate agent execution by echoing the prompt
+# TODO: Implement actual API calls when API client is ready
+echo "=== Agent Prompt (First 500 chars) ==="
+echo "$PROMPT" | head -c 500
+echo "..."
+echo ""
+echo "=== Agent Execution Status ==="
+echo "✅ Agent prompt prepared successfully"
+echo "⚠️  Note: Direct API execution not yet implemented"
+echo ""
+echo "Next Steps:"
+echo "1. Integrate with Claude API SDK"
+echo "2. Implement streaming response handling"
+echo "3. Add tool execution support"
+echo ""
+
+# For CFN Loop agents, simulate completion protocol
+if [ -n "$TASK_ID" ]; then
+  echo "=== CFN Loop Simulation ==="
+  echo "This agent would execute the following protocol:"
+  echo ""
+  echo "1. Execute task work"
+  echo "2. redis-cli lpush \"swarm:${TASK_ID}:${AGENT_ID}:done\" \"complete\""
+  echo "3. ./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \\"
+  echo "     --task-id \"$TASK_ID\" \\"
+  echo "     --agent-id \"$AGENT_ID\" \\"
+  echo "     --confidence 0.85 \\"
+  echo "     --iteration $ITERATION"
+  echo "4. ./.claude/skills/redis-coordination/invoke-waiting-mode.sh enter \\"
+  echo "     --task-id \"$TASK_ID\" \\"
+  echo "     --agent-id \"$AGENT_ID\" \\"
+  echo "     --context \"iteration-complete\""
+  echo ""
+fi
+
+# Clean up prompt file
+rm -f "$PROMPT_FILE"
+
+# Exit with success (temporary until real execution implemented)
+exit 0