claude-flow-novice 2.10.7 → 2.10.9

package/claude-assets/skills/cfn-agent-spawning/spawn-worker.sh

@@ -0,0 +1,176 @@
+#!/bin/bash
+set -eu
+
+# Get the project root directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+
+# Load team providers configuration
+PROVIDERS_CONFIG="${PROJECT_ROOT}/.claude/cfn-config/team-providers.json"
+
+# Validate configuration file exists
+if [[ ! -f "$PROVIDERS_CONFIG" ]]; then
+    echo "Error: Team providers configuration not found at $PROVIDERS_CONFIG"
+    exit 1
+fi
+
+# Function to validate provider configuration
+validate_provider_config() {
+    local team="$1"
+    local role="$2"  # coordinator or workers
+
+    # Use jq to validate JSON structure and extract provider details
+    if ! jq -e ".teams.${team}.${role}" "$PROVIDERS_CONFIG" &>/dev/null; then
+        echo "Error: Invalid or missing provider configuration for team=${team}, role=${role}"
+        exit 1
+    fi
+}
+
+# Function to select appropriate model based on complexity
+select_model() {
+    local team="$1"
+    local complexity="$2"  # simple or complex
+
+    # Retrieve model based on complexity and team configuration
+    local model=$(jq -r ".teams.${team}.workers.models.${complexity}" "$PROVIDERS_CONFIG")
+
+    if [[ "$model" == "null" ]]; then
+        # Fallback to default complexity from global config
+        local default_complexity=$(jq -r ".global_config.default_complexity // \"simple\"" "$PROVIDERS_CONFIG")
+        model=$(jq -r ".teams.${team}.workers.models.${default_complexity}" "$PROVIDERS_CONFIG")
+    fi
+
+    echo "$model"
+}
+
+# Function to get API key from environment
+get_api_key() {
+    local team="$1"
+    local role="$2"  # coordinator or workers
+
+    # Extract apiKeyEnvVar from config
+    local api_key_env_var=$(jq -r ".teams.${team}.${role}.apiKeyEnvVar" "$PROVIDERS_CONFIG")
+
+    if [[ "$api_key_env_var" == "null" ]]; then
+        echo "Error: apiKeyEnvVar not found for team=${team}, role=${role}"
+        exit 1
+    fi
+
+    # Get actual API key value from environment
+    local api_key_value="${!api_key_env_var:-}"
+
+    if [[ -z "$api_key_value" ]]; then
+        echo "Error: API key not found in environment variable: $api_key_env_var"
+        exit 1
+    fi
+
+    echo "$api_key_value"
+}
+
+# Main worker spawning logic
+spawn_worker() {
+    local team="$1"
+    local complexity="${2:-simple}"
+    local provider_mode="${3:-auto}"
+    local agent_type="${4:-}"
+    local task_context="${5:-}"
+
+    # Validate input parameters
+    validate_provider_config "$team" "workers"
+
+    # Retrieve provider details from config
+    local provider=$(jq -r ".teams.${team}.workers.provider" "$PROVIDERS_CONFIG")
+    local api_key_env_var=$(jq -r ".teams.${team}.workers.apiKeyEnvVar" "$PROVIDERS_CONFIG")
+    local base_url=$(jq -r ".teams.${team}.workers.baseUrl" "$PROVIDERS_CONFIG")
+
+    # Select model dynamically based on complexity
+    local model=$(select_model "$team" "$complexity")
+
+    # Get API key from environment
+    local api_key=$(get_api_key "$team" "workers")
+
+    # Provider routing logic
+    case "$provider_mode" in
+        auto)
+            # Use provider routing rules from config
+            case "$provider" in
+                zai)
+                    echo "Spawning Z.ai worker for team ${team} (Model: ${model}, Complexity: ${complexity})"
+
+                    # Set environment variables for Z.ai spawning
+                    export ZAI_API_KEY="$api_key"
+                    export ZAI_BASE_URL="$base_url"
+                    export ZAI_MODEL="$model"
+
+                    # Call actual spawning logic (to be implemented)
+                    # npx claude-flow-novice spawn "$agent_type" \
+                    #   --provider zai \
+                    #   --model "$model" \
+                    #   --context "$task_context"
+                    ;;
+                anthropic)
+                    echo "Spawning Anthropic worker for team ${team} (Model: ${model}, Complexity: ${complexity})"
+
+                    # Set environment variables for Anthropic spawning
+                    export ANTHROPIC_API_KEY="$api_key"
+                    export ANTHROPIC_BASE_URL="$base_url"
+                    export ANTHROPIC_MODEL="$model"
+
+                    # Call actual spawning logic (to be implemented)
+                    # npx claude-flow-novice spawn "$agent_type" \
+                    #   --provider anthropic \
+                    #   --model "$model" \
+                    #   --context "$task_context"
+                    ;;
+                *)
+                    echo "Error: Unsupported provider: ${provider}"
+                    exit 1
+                    ;;
+            esac
+            ;;
+        zai)
+            echo "Force spawning Z.ai worker for team ${team} (Model: ${model})"
+            local api_key=$(get_api_key "$team" "workers")
+            export ZAI_API_KEY="$api_key"
+            export ZAI_BASE_URL="$base_url"
+            export ZAI_MODEL="$model"
+            ;;
+        anthropic)
+            echo "Force spawning Anthropic worker for team ${team} (Model: ${model})"
+            local api_key=$(get_api_key "$team" "workers")
+            export ANTHROPIC_API_KEY="$api_key"
+            export ANTHROPIC_BASE_URL="$base_url"
+            export ANTHROPIC_MODEL="$model"
+            ;;
+        *)
+            echo "Error: Invalid provider mode: ${provider_mode}"
+            exit 1
+            ;;
+    esac
+
+    # Log successful configuration
+    echo "Worker configuration complete:"
+    echo "  Team: $team"
+    echo "  Provider: $provider"
+    echo "  Model: $model"
+    echo "  Base URL: $base_url"
+    echo "  Complexity: $complexity"
+}
+
+# Allow script to be used as a function or executed directly
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    # Script is being run directly
+    if [[ $# -lt 1 ]]; then
+        echo "Usage: $0 <team> [complexity] [provider_mode] [agent_type] [task_context]"
+        echo ""
+        echo "Arguments:"
+        echo "  team           - Team name (marketing, engineering, sales, support, finance)"
+        echo "  complexity     - simple|complex (default: simple)"
+        echo "  provider_mode  - auto|zai|anthropic (default: auto)"
+        echo "  agent_type     - Agent type to spawn (optional)"
+        echo "  task_context   - Task context for agent (optional)"
+        exit 1
+    fi
+
+    spawn_worker "$@"
+fi

package/claude-assets/skills/pre-edit-backup/backup.sh

@@ -0,0 +1,130 @@
+#!/bin/bash
+
+# Pre-Edit Backup Script
+# Creates timestamped backup with SHA-256 hash and JSON metadata
+#
+# Usage: backup.sh FILE_PATH AGENT_ID
+#
+# Arguments:
+#   FILE_PATH  - Absolute path to file to backup
+#   AGENT_ID   - Unique identifier for the agent creating the backup
+#
+# Returns:
+#   Backup directory path on success
+#   Exit code 1 on failure
+#
+# Example:
+#   ./.claude/skills/pre-edit-backup/backup.sh "/path/to/file.txt" "backend-dev-1"
+
+set -euo pipefail
+
+# === Input Validation ===
+
+FILE_PATH="$1"
+AGENT_ID="$2"
+
+if [[ -z "$FILE_PATH" ]]; then
+    echo "Error: No file path provided" >&2
+    echo "Usage: backup.sh FILE_PATH AGENT_ID" >&2
+    exit 1
+fi
+
+if [[ -z "$AGENT_ID" ]]; then
+    echo "Error: No agent ID provided" >&2
+    echo "Usage: backup.sh FILE_PATH AGENT_ID" >&2
+    exit 1
+fi
+
+if [[ ! -f "$FILE_PATH" ]]; then
+    echo "Error: File does not exist: $FILE_PATH" >&2
+    exit 1
+fi
+
+# === Configuration ===
+
+BACKUP_BASE_DIR=".backups"
+DEFAULT_TTL=86400  # 24 hours in seconds
+
+# === Tool Availability Checks ===
+
+# Check for sha256sum (with fallback to shasum on macOS)
+if command -v sha256sum &>/dev/null; then
+    HASH_TOOL="sha256sum"
+elif command -v shasum &>/dev/null; then
+    HASH_TOOL="shasum -a 256"
+else
+    echo "Error: Neither sha256sum nor shasum found. Cannot generate file hash." >&2
+    exit 1
+fi
+
+# Check for jq (graceful degradation)
+if ! command -v jq &>/dev/null; then
+    echo "Warning: jq not found. Metadata will be created using basic shell." >&2
+    USE_JQ=false
+else
+    USE_JQ=true
+fi
+
+# === Generate Backup Metadata ===
+
+TIMESTAMP=$(date +%s%3N 2>/dev/null || date +%s)  # Milliseconds if supported, else seconds
+FILE_HASH=$($HASH_TOOL "$FILE_PATH" | cut -d' ' -f1)
+
+# === Create Backup Directory ===
+
+BACKUP_DIR="${BACKUP_BASE_DIR}/${AGENT_ID}/${TIMESTAMP}_${FILE_HASH}"
+
+if ! mkdir -p "$BACKUP_DIR" 2>/dev/null; then
+    echo "Error: Failed to create backup directory: $BACKUP_DIR" >&2
+    exit 1
+fi
+
+# Set secure permissions (owner read/write/execute only)
+chmod 700 "$BACKUP_DIR" 2>/dev/null || true
+
+# === Copy Original File ===
+
+if ! cp "$FILE_PATH" "${BACKUP_DIR}/original_file" 2>/dev/null; then
+    echo "Error: Failed to copy file to backup directory" >&2
+    rm -rf "$BACKUP_DIR"
+    exit 1
+fi
+
+# === Generate Metadata ===
+
+METADATA_FILE="${BACKUP_DIR}/backup_metadata.json"
+
+if [[ "$USE_JQ" == true ]]; then
+    # Use jq for structured JSON generation
+    jq -n \
+        --arg agent_id "$AGENT_ID" \
+        --arg original_path "$FILE_PATH" \
+        --arg timestamp "$TIMESTAMP" \
+        --arg file_hash "$FILE_HASH" \
+        --arg ttl "$DEFAULT_TTL" \
+        '{
+            agent_id: $agent_id,
+            original_path: $original_path,
+            backup_timestamp: ($timestamp | tonumber),
+            file_hash: $file_hash,
+            backup_ttl: ($ttl | tonumber),
+            backup_status: "active"
+        }' > "$METADATA_FILE"
+else
+    # Fallback: Manual JSON generation
+    cat > "$METADATA_FILE" <<EOF
+{
+    "agent_id": "$AGENT_ID",
+    "original_path": "$FILE_PATH",
+    "backup_timestamp": $TIMESTAMP,
+    "file_hash": "$FILE_HASH",
+    "backup_ttl": $DEFAULT_TTL,
+    "backup_status": "active"
+}
+EOF
+fi
+
+# === Return Backup Path ===
+
+echo "$BACKUP_DIR"
+exit 0

package/claude-assets/skills/pre-edit-backup/cleanup.sh

@@ -0,0 +1,155 @@
+#!/bin/bash
+
+# Pre-Edit Backup Cleanup Script
+# Removes expired backups based on TTL configuration
+# Runs as background process or cron-style with flock for concurrency control
+#
+# Usage: cleanup.sh [--dry-run] [--log-file FILE]
+#
+# Options:
+#   --dry-run    - Show what would be deleted without actually deleting
+#   --log-file   - Path to log file (default: none, outputs to stdout)
+#
+# Returns:
+#   Exit code 0 on success
+#   Exit code 1 if cleanup already in progress
+#
+# Example:
+#   ./.claude/skills/pre-edit-backup/cleanup.sh
+#   ./.claude/skills/pre-edit-backup/cleanup.sh --dry-run
+#   ./.claude/skills/pre-edit-backup/cleanup.sh --log-file /tmp/backup-cleanup.log
+
+set -euo pipefail
+
+# === Configuration ===
+
+BACKUP_BASE_DIR=".backups"
+CURRENT_TIME=$(date +%s)
+DRY_RUN=false
+LOG_FILE=""
+
+# === Parse Options ===
+
+while [[ "$#" -gt 0 ]]; do
+    case $1 in
+        --dry-run)
+            DRY_RUN=true
+            shift
+            ;;
+        --log-file)
+            LOG_FILE="$2"
+            shift 2
+            ;;
+        *)
+            echo "Error: Unknown option: $1" >&2
+            echo "Usage: cleanup.sh [--dry-run] [--log-file FILE]" >&2
+            exit 1
+            ;;
+    esac
+done
+
+# === Logging Function ===
+
+log() {
+    local message="$1"
+    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
+    local log_line="[$timestamp] $message"
+
+    if [[ -n "$LOG_FILE" ]]; then
+        echo "$log_line" >> "$LOG_FILE"
+    else
+        echo "$log_line"
+    fi
+}
+
+# === Prevent Concurrent Cleanup ===
+
+if [[ ! -d "$BACKUP_BASE_DIR" ]]; then
+    log "Backup directory does not exist: $BACKUP_BASE_DIR"
+    exit 0
+fi
+
+LOCKFILE="${BACKUP_BASE_DIR}/cleanup.lock"
+
+# Ensure lock file directory exists
+mkdir -p "$(dirname "$LOCKFILE")" 2>/dev/null || true
+
+# Acquire lock (non-blocking)
+exec 9>"$LOCKFILE"
+if ! flock -n 9; then
+    log "Cleanup already in progress (lock held)"
+    exit 1
+fi
+
+log "Cleanup started (dry-run: $DRY_RUN)"
+
+# === Cleanup Logic ===
+
+REMOVED_COUNT=0
+SKIPPED_COUNT=0
+ERROR_COUNT=0
+
+# Check for jq availability
+if ! command -v jq &>/dev/null; then
+    log "Error: jq is required for cleanup operations"
+    exit 1
+fi
+
+# Iterate through agent directories
+for agent_dir in "$BACKUP_BASE_DIR"/*; do
+    # Skip if not a directory or if it's the lockfile
+    [[ -d "$agent_dir" ]] || continue
+    [[ "$(basename "$agent_dir")" == "cleanup.lock" ]] && continue
+
+    # Iterate through backup directories for this agent
+    for backup_dir in "$agent_dir"/*; do
+        [[ -d "$backup_dir" ]] || continue
+
+        metadata_file="${backup_dir}/backup_metadata.json"
+
+        if [[ ! -f "$metadata_file" ]]; then
+            log "Warning: Metadata missing for backup: ${backup_dir}"
+            SKIPPED_COUNT=$((SKIPPED_COUNT + 1))
+            continue
+        fi
+
+        # Extract backup timestamp and TTL
+        backup_timestamp=$(jq -r '.backup_timestamp' "$metadata_file" 2>/dev/null || echo "")
+        backup_ttl=$(jq -r '.backup_ttl' "$metadata_file" 2>/dev/null || echo "")
+
+        if [[ -z "$backup_timestamp" ]] || [[ "$backup_timestamp" == "null" ]] || \
+           [[ -z "$backup_ttl" ]] || [[ "$backup_ttl" == "null" ]]; then
+            log "Warning: Invalid metadata in: ${metadata_file}"
+            SKIPPED_COUNT=$((SKIPPED_COUNT + 1))
+            continue
+        fi
+
+        # Convert milliseconds to seconds if needed (timestamp > 10 digits = milliseconds)
+        if [[ ${#backup_timestamp} -gt 10 ]]; then
+            backup_timestamp=$((backup_timestamp / 1000))
+        fi
+
+        # Check if backup has expired
+        age=$((CURRENT_TIME - backup_timestamp))
+        if (( age > backup_ttl )); then
+            if [[ "$DRY_RUN" == true ]]; then
+                log "Would remove expired backup (age: ${age}s, ttl: ${backup_ttl}s): ${backup_dir}"
+                REMOVED_COUNT=$((REMOVED_COUNT + 1))
+            else
+                if rm -rf "$backup_dir" 2>/dev/null; then
+                    log "Removed expired backup (age: ${age}s, ttl: ${backup_ttl}s): ${backup_dir}"
+                    REMOVED_COUNT=$((REMOVED_COUNT + 1))
+                else
+                    log "Error: Failed to remove backup: ${backup_dir}"
+                    ERROR_COUNT=$((ERROR_COUNT + 1))
+                fi
+            fi
+        fi
+    done
+done
+
+# === Summary ===
+
+log "Cleanup completed: removed=$REMOVED_COUNT, skipped=$SKIPPED_COUNT, errors=$ERROR_COUNT"
+
+exit 0

package/claude-assets/skills/pre-edit-backup/restore.sh

@@ -0,0 +1,128 @@
+#!/bin/bash
+
+# Pre-Edit Restore Script
+# Restores file from backup and updates metadata
+#
+# Usage: restore.sh BACKUP_DIR [--list FILE_PATH AGENT_ID]
+#
+# Arguments:
+#   BACKUP_DIR  - Path to backup directory containing backup_metadata.json
+#   --list      - List available backups for a file (requires FILE_PATH and AGENT_ID)
+#
+# Returns:
+#   Exit code 0 on success
+#   Exit code 1 on failure
+#
+# Example:
+#   ./.claude/skills/pre-edit-backup/restore.sh ".backups/backend-dev-1/1698764800000_abc123"
+#   ./.claude/skills/pre-edit-backup/restore.sh --list "/path/to/file.txt" "backend-dev-1"
+
+set -euo pipefail
+
+# === Handle --list Mode ===
+
+if [[ "${1:-}" == "--list" ]]; then
+    FILE_PATH="$2"
+    AGENT_ID="$3"
+
+    if [[ -z "$FILE_PATH" ]] || [[ -z "$AGENT_ID" ]]; then
+        echo "Error: --list requires FILE_PATH and AGENT_ID" >&2
+        exit 1
+    fi
+
+    BACKUP_BASE_DIR=".backups"
+    AGENT_BACKUP_DIR="${BACKUP_BASE_DIR}/${AGENT_ID}"
+
+    if [[ ! -d "$AGENT_BACKUP_DIR" ]]; then
+        echo "No backups found for agent: $AGENT_ID" >&2
+        exit 1
+    fi
+
+    echo "Available backups for $FILE_PATH (agent: $AGENT_ID):"
+    echo "---"
+
+    FOUND_BACKUPS=0
+    for backup_dir in "$AGENT_BACKUP_DIR"/*; do
+        if [[ -f "${backup_dir}/backup_metadata.json" ]]; then
+            ORIGINAL=$(jq -r '.original_path' "${backup_dir}/backup_metadata.json" 2>/dev/null || echo "")
+            if [[ "$ORIGINAL" == "$FILE_PATH" ]]; then
+                TIMESTAMP=$(jq -r '.backup_timestamp' "${backup_dir}/backup_metadata.json" 2>/dev/null || echo "unknown")
+                STATUS=$(jq -r '.backup_status' "${backup_dir}/backup_metadata.json" 2>/dev/null || echo "unknown")
+                echo "Backup: $(basename "$backup_dir")"
+                echo "  Timestamp: $TIMESTAMP"
+                echo "  Status: $STATUS"
+                echo "  Path: $backup_dir"
+                echo "---"
+                FOUND_BACKUPS=$((FOUND_BACKUPS + 1))
+            fi
+        fi
+    done
+
+    if [[ $FOUND_BACKUPS -eq 0 ]]; then
+        echo "No backups found for this file."
+        exit 1
+    fi
+
+    exit 0
+fi
+
+# === Restore Mode ===
+
+BACKUP_DIR="$1"
+
+if [[ -z "$BACKUP_DIR" ]]; then
+    echo "Error: No backup directory provided" >&2
+    echo "Usage: restore.sh BACKUP_DIR" >&2
+    exit 1
+fi
+
+if [[ ! -d "$BACKUP_DIR" ]]; then
+    echo "Error: Backup directory does not exist: $BACKUP_DIR" >&2
+    exit 1
+fi
+
+METADATA_FILE="${BACKUP_DIR}/backup_metadata.json"
+BACKUP_FILE="${BACKUP_DIR}/original_file"
+
+if [[ ! -f "$METADATA_FILE" ]]; then
+    echo "Error: Backup metadata not found: $METADATA_FILE" >&2
+    exit 1
+fi
+
+if [[ ! -f "$BACKUP_FILE" ]]; then
+    echo "Error: Backup file not found: $BACKUP_FILE" >&2
+    exit 1
+fi
+
+# Check for jq availability
+if ! command -v jq &>/dev/null; then
+    echo "Error: jq is required for restore operations" >&2
+    exit 1
+fi
+
+# Extract original path
+ORIGINAL_PATH=$(jq -r '.original_path' "$METADATA_FILE" 2>/dev/null)
+
+if [[ -z "$ORIGINAL_PATH" ]] || [[ "$ORIGINAL_PATH" == "null" ]]; then
+    echo "Error: Failed to read original path from metadata" >&2
+    exit 1
+fi
+
+# Restore file
+if ! cp "$BACKUP_FILE" "$ORIGINAL_PATH" 2>/dev/null; then
+    echo "Error: Failed to restore file to: $ORIGINAL_PATH" >&2
+    exit 1
+fi
+
+# Update backup status
+TEMP_FILE=$(mktemp)
+if jq '.backup_status = "restored"' "$METADATA_FILE" > "$TEMP_FILE" 2>/dev/null; then
+    mv "$TEMP_FILE" "$METADATA_FILE"
+else
+    echo "Warning: Failed to update backup status in metadata" >&2
+    rm -f "$TEMP_FILE"
+fi
+
+echo "File restored from backup: ${BACKUP_DIR}"
+echo "Restored to: ${ORIGINAL_PATH}"
+exit 0