claude-flow-novice 2.14.34 → 2.14.36

package/claude-assets/skills/cfn-validation-runner-instrumentation/wrapped-executor.sh

@@ -1,327 +1,289 @@
-#!/bin/bash
-# CFN Validation Runner Instrumentation
-# Wraps Bun/Node/Playwright invocations with logging, timeouts, and cleanup
+#!/usr/bin/env bash
+
+##############################################################################
+# CFN Validation Runner Process Instrumentation
+# Provides process wrapping, monitoring, and instrumentation for CFN agents
+#
+# Usage:
+#   source wrapped-executor.sh
+#   wrap_execution <command> <timeout> <log_prefix>
+#
+# Example:
+#   wrap_execution "npx claude-flow-novice agent coder" 300 "agent-execution"
+##############################################################################
 
 set -euo pipefail
 
-# Script configuration
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
-
-# Configuration defaults
-DEFAULT_TIMEOUT="${CFN_VALIDATION_TIMEOUT:-300}"  # 5 minutes
-DEFAULT_MEMORY="${CFN_VALIDATION_MEMORY:-2048}"  # 2GB
-LOG_DIR="${CFN_VALIDATION_LOG_DIR:-$PROJECT_ROOT/.claude/logs/validation}"
-MONITOR_INTERVAL="${CFN_MONITOR_INTERVAL:-30}"  # 30 seconds
-
-# 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 functions
-log_info() {
-    echo -e "${BLUE}[INFO]${NC} $(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE"
-}
+# Instrumentation state
+declare -A CFN_INSTRUMENT_STATE
+CFN_INSTRUMENT_STATE["active"]=false
+CFN_INSTRUMENT_STATE["start_time"]=0
+CFN_INSTRUMENT_STATE["pid"]=0
+CFN_INSTRUMENT_STATE["timeout"]=0
+CFN_INSTRUMENT_STATE["log_prefix"]=""
 
-log_success() {
-    echo -e "${GREEN}[SUCCESS]${NC} $(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE"
-}
+# Default timeouts (seconds)
+readonly DEFAULT_TIMEOUT=300        # 5 minutes
+readonly MAX_TIMEOUT=3600           # 1 hour
+readonly WARNING_TIMEOUT=240        # 4 minutes
 
-log_error() {
-    echo -e "${RED}[ERROR]${NC} $(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE"
-}
+# Resource limits
+readonly MAX_MEMORY_MB=2048
+readonly MAX_CPU_PERCENT=80
 
-log_warning() {
-    echo -e "${YELLOW}[WARNING]${NC} $(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE"
-}
+##############################################################################
+# Core Instrumentation Functions
+##############################################################################
 
