claude-flow-novice 2.15.11 → 2.16.1

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

@@ -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/cfn-backlog-management/SKILL.md

@@ -195,5 +195,5 @@ grep -B 2 "Category: Optimization" readme/BACKLOG.md
 ## References
 
 - **STRAT-025**: Explicit Deliverable Tracking (adaptive context)
-- **CFN Loop Documentation**: `.claude/commands/cfn/CFN_LOOP_TASK_MODE.md`
+- **CFN Loop Documentation**: `.claude/commands/CFN_LOOP_TASK_MODE.md`
 - **Sprint Execution**: CLAUDE.md Section 6 - Sprint Context Injection

package/claude-assets/skills/cfn-coordination/agent-completion.sh.backup

@@ -0,0 +1,36 @@
+#!/bin/bash
+
+# Bash wrapper for TypeScript agent-completion CLI
+# Provides backward compatibility with existing bash-based agent completion
+#
+# Usage:
+#   agent-completion.sh --task-id <id> --agent-id <id> --confidence <score> [options]
+#
+# This wrapper delegates to the TypeScript CLI tool which provides:
+# - Type-safe Redis operations
+# - Test metric tracking (test-driven validation)
+# - Unified namespace handling (swarm/cfn_loop)
+# - Better error handling
+
+set -euo pipefail
+
+# Get the project root
+PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || echo "${PWD}")
+
+# Path to the compiled TypeScript CLI
+CLI_PATH="${PROJECT_ROOT}/dist/cli/agent-completion.js"
+
+# Check if CLI is compiled
+if [ ! -f "$CLI_PATH" ]; then
+    echo "Error: TypeScript CLI not compiled. Run 'npm run build' first." >&2
+    exit 1
+fi
+
+# Ensure Node.js is available
+if ! command -v node &>/dev/null; then
+    echo "Error: Node.js not found. Required to run coordination CLI." >&2
+    exit 1
+fi
+
+# Pass all arguments to the TypeScript CLI
+exec node "$CLI_PATH" "$@"

package/claude-assets/skills/cfn-coordination/coordination-signal.sh.backup

@@ -0,0 +1,36 @@
+#!/bin/bash
+
+# Bash wrapper for TypeScript coordination-signal CLI
+# Provides backward compatibility with existing bash-based coordination
+#
+# Usage:
+#   coordination-signal.sh --task-id <id> --channel <ch> --message <msg> [options]
+#
+# This wrapper delegates to the TypeScript CLI tool which provides:
+# - Type-safe Redis operations
+# - Unified namespace handling (swarm/cfn_loop)
+# - Automatic timeout management
+# - Better error handling
+
+set -euo pipefail
+
+# Get the project root
+PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || echo "${PWD}")
+
+# Path to the compiled TypeScript CLI
+CLI_PATH="${PROJECT_ROOT}/dist/cli/coordination-signal.js"
+
+# Check if CLI is compiled
+if [ ! -f "$CLI_PATH" ]; then
+    echo "Error: TypeScript CLI not compiled. Run 'npm run build' first." >&2
+    exit 1
+fi
+
+# Ensure Node.js is available
+if ! command -v node &>/dev/null; then
+    echo "Error: Node.js not found. Required to run coordination CLI." >&2
+    exit 1
+fi
+
+# Pass all arguments to the TypeScript CLI
+exec node "$CLI_PATH" "$@"

package/claude-assets/skills/cfn-coordination/coordination-wait.sh.backup

@@ -0,0 +1,36 @@
+#!/bin/bash
+
+# Bash wrapper for TypeScript coordination-wait CLI
+# Provides backward compatibility with existing bash-based coordination
+#
+# Usage:
+#   coordination-wait.sh --task-id <id> --channel <ch> [--timeout <sec>]
+#
+# This wrapper delegates to the TypeScript CLI tool which provides:
+# - Type-safe Redis blocking operations
+# - Unified namespace handling (swarm/cfn_loop)
+# - Automatic timeout management
+# - Better error handling
+
+set -euo pipefail
+
+# Get the project root
+PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || echo "${PWD}")
+
+# Path to the compiled TypeScript CLI
+CLI_PATH="${PROJECT_ROOT}/dist/cli/coordination-wait.js"
+
+# Check if CLI is compiled
+if [ ! -f "$CLI_PATH" ]; then
+    echo "Error: TypeScript CLI not compiled. Run 'npm run build' first." >&2
+    exit 1
+fi
+
+# Ensure Node.js is available
+if ! command -v node &>/dev/null; then
+    echo "Error: Node.js not found. Required to run coordination CLI." >&2
+    exit 1
+fi
+
+# Pass all arguments to the TypeScript CLI
+exec node "$CLI_PATH" "$@"

