claude-flow-novice 2.10.8 → 2.10.9

package/claude-assets/hooks/cfn-invoke-pre-edit.sh

@@ -0,0 +1,88 @@
+#!/bin/bash
+
+# Pre-Edit Backup Hook Wrapper
+# Creates backup before file modifications in agent workflows
+#
+# Usage: .claude/hooks/cfn-invoke-pre-edit.sh FILE_PATH --agent-id AGENT_ID
+#
+# Arguments:
+#   FILE_PATH   - Absolute path to file about to be edited
+#   --agent-id  - Unique identifier for the agent performing the edit
+#
+# Returns:
+#   Backup directory path on success
+#   Exit code 1 on failure
+#
+# Example:
+#   BACKUP_PATH=$(./.claude/hooks/cfn-invoke-pre-edit.sh "/path/to/file.txt" --agent-id "backend-dev-1")
+
+set -euo pipefail
+
+# === Parse Arguments ===
+
+FILE_PATH=""
+AGENT_ID=""
+
+# First positional argument is file path
+if [[ -n "${1:-}" ]] && [[ "$1" != --* ]]; then
+    FILE_PATH="$1"
+    shift
+fi
+
+# Parse remaining named arguments
+while [[ "$#" -gt 0 ]]; do
+    case $1 in
+        --agent-id)
+            if [[ -z "${2:-}" ]]; then
+                echo "Error: --agent-id requires a value" >&2
+                exit 1
+            fi
+            AGENT_ID="$2"
+            shift 2
+            ;;
+        *)
+            echo "Error: Unknown argument: $1" >&2
+            echo "Usage: cfn-invoke-pre-edit.sh FILE_PATH --agent-id AGENT_ID" >&2
+            exit 1
+            ;;
+    esac
+done
+
+# === Validate Inputs ===
+
+if [[ -z "$FILE_PATH" ]]; then
+    echo "Error: No file path provided" >&2
+    echo "Usage: cfn-invoke-pre-edit.sh FILE_PATH --agent-id AGENT_ID" >&2
+    exit 1
+fi
+
+if [[ -z "$AGENT_ID" ]]; then
+    echo "Error: No agent ID provided" >&2
+    echo "Usage: cfn-invoke-pre-edit.sh FILE_PATH --agent-id AGENT_ID" >&2
+    exit 1
+fi
+
+if [[ ! -f "$FILE_PATH" ]]; then
+    echo "Error: File does not exist: $FILE_PATH" >&2
+    exit 1
+fi
+
+# === Execute Pre-Edit Backup ===
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+BACKUP_SCRIPT="${SCRIPT_DIR}/../skills/pre-edit-backup/backup.sh"
+
+if [[ ! -f "$BACKUP_SCRIPT" ]]; then
+    echo "Error: Backup script not found: $BACKUP_SCRIPT" >&2
+    exit 1
+fi
+
+# Execute backup and capture output
+if ! BACKUP_DIR=$("$BACKUP_SCRIPT" "$FILE_PATH" "$AGENT_ID" 2>&1); then
+    echo "Error: Backup failed: $BACKUP_DIR" >&2
+    exit 1
+fi
+
+# Return backup directory path
+echo "$BACKUP_DIR"
+exit 0

package/claude-assets/hooks/post-edit.config.json

@@ -1,12 +1,23 @@
 {
-  "default_validation": {
-    "file_size": {
-      "min_bytes": 1024,
-      "max_bytes": 1048576
+    "pre_edit_backup": {
+        "enabled": true,
+        "default_ttl": 86400,
+        "retention_strategy": "oldest_first",
+        "ignore_patterns": [
+            "*.log",
+            "*.tmp",
+            ".backups/*"
+        ]
     },
-    "content_checks": {
-      "required_sections": ["# ", "## ", "### "],
-      "min_sections": 3
+    "post_edit_validation": {
+        "enabled": true,
+        "checks": [
+            "file_integrity",
+            "pre_edit_backup_created"
+        ]
+    },
+    "logging": {
+        "enabled": true,
+        "log_path": ".claude/logs/file_edit_hooks.log"
     }
-  }
 }

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