-# Process monitoring
-monitor_process() {
-    local pid="$1"
-    local timeout="$2"
-    local command_name="$3"
-    local log_file="$4"
+wrap_execution() {
+    local command="$1"
+    local timeout="${2:-$DEFAULT_TIMEOUT}"
+    local log_prefix="${3:-cfn-execution}"
 
-    local elapsed=0
-    while kill -0 "$pid" 2>/dev/null; do
-        if [[ $elapsed -ge $timeout ]]; then
-            log_warning "Process $pid ($command_name) exceeded timeout ${timeout}s, terminating..."
+    # Validate timeout
+    if (( timeout > MAX_TIMEOUT )); then
+        timeout=$MAX_TIMEOUT
+        echo "⚠️ Timeout capped at ${MAX_TIMEOUT}s" >&2
+    fi
 
-            # Get memory usage before termination
-            local memory_usage=$(ps -o rss= -p "$pid" 2>/dev/null | tr -d ' ' || echo "unknown")
-            log_error "Memory usage at termination: ${memory_usage}KB"
+    # Initialize instrumentation state
+    CFN_INSTRUMENT_STATE["active"]=true
+    CFN_INSTRUMENT_STATE["start_time"]=$(date +%s)
+    CFN_INSTRUMENT_STATE["timeout"]=$timeout
+    CFN_INSTRUMENT_STATE["log_prefix"]="$log_prefix"
 
-            # Terminate the process gracefully
-            kill -TERM "$pid" 2>/dev/null || true
-            sleep 5
+    echo "🔧 CFN Process Instrumentation v1.0.0" >&2
+    echo "   Command: $command" >&2
+    echo "   Timeout: ${timeout}s" >&2
+    echo "   PID: $$" >&2
+    echo "   Start: $(date -u +%Y-%m-%dT%H:%M:%SZ)" >&2
 
-            # Force kill if still running
-            if kill -0 "$pid" 2>/dev/null; then
-                log_error "Force killing process $pid ($command_name)"
-                kill -KILL "$pid" 2>/dev/null || true
-            fi
-
-            return 124  # Timeout exit code
-        fi
+    # Setup monitoring
+    setup_process_monitoring "$timeout" "$log_prefix"
 
-        # Log periodic status
-        if [[ $((elapsed % MONITOR_INTERVAL)) -eq 0 && $elapsed -gt 0 ]]; then
-            local memory_usage=$(ps -o rss= -p "$pid" 2>/dev/null | tr -d ' ' || echo "unknown")
-            log_info "Process $pid ($command_name) running: ${elapsed}s elapsed, ${memory_usage}KB memory"
-        fi
+    # Execute with instrumentation
+    local result
+    result=$(execute_with_monitoring "$command" "$timeout" "$log_prefix")
+    local exit_code=$?
 
-        sleep 1
-        ((elapsed++))
-    done
+    # Cleanup and report
+    cleanup_instrumentation "$exit_code"
 
-    return 0
+    return $exit_code
 }
 
-# Instrumented execution wrapper
-execute_instrumented() {
-    local command="$1"
-    local timeout="${2:-$DEFAULT_TIMEOUT}"
-    local memory_limit="${3:-$DEFAULT_MEMORY}"
-    shift 3
-    local args=("$@")
-
-    # Create log directory
-    mkdir -p "$LOG_DIR"
-
-    # Generate unique execution ID
-    local execution_id="exec_$(date +%Y%m%d_%H%M%S)_$$"
-    local log_file="$LOG_DIR/${execution_id}.log"
-    export LOG_FILE="$log_file"
-
-    # Extract command name for logging
-    local command_name=$(basename "$command")
-    local full_command="$command ${args[*]}"
-
-    # Start execution logging
-    log_info "=== Starting Instrumented Execution ==="
-    log_info "Execution ID: $execution_id"
-    log_info "Command: $full_command"
-    log_info "Timeout: ${timeout}s"
-    log_info "Memory Limit: ${memory_limit}MB"
-    log_info "Working Directory: $(pwd)"
-    log_info "Environment: CFN_MODE=${CFN_MODE:-unset}, NODE_OPTIONS=${NODE_OPTIONS:-unset}"
-
-    # Set up resource limits
-    local memory_limit_kb=$((memory_limit * 1024))
-
-    # Start the command with resource limits
-    local start_time=$(date +%s)
-    log_info "Starting process at $(date)"
-
-    # Launch command in background with resource limits
-    (
-        # Apply memory limit
-        ulimit -v "$memory_limit_kb" 2>/dev/null || {
-            log_warning "Could not set memory limit via ulimit"
-        }
-
-        # Apply Node.js specific memory limit
-        if [[ "$command_name" == "node" || "$command_name" == "bun" ]]; then
-            export NODE_OPTIONS="${NODE_OPTIONS:-} --max-old-space-size=$memory_limit"
-            log_info "Set NODE_OPTIONS: $NODE_OPTIONS"
-        fi
+setup_process_monitoring() {
+    local timeout="$1"
+    local log_prefix="$2"
 
-        # Execute the command
-        exec "$command" "${args[@]}" 2>&1
-    ) &
+    echo "   Setting up process monitoring..." >&2
 
-    local pid=$!
-    log_info "Process started with PID: $pid"
+    # Start resource monitoring in background
+    (
+        local monitor_interval=30  # Check every 30 seconds
+        local elapsed=0
 
-    # Start monitoring in background
-    monitor_process "$pid" "$timeout" "$command_name" "$log_file" &
-    local monitor_pid=$!
+        while (( elapsed < timeout )); do
+            sleep $monitor_interval
+            elapsed=$((elapsed + monitor_interval))
 
-    # Wait for command completion
-    local exit_code=0
-    if wait "$pid" 2>/dev/null; then
-        exit_code=$?
-        log_success "Process $pid ($command_name) completed successfully"
-    else
-        exit_code=$?
-        if [[ $exit_code -eq 124 ]]; then
-            log_error "Process $pid ($command_name) timed out after ${timeout}s"
-        else
-            log_error "Process $pid ($command_name) failed with exit code: $exit_code"
-        fi
-    fi
+            if [[ "${CFN_INSTRUMENT_STATE[active]}" == "true" ]]; then
+                check_resource_usage "$log_prefix" "$elapsed"
+            else
+                break
+            fi
+        done
 
-    # Stop monitoring
-    kill "$monitor_pid" 2>/dev/null || true
-    wait "$monitor_pid" 2>/dev/null || true
+        # Timeout warning
+        if [[ "${CFN_INSTRUMENT_STATE[active]}" == "true" ]]; then
+            echo "⚠️ [$log_prefix] Approaching timeout: ${elapsed}s" >&2
+        fi
+    ) &
 
-    # Calculate execution time
-    local end_time=$(date +%s)
-    local duration=$((end_time - start_time))
+    echo "   Resource monitoring started (interval: 30s)" >&2
+}
 
-    # Final status logging
-    log_info "=== Execution Summary ==="
-    log_info "Command: $full_command"
-    log_info "Exit Code: $exit_code"
-    log_info "Duration: ${duration}s"
-    log_info "Memory Limit: ${memory_limit}MB"
+check_resource_usage() {
+    local log_prefix="$1"
+    local elapsed="$2"
 
-    # Log resource usage summary if available
+    # Check memory usage
     if command -v ps >/dev/null 2>&1; then
-        local final_memory=$(ps -o rss= -p "$pid" 2>/dev/null | tr -d ' ' || echo "unknown")
-        log_info "Final Memory: ${final_memory}KB"
-    fi
+        local memory_mb=$(ps -o rss= -p $$ 2>/dev/null | awk '{print int($1/1024)}' || echo "0")
 
-    # Cleanup if process is still running
-    if kill -0 "$pid" 2>/dev/null; then
-        log_warning "Cleaning up still-running process $pid"
-        kill -TERM "$pid" 2>/dev/null || true
-        sleep 2
-        kill -KILL "$pid" 2>/dev/null || true
+        if (( memory_mb > MAX_MEMORY_MB )); then
+            echo "⚠️ [$log_prefix] High memory: ${memory_mb}MB (limit: ${MAX_MEMORY_MB}MB)" >&2
+        fi
     fi
 
-    # Archive log if successful
-    if [[ $exit_code -eq 0 ]]; then
-        local archive_log="$LOG_DIR/${execution_id}_success.log"
-        mv "$log_file" "$archive_log" 2>/dev/null || true
-        log_success "Log archived: $archive_log"
-    else
-        local archive_log="$LOG_DIR/${execution_id}_failed.log"
-        mv "$log_file" "$archive_log" 2>/dev/null || true
-        log_error "Failed log archived: $archive_log"
+    # Check CPU usage (basic check)
+    if command -v top >/dev/null 2>&1; then
+        local cpu_percent=$(top -b -n 1 -p $$ 2>/dev/null | awk 'NR>7 {print $9}' | head -1 || echo "0")
+
+        if (( $(echo "$cpu_percent > $MAX_CPU_PERCENT" | bc -l 2>/dev/null || echo "0") )); then
+            echo "⚠️ [$log_prefix] High CPU: ${cpu_percent}%" >&2
+        fi
     fi
 
-    return $exit_code
+    # Warning timeout check
+    if (( elapsed > WARNING_TIMEOUT )); then
+        echo "⏰ [$log_prefix] Long running: ${elapsed}s" >&2
+    fi
 }
 
-# Specific wrappers for common tools
-execute_node() {
-    local timeout="${1:-$DEFAULT_TIMEOUT}"
-    shift
-    log_info "Executing Node.js with instrumentation"
-    execute_instrumented "node" "$timeout" "$DEFAULT_MEMORY" "$@"
-}
+execute_with_monitoring() {
+    local command="$1"
+    local timeout="$2"
+    local log_prefix="$3"
 
-execute_bun() {
-    local timeout="${1:-$DEFAULT_TIMEOUT}"
-    shift
-    log_info "Executing Bun with instrumentation"
-    execute_instrumented "bun" "$timeout" "$DEFAULT_MEMORY" "$@"
-}
+    echo "   Executing: $command" >&2
 
-execute_playwright() {
-    local timeout="${1:-$DEFAULT_TIMEOUT}"
-    shift
-    # Playwright may need more memory
-    local playwright_memory="${CFN_PLAYWRIGHT_MEMORY:-4096}"
-    log_info "Executing Playwright with instrumentation"
-    execute_instrumented "npx" "$timeout" "$playwright_memory" "playwright" "$@"
-}
+    # Store command PID for monitoring
+    local child_pid
 
-execute_npx() {
-    local timeout="${1:-$DEFAULT_TIMEOUT}"
-    shift
-    log_info "Executing NPX with instrumentation"
-    execute_instrumented "npx" "$timeout" "$DEFAULT_MEMORY" "$@"
-}
+    # Execute command with timeout
+    if command -v timeout >/dev/null 2>&1; then
+        # Use system timeout if available
+        timeout "$timeout" bash -c "$command" &
+        child_pid=$!
+        CFN_INSTRUMENT_STATE["pid"]=$child_pid
 
-# Cleanup old logs
-cleanup_logs() {
-    local max_days="${CFN_LOG_RETENTION_DAYS:-7}"
-    log_info "Cleaning up logs older than $max_days days"
+        echo "   Process PID: $child_pid" >&2
 
-    find "$LOG_DIR" -name "*.log" -type f -mtime "+$max_days" -delete 2>/dev/null || true
-    log_info "Log cleanup completed"
-}
+        # Wait for completion with monitoring
+        local wait_result=0
+        while kill -0 $child_pid 2>/dev/null; do
+            sleep 5
 
-# Show usage
-show_usage() {
-    cat <<'EOF'
-CFN Validation Runner Instrumentation
+            # Check if we're approaching timeout
+            local elapsed=$(($(date +%s) - CFN_INSTRUMENT_STATE[start_time]))
+            if (( elapsed > timeout - 10 )); then
+                echo "⚠️ [$log_prefix] Approaching hard timeout, preparing graceful shutdown" >&2
+            fi
+        done
+
+        wait $child_pid
+        wait_result=$?
+
+    else
+        # Fallback without system timeout
+        echo "   Running without system timeout (not available)" >&2
+        bash -c "$command" &
+        child_pid=$!
+        CFN_INSTRUMENT_STATE["pid"]=$child_pid
+
+        # Basic wait (less safe)
+        wait $child_pid
+        wait_result=$?
+    fi
+
+    return $wait_result
+}
 
-USAGE:
-    source "$(dirname "${BASH_SOURCE[0]}")/wrapped-executor.sh"
+cleanup_instrumentation() {
+    local exit_code="$1"
+    local elapsed=$(($(date +%s) - CFN_INSTRUMENT_STATE[start_time]))
 
-    # Generic Execution
-    execute_instrumented <command> [timeout] [memory_limit] [args...]
+    echo "🧹 Process instrumentation cleanup" >&2
+    echo "   Exit code: $exit_code" >&2
+    echo "   Duration: ${elapsed}s" >&2
 
-    # Tool-Specific Wrappers
-    execute_node [timeout] [args...]           # Execute Node.js
-    execute_bun [timeout] [args...]            # Execute Bun
-    execute_playwright [timeout] [args...]     # Execute Playwright
-    execute_npx [timeout] [args...]            # Execute NPX
+    # Kill any remaining background processes
+    if [[ -n "${CFN_INSTRUMENT_STATE[pid]:-}" ]] && kill -0 "${CFN_INSTRUMENT_STATE[pid]}" 2>/dev/null; then
+        echo "   Terminating child process: ${CFN_INSTRUMENT_STATE[pid]}" >&2
+        kill -TERM "${CFN_INSTRUMENT_STATE[pid]}" 2>/dev/null || true
+        sleep 2
+        kill -KILL "${CFN_INSTRUMENT_STATE[pid]}" 2>/dev/null || true
+    fi
 
-    # Maintenance
-    cleanup_logs                               # Clean up old logs
+    # Clear state
+    CFN_INSTRUMENT_STATE["active"]=false
+    CFN_INSTRUMENT_STATE["pid"]=0
 
-ENVIRONMENT VARIABLES:
-    CFN_VALIDATION_TIMEOUT      # Default timeout in seconds (default: 300)
-    CFN_VALIDATION_MEMORY       # Default memory limit in MB (default: 2048)
-    CFN_VALIDATION_LOG_DIR      # Log directory (default: ./.claude/logs/validation)
-    CFN_MONITOR_INTERVAL        # Monitoring interval in seconds (default: 30)
-    CFN_PLAYWRIGHT_MEMORY       # Playwright memory limit in MB (default: 4096)
-    CFN_LOG_RETENTION_DAYS      # Log retention in days (default: 7)
+    echo "✅ Instrumentation cleanup complete" >&2
+}
 
-EXAMPLES:
-    # Execute Node.js script with default settings
-    execute_node validate.js
+##############################################################################
+# Utility Functions
+##############################################################################
+
+get_instrumentation_status() {
+    if [[ "${CFN_INSTRUMENT_STATE[active]}" == "true" ]]; then
+        local elapsed=$(($(date +%s) - CFN_INSTRUMENT_STATE[start_time]))
+        echo "CFN Instrumentation Status: ACTIVE"
+        echo "  PID: $$"
+        echo "  Child PID: ${CFN_INSTRUMENT_STATE[pid]}"
+        echo "  Elapsed: ${elapsed}s"
+        echo "  Timeout: ${CFN_INSTRUMENT_STATE[timeout]}s"
+        echo "  Log Prefix: ${CFN_INSTRUMENT_STATE[log_prefix]}"
+    else
+        echo "CFN Instrumentation Status: INACTIVE"
+    fi
+}
 
-    # Execute Bun with custom timeout
-    execute_bun 600 build.ts
+force_kill_execution() {
+    local signal="${1:-TERM}"
 
-    # Execute Playwright with longer timeout
-    execute_playwright 900 test.spec.js
+    if [[ "${CFN_INSTRUMENT_STATE[active]}" == "true" ]] && [[ -n "${CFN_INSTRUMENT_STATE[pid]:-}" ]]; then
+        echo "🚨 Force killing execution: ${CFN_INSTRUMENT_STATE[pid]} (signal: $signal)" >&2
+        kill -"$signal" "${CFN_INSTRUMENT_STATE[pid]}" 2>/dev/null || true
 
-    # Generic execution with custom memory limit
-    execute_instrumented custom-tool 300 4096 --arg1 --arg2
+        if [[ "$signal" == "TERM" ]]; then
+            sleep 2
+            if kill -0 "${CFN_INSTRUMENT_STATE[pid]}" 2>/dev/null; then
+                kill -KILL "${CFN_INSTRUMENT_STATE[pid]}" 2>/dev/null || true
+            fi
+        fi
+    fi
+}
 
-OUTPUT:
-    All executions generate detailed logs in ./.claude/logs/validation/
-    Logs include: start time, end time, memory usage, exit codes, timeouts
+##############################################################################
+# Signal Handlers
+##############################################################################
 
-EOF
+setup_signal_handlers() {
+    trap 'handle_instrumentation_signal INT' INT
+    trap 'handle_instrumentation_signal TERM' TERM
+    trap 'handle_instrumentation_signal HUP' HUP
 }
 
-# Main execution block
-if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
-    if [[ "$1" == "--help" || "$1" == "-h" ]]; then
-        show_usage
-        exit 0
+handle_instrumentation_signal() {
+    local signal="$1"
+    echo "🛑 Instrumentation received signal: $signal" >&2
+
+    if [[ "${CFN_INSTRUMENT_STATE[active]}" == "true" ]]; then
+        force_kill_execution TERM
+        cleanup_instrumentation 130
     fi
 
-    # Execute operation if provided
+    exit 130
+}
+
+##############################################################################
+# Auto-initialization
+##############################################################################
+
+# If script is sourced, make instrumentation available
+if [[ "${BASH_SOURCE[0]}" != "${0}" ]]; then
+    echo "🔧 CFN Process Instrumentation loaded" >&2
+    echo "   Use: wrap_execution <command> <timeout> <log_prefix>" >&2
+    setup_signal_handlers
+fi
+
+# If script is executed directly, show usage
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    echo "CFN Process Instrumentation v1.0.0"
+    echo ""
+    echo "Usage:"
+    echo "  source wrapped-executor.sh"
+    echo "  wrap_execution \"command\" timeout log_prefix"
+    echo ""
+    echo "Example:"
+    echo "  wrap_execution \"npx claude-flow-novice agent coder\" 300 \"agent-execution\""
+    echo ""
+
+    # Test run if arguments provided
     if [[ $# -gt 0 ]]; then
-        case "$1" in
-            "node")
-                shift
-                execute_node "$@"
-                ;;
-            "bun")
-                shift
-                execute_bun "$@"
-                ;;
-            "playwright")
-                shift
-                execute_playwright "$@"
-                ;;
-            "npx")
-                shift
-                execute_npx "$@"
-                ;;
-            "cleanup")
-                cleanup_logs
-                ;;
-            *)
-                echo "Unknown command: $1" >&2
-                echo "Use --help for usage information" >&2
-                exit 1
-                ;;
-        esac
-    else
-        echo "CFN Validation Runner Instrumentation" >&2
-        echo "Use --help for usage information" >&2
+        wrap_execution "$@"
     fi
 fi