package/claude-assets/skills/cfn-dependency-ingestion/README.md

@@ -0,0 +1,101 @@
+# CFN Dependency Ingestion Skill
+
+Dynamic ingestion of CFN Loop CLI dependency files by parsing the dependency diagram.
+
+## Quick Start
+
+```bash
+# Ingest all dependencies
+./.claude/skills/cfn-dependency-ingestion/ingest-dependencies.sh
+
+# Ingest P0 critical path only
+./.claude/skills/cfn-dependency-ingestion/ingest-dependencies.sh --priority P0
+
+# Ingest TypeScript files only
+./.claude/skills/cfn-dependency-ingestion/ingest-dependencies.sh --type TS
+
+# Include deprecated files
+./.claude/skills/cfn-dependency-ingestion/ingest-dependencies.sh --include-deprecated
+```
+
+## Output
+
+The script outputs Read commands grouped by priority:
+
+```
+# Step 1: Read the dependency diagram
+Read: readme/CFN_LOOP_DEPENDENCY_DIAGRAM.txt
+
+# Step 2: Read P0 critical path files (required for 5-iteration e2e)
+Read: .claude/skills/cfn-loop-orchestration/src/orchestrate.ts
+Read: .claude/skills/cfn-agent-selection-with-fallback/src/cli.ts
+...
+
+# Step 3: Read P1 files (post-validation features)
+...
+
+# Step 5: Read coordination layer (Redis/Shell scripts)
+...
+
+# Step 6: Read agent profiles (coordinators and workers)
+...
+
+# Step 7: Read slash commands
+...
+```
+
+## Options
+
+- `--priority P0,P1,P2` - Filter by priority levels
+- `--type TS,SH` - Filter by file types (TypeScript or Shell)
+- `--include-deprecated` - Include files marked as DEPRECATED
+- `--skip-validation` - Disable file existence checks (faster, but may include missing files)
+
+## Features
+
+### Deduplication (Enhancement #1)
+All file paths are deduplicated using `sort -u`. If a file appears in multiple sections (e.g., `orchestrate.ts` in both P0 and coordination layer), it will only appear once in the final output.
+
+### Type Filtering (Enhancement #2)
+The `--type` flag correctly filters files by extension:
+- `--type TS` - Only `.ts`, `.js`, `.cjs` files
+- `--type SH` - Only `.sh` files
+- `--type TS,SH` - Both TypeScript and Shell files
+
+### File Existence Validation (Enhancement #3)
+By default, the script validates that all discovered files exist on the filesystem:
+- Missing files are reported to stderr with `WARNING: File not found: <path>`
+- Missing files are excluded from Read output
+- Use `--skip-validation` to disable checks for faster execution
+
+### Regression Testing (Enhancement #4)
+Expected file counts are documented in `SKILL.md` for regression testing:
+- Total files: 14 (as of 2025-11-20, after deduplication)
+- P0 files: 3 (in P0 section, Step 2)
+- TypeScript files: 4
+- Shell files: 3
+- Known missing files: 4
+
+See `SKILL.md` for validation commands and regression test suite.
+
+## Usage in Agents
+
+The `cfn-loops-cli-expert` agent uses this skill for dynamic dependency loading:
+
+```markdown
+## Step 2: Execute Dependency Ingestion
+
+```bash
+./.claude/skills/cfn-dependency-ingestion/ingest-dependencies.sh
+```
+
+This automatically discovers and reads all files referenced in the dependency diagram.
+```
+
+## Maintenance
+
+This skill self-updates when `readme/CFN_LOOP_DEPENDENCY_DIAGRAM.txt` changes. No code updates needed.
+
+## Implementation
+
+See `SKILL.md` for complete documentation and progressive disclosure.