package/dist/cli/agent-definition-parser.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/cli/agent-definition-parser.ts"],"sourcesContent":["/**\r\n * Agent Definition Parser\r\n *\r\n * Parses agent definition files (.md) with YAML frontmatter and markdown content.\r\n * Supports agent definitions in .claude/agents/ directory structure.\r\n */\r\n\r\nimport fs from 'fs/promises';\r\nimport path from 'path';\r\nimport { glob } from 'glob';\r\n\r\nexport interface AgentDefinition {\r\n  // YAML frontmatter fields\r\n  name: string;\r\n  description: string;\r\n  tools: string[];\r\n  model: 'haiku' | 'sonnet' | 'opus';\r\n  type?: string;\r\n  color?: string;\r\n  acl_level?: number;\r\n  capabilities?: string[];\r\n  validation_hooks?: string[];\r\n  lifecycle?: {\r\n    pre_task?: string;\r\n    post_task?: string;\r\n  };\r\n\r\n  // Parsed markdown content\r\n  content: string;\r\n\r\n  // File metadata\r\n  filePath: string;\r\n  category?: string; // e.g., 'core-agents', 'specialized', 'custom'\r\n}\r\n\r\n/**\r\n * Parse YAML frontmatter from markdown content\r\n */\r\nfunction parseFrontmatter(content: string): { frontmatter: Record<string, any>; body: string } {\r\n  const frontmatterRegex = /^---\\n([\\s\\S]*?)\\n---\\n([\\s\\S]*)$/;\r\n  const match = content.match(frontmatterRegex);\r\n\r\n  if (!match) {\r\n    return { frontmatter: {}, body: content };\r\n  }\r\n\r\n  const [, yamlContent, body] = match;\r\n\r\n  // Simple YAML parser (handles basic key-value pairs, arrays, and objects)\r\n  const frontmatter: Record<string, any> = {};\r\n  const lines = yamlContent.split('\\n');\r\n  let currentKey = '';\r\n  let currentArray: string[] = [];\r\n  let isInArray = false;\r\n  let isInObject = false;\r\n  let currentObject: Record<string, string> = {};\r\n  let objectKey = '';\r\n\r\n  for (const line of lines) {\r\n    const trimmed = line.trim();\r\n    if (!trimmed || trimmed.startsWith('#')) continue;\r\n\r\n    // Array item\r\n    if (trimmed.startsWith('- ')) {\r\n      if (!isInArray) {\r\n        isInArray = true;\r\n        currentArray = [];\r\n      }\r\n      currentArray.push(trimmed.substring(2).trim());\r\n      continue;\r\n    }\r\n\r\n    // End of array\r\n    if (isInArray && !trimmed.startsWith('- ')) {\r\n      frontmatter[currentKey] = currentArray;\r\n      isInArray = false;\r\n      currentArray = [];\r\n    }\r\n\r\n    // Object field (indented key-value)\r\n    if (trimmed.match(/^\\s+\\w+:/) && isInObject) {\r\n      const [objKey, ...objValueParts] = trimmed.split(':');\r\n      const objValue = objValueParts.join(':').trim().replace(/^[\"']|[\"']$/g, '');\r\n      currentObject[objKey.trim()] = objValue;\r\n      continue;\r\n    }\r\n\r\n    // Key-value pair\r\n    const colonIndex = trimmed.indexOf(':');\r\n    if (colonIndex !== -1) {\r\n      const key = trimmed.substring(0, colonIndex).trim();\r\n      const value = trimmed.substring(colonIndex + 1).trim();\r\n\r\n      // Check if this starts an object\r\n      if (value === '') {\r\n        isInObject = true;\r\n        currentObject = {};\r\n        objectKey = key;\r\n        continue;\r\n      }\r\n\r\n      // End previous object if any\r\n      if (isInObject && !trimmed.match(/^\\s+/)) {\r\n        frontmatter[objectKey] = currentObject;\r\n        isInObject = false;\r\n        currentObject = {};\r\n      }\r\n\r\n      currentKey = key;\r\n\r\n      // Multi-line string (starts with |)\r\n      if (value === '|') {\r\n        continue; // Will be handled by next lines\r\n      }\r\n\r\n      // Inline array (e.g., [item1, item2, item3])\r\n      if (value.startsWith('[') && value.endsWith(']')) {\r\n        const arrayContent = value.substring(1, value.length - 1);\r\n        const items = arrayContent.split(',').map(item => item.trim());\r\n        frontmatter[key] = items;\r\n        continue;\r\n      }\r\n\r\n      // Remove quotes\r\n      const cleanValue = value.replace(/^[\"']|[\"']$/g, '');\r\n      frontmatter[key] = cleanValue;\r\n    } else if (currentKey && trimmed && !isInArray && !isInObject) {\r\n      // Continuation of multi-line string\r\n      const existingValue = frontmatter[currentKey];\r\n      frontmatter[currentKey] = existingValue\r\n        ? `${existingValue}\\n${trimmed}`\r\n        : trimmed;\r\n    }\r\n  }\r\n\r\n  // Handle trailing array or object\r\n  if (isInArray) {\r\n    frontmatter[currentKey] = currentArray;\r\n  }\r\n  if (isInObject) {\r\n    frontmatter[objectKey] = currentObject;\r\n  }\r\n\r\n  return { frontmatter, body: body.trim() };\r\n}\r\n\r\n/**\r\n * Find agent definition file by agent type/name\r\n */\r\nasync function findAgentFile(agentType: string, baseDir: string = '.claude/agents'): Promise<string | null> {\r\n  // Normalize agent type (handle both kebab-case and underscores)\r\n  const normalizedType = agentType.toLowerCase().replace(/_/g, '-');\r\n\r\n  // Search patterns (in order of priority)\r\n  const patterns = [\r\n    // Exact match in any subdirectory\r\n    `${baseDir}/**/${normalizedType}.md`,\r\n    // Match with different casing\r\n    `${baseDir}/**/*${normalizedType}*.md`,\r\n  ];\r\n\r\n  for (const pattern of patterns) {\r\n    const files = await glob(pattern, { nodir: true, absolute: true });\r\n    if (files.length > 0) {\r\n      // Prefer exact match over partial match\r\n      const exactMatch = files.find(f => {\r\n        const basename = path.basename(f, '.md').toLowerCase();\r\n        return basename === normalizedType;\r\n      });\r\n      return exactMatch || files[0];\r\n    }\r\n  }\r\n\r\n  return null;\r\n}\r\n\r\n/**\r\n * Parse agent definition from file\r\n */\r\nexport async function parseAgentDefinition(agentType: string): Promise<AgentDefinition> {\r\n  // Find agent file\r\n  const filePath = await findAgentFile(agentType);\r\n\r\n  if (!filePath) {\r\n    throw new Error(`Agent definition not found: ${agentType}`);\r\n  }\r\n\r\n  // Read file content\r\n  const content = await fs.readFile(filePath, 'utf-8');\r\n\r\n  // Parse frontmatter and body\r\n  const { frontmatter, body } = parseFrontmatter(content);\r\n\r\n  // Extract category from path\r\n  const relativePath = path.relative('.claude/agents', filePath);\r\n  const category = relativePath.includes('/')\r\n    ? relativePath.split('/')[0]\r\n    : undefined;\r\n\r\n  // Build agent definition\r\n  const definition: AgentDefinition = {\r\n    name: frontmatter.name || agentType,\r\n    description: frontmatter.description || '',\r\n    tools: Array.isArray(frontmatter.tools) ? frontmatter.tools : [],\r\n    model: frontmatter.model || 'haiku',\r\n    type: frontmatter.type,\r\n    color: frontmatter.color,\r\n    acl_level: frontmatter.acl_level ? parseInt(String(frontmatter.acl_level), 10) : undefined,\r\n    capabilities: frontmatter.capabilities,\r\n    validation_hooks: frontmatter.validation_hooks,\r\n    lifecycle: frontmatter.lifecycle,\r\n    content: body,\r\n    filePath,\r\n    category,\r\n  };\r\n\r\n  return definition;\r\n}\r\n\r\n/**\r\n * List all available agent definitions\r\n */\r\nexport async function listAgentDefinitions(baseDir: string = '.claude/agents'): Promise<string[]> {\r\n  const pattern = `${baseDir}/**/*.md`;\r\n  const files = await glob(pattern, { nodir: true });\r\n\r\n  return files.map(f => path.basename(f, '.md'));\r\n}\r\n\r\n/**\r\n * Check if agent definition includes CFN Loop protocol\r\n */\r\nexport function hasCFNLoopProtocol(definition: AgentDefinition): boolean {\r\n  const content = definition.content.toLowerCase();\r\n  return (\r\n    content.includes('cfn loop') &&\r\n    content.includes('redis completion protocol') ||\r\n    content.includes('invoke-waiting-mode.sh')\r\n  );\r\n}\r\n"],"names":["fs","path","glob","parseFrontmatter","content","frontmatterRegex","match","frontmatter","body","yamlContent","lines","split","currentKey","currentArray","isInArray","isInObject","currentObject","objectKey","line","trimmed","trim","startsWith","push","substring","objKey","objValueParts","objValue","join","replace","colonIndex","indexOf","key","value","endsWith","arrayContent","length","items","map","item","cleanValue","existingValue","findAgentFile","agentType","baseDir","normalizedType","toLowerCase","patterns","pattern","files","nodir","absolute","exactMatch","find","f","basename","parseAgentDefinition","filePath","Error","readFile","relativePath","relative","category","includes","undefined","definition","name","description","tools","Array","isArray","model","type","color","acl_level","parseInt","String","capabilities","validation_hooks","lifecycle","listAgentDefinitions","hasCFNLoopProtocol"],"mappings":"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"}
+{"version":3,"sources":["../../src/cli/agent-definition-parser.ts"],"sourcesContent":["/**\r\n * Agent Definition Parser\r\n *\r\n * Parses agent definition files (.md) with YAML frontmatter and markdown content.\r\n * Supports agent definitions in .claude/agents/ directory structure.\r\n */\r\n\r\nimport fs from 'fs/promises';\r\nimport path from 'path';\r\nimport { glob } from 'glob';\r\n\r\nexport interface AgentDefinition {\r\n  // YAML frontmatter fields\r\n  name: string;\r\n  description: string;\r\n  tools: string[];\r\n  model: 'haiku' | 'sonnet' | 'opus';\r\n  type?: string;\r\n  color?: string;\r\n  acl_level?: number;\r\n  capabilities?: string[];\r\n  validation_hooks?: string[];\r\n  lifecycle?: {\r\n    pre_task?: string;\r\n    post_task?: string;\r\n  };\r\n\r\n  // Parsed markdown content\r\n  content: string;\r\n\r\n  // File metadata\r\n  filePath: string;\r\n  category?: string; // e.g., 'core-agents', 'specialized', 'custom'\r\n}\r\n\r\n/**\r\n * Parse YAML frontmatter from markdown content\r\n */\r\nfunction parseFrontmatter(content: string): { frontmatter: Record<string, any>; body: string } {\r\n  const frontmatterRegex = /^---\\n([\\s\\S]*?)\\n---\\n([\\s\\S]*)$/;\r\n  const match = content.match(frontmatterRegex);\r\n\r\n  if (!match) {\r\n    return { frontmatter: {}, body: content };\r\n  }\r\n\r\n  const [, yamlContent, body] = match;\r\n\r\n  \r\n  // Simple YAML parser (handles basic key-value pairs, arrays, and objects)\r\n  const frontmatter: Record<string, any> = {};\r\n  const lines = yamlContent.split('\\n');\r\n  let currentKey = '';\r\n  let currentArray: string[] = [];\r\n  let isInArray = false;\r\n  let isInObject = false;\r\n  let currentObject: Record<string, string> = {};\r\n  let objectKey = '';\r\n\r\n  for (const line of lines) {\r\n    const trimmed = line.trim();\r\n    if (!trimmed || trimmed.startsWith('#')) continue;\r\n\r\n    // Array item\r\n    if (trimmed.startsWith('- ')) {\r\n      if (!isInArray) {\r\n        isInArray = true;\r\n        currentArray = [];\r\n      }\r\n      currentArray.push(trimmed.substring(2).trim());\r\n      continue;\r\n    }\r\n\r\n    // End of array\r\n    if (isInArray && !trimmed.startsWith('- ')) {\r\n      frontmatter[currentKey] = currentArray;\r\n      isInArray = false;\r\n      currentArray = [];\r\n    }\r\n\r\n    // Object field (indented key-value)\r\n    if (trimmed.match(/^\\s+\\w+:/) && isInObject) {\r\n      const [objKey, ...objValueParts] = trimmed.split(':');\r\n      const objValue = objValueParts.join(':').trim().replace(/^[\"']|[\"']$/g, '');\r\n      currentObject[objKey.trim()] = objValue;\r\n      continue;\r\n    }\r\n\r\n    // Key-value pair\r\n    const colonIndex = trimmed.indexOf(':');\r\n    if (colonIndex !== -1) {\r\n      const key = trimmed.substring(0, colonIndex).trim();\r\n      const value = trimmed.substring(colonIndex + 1).trim();\r\n\r\n      // Check if this starts an object\r\n      if (value === '') {\r\n        isInObject = true;\r\n        currentObject = {};\r\n        objectKey = key;\r\n        continue;\r\n      }\r\n\r\n      // End previous object if any\r\n      if (isInObject && !trimmed.match(/^\\s+/)) {\r\n        frontmatter[objectKey] = currentObject;\r\n        isInObject = false;\r\n        currentObject = {};\r\n      }\r\n\r\n      currentKey = key;\r\n\r\n      // Multi-line string (starts with |)\r\n      if (value === '|') {\r\n        continue; // Will be handled by next lines\r\n      }\r\n\r\n      // Inline array (e.g., [item1, item2, item3])\r\n      if (value.startsWith('[') && value.endsWith(']')) {\r\n        const arrayContent = value.substring(1, value.length - 1);\r\n        const items = arrayContent.split(',').map(item => item.trim());\r\n        frontmatter[key] = items;\r\n        continue;\r\n      }\r\n\r\n      // Remove quotes\r\n      const cleanValue = value.replace(/^[\"']|[\"']$/g, '');\r\n      frontmatter[key] = cleanValue;\r\n    } else if (currentKey && trimmed && !isInArray && !isInObject) {\r\n      // Continuation of multi-line string\r\n      const existingValue = frontmatter[currentKey];\r\n      frontmatter[currentKey] = existingValue\r\n        ? `${existingValue}\\n${trimmed}`\r\n        : trimmed;\r\n    }\r\n  }\r\n\r\n  // Handle trailing array or object\r\n  if (isInArray) {\r\n    frontmatter[currentKey] = currentArray;\r\n  }\r\n  if (isInObject) {\r\n    frontmatter[objectKey] = currentObject;\r\n  }\r\n\r\n  return { frontmatter, body: body.trim() };\r\n}\r\n\r\n/**\r\n * Find agent definition file by agent type/name\r\n */\r\nasync function findAgentFile(agentType: string, baseDir: string = '.claude/agents'): Promise<string | null> {\r\n  // Normalize agent type (handle both kebab-case and underscores)\r\n  const normalizedType = agentType.toLowerCase().replace(/_/g, '-');\r\n\r\n  // Search patterns (in order of priority)\r\n  const patterns = [\r\n    // Exact match in any subdirectory\r\n    `${baseDir}/**/${normalizedType}.md`,\r\n    // Match with different casing\r\n    `${baseDir}/**/*${normalizedType}*.md`,\r\n  ];\r\n\r\n  for (const pattern of patterns) {\r\n    const files = await glob(pattern, { nodir: true, absolute: true });\r\n    if (files.length > 0) {\r\n      // Prefer exact match over partial match\r\n      const exactMatch = files.find(f => {\r\n        const basename = path.basename(f, '.md').toLowerCase();\r\n        return basename === normalizedType;\r\n      });\r\n      return exactMatch || files[0];\r\n    }\r\n  }\r\n\r\n  return null;\r\n}\r\n\r\n/**\r\n * Parse agent definition from file\r\n */\r\nexport async function parseAgentDefinition(agentType: string): Promise<AgentDefinition> {\r\n  // Find agent file\r\n  const filePath = await findAgentFile(agentType);\r\n\r\n  if (!filePath) {\r\n    throw new Error(`Agent definition not found: ${agentType}`);\r\n  }\r\n\r\n  // Read file content\r\n  const content = await fs.readFile(filePath, 'utf-8');\r\n\r\n  \r\n  // Parse frontmatter and body\r\n  const { frontmatter, body } = parseFrontmatter(content);\r\n\r\n  // Extract category from path\r\n  const relativePath = path.relative('.claude/agents', filePath);\r\n  const category = relativePath.includes('/')\r\n    ? relativePath.split('/')[0]\r\n    : undefined;\r\n\r\n  \r\n  // Build agent definition\r\n  const definition: AgentDefinition = {\r\n    name: frontmatter.name || agentType,\r\n    description: frontmatter.description || '',\r\n    tools: Array.isArray(frontmatter.tools) ? frontmatter.tools : [],\r\n    model: frontmatter.model || 'haiku',\r\n    type: frontmatter.type,\r\n    color: frontmatter.color,\r\n    acl_level: frontmatter.acl_level ? parseInt(String(frontmatter.acl_level), 10) : undefined,\r\n    capabilities: frontmatter.capabilities,\r\n    validation_hooks: frontmatter.validation_hooks,\r\n    lifecycle: frontmatter.lifecycle,\r\n    content: body,\r\n    filePath,\r\n    category,\r\n  };\r\n\r\n  return definition;\r\n}\r\n\r\n/**\r\n * List all available agent definitions\r\n */\r\nexport async function listAgentDefinitions(baseDir: string = '.claude/agents'): Promise<string[]> {\r\n  const pattern = `${baseDir}/**/*.md`;\r\n  const files = await glob(pattern, { nodir: true });\r\n\r\n  return files.map(f => path.basename(f, '.md'));\r\n}\r\n\r\n/**\r\n * Check if agent definition includes CFN Loop protocol\r\n */\r\nexport function hasCFNLoopProtocol(definition: AgentDefinition): boolean {\r\n  const content = definition.content.toLowerCase();\r\n  return (\r\n    content.includes('cfn loop') &&\r\n    content.includes('redis completion protocol') ||\r\n    content.includes('invoke-waiting-mode.sh')\r\n  );\r\n}\r\n"],"names":["fs","path","glob","parseFrontmatter","content","frontmatterRegex","match","frontmatter","body","yamlContent","lines","split","currentKey","currentArray","isInArray","isInObject","currentObject","objectKey","line","trimmed","trim","startsWith","push","substring","objKey","objValueParts","objValue","join","replace","colonIndex","indexOf","key","value","endsWith","arrayContent","length","items","map","item","cleanValue","existingValue","findAgentFile","agentType","baseDir","normalizedType","toLowerCase","patterns","pattern","files","nodir","absolute","exactMatch","find","f","basename","parseAgentDefinition","filePath","Error","readFile","relativePath","relative","category","includes","undefined","definition","name","description","tools","Array","isArray","model","type","color","acl_level","parseInt","String","capabilities","validation_hooks","lifecycle","listAgentDefinitions","hasCFNLoopProtocol"],"mappings":"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"}