claude-flow-novice 2.18.6 → 2.18.8

package/claude-assets/skills/cfn-routing-config/lib/hybrid/check-dependencies.sh

@@ -1,52 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Hybrid Routing Skill Dependency Checker
-
-DEPENDENCIES=(
-    "jq"
-    "redis-cli"
-    "openssl"
-)
-
-OPTIONAL_DEPENDENCIES=(
-    "websocketd"
-)
-
-check_dependency() {
-    local dep="$1"
-    if ! command -v "$dep" &> /dev/null; then
-        echo "Error: Dependency '$dep' not found."
-        return 1
-    fi
-}
-
-main() {
-    echo "Checking Required Dependencies for Hybrid Routing Skill..."
-
-    # Check required dependencies
-    for dep in "${DEPENDENCIES[@]}"; do
-        if ! check_dependency "$dep"; then
-            echo "CRITICAL: Unable to proceed without $dep"
-            exit 1
-        fi
-    done
-
-    # Check optional dependencies
-    for dep in "${OPTIONAL_DEPENDENCIES[@]}"; do
-        if ! command -v "$dep" &> /dev/null; then
-            echo "Warning: Optional dependency '$dep' not found. Some advanced routing features may be limited."
-        fi
-    done
-
-    # Additional Redis connectivity check
-    if ! redis-cli ping &> /dev/null; then
-        echo "Error: Cannot connect to Redis server"
-        exit 1
-    fi
-
-    echo "✅ All dependencies validated successfully"
-    exit 0
-}
-
-main "$@"

package/claude-assets/skills/cfn-routing-config/lib/hybrid/config.json

@@ -1,26 +0,0 @@
-{
-    "skill_name": "hybrid-routing",
-    "version": "1.0.0",
-    "routing_strategies": {
-        "primary": {
-            "type": "redis-pubsub",
-            "priority": 1,
-            "latency_threshold_ms": 50
-        },
-        "secondary": {
-            "type": "websocket",
-            "priority": 2,
-            "latency_threshold_ms": 100
-        }
-    },
-    "performance_targets": {
-        "routing_accuracy": 0.85,
-        "channel_transition_time_ms": 50,
-        "packet_loss_percentage": 0.01
-    },
-    "security_configuration": {
-        "encryption": "TLS_1_3",
-        "authentication_method": "JWT",
-        "rate_limit_per_second": 1000
-    }
-}

package/claude-assets/skills/cfn-routing-config/lib/hybrid/spawn-worker.sh

@@ -1,44 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Hybrid Routing Worker Spawner
-# Dynamically configures and launches routing workers
-
-CONFIG_PATH="$(dirname "$0")/config.json"
-
-# Load configuration
-SKILL_NAME=$(jq -r '.skill_name' "$CONFIG_PATH")
-PRIMARY_CHANNEL=$(jq -r '.routing_strategies.primary.type' "$CONFIG_PATH")
-SECONDARY_CHANNEL=$(jq -r '.routing_strategies.secondary.type' "$CONFIG_PATH")
-
-# Worker spawning function
-spawn_routing_worker() {
-    local channel_type="$1"
-    local worker_id="$2"
-
-    case "$channel_type" in
-        "redis-pubsub")
-            ./.claude/skills/cfn-redis-coordination/spawn-agent.sh \
-                --skill-id "$SKILL_NAME" \
-                --agent-id "routing-worker-$worker_id" \
-                --strategy "$channel_type"
-            ;;
-        "websocket")
-            ./.claude/skills/agent-lifecycle/lib/spawning/spawn-agent.sh \
-                --skill-id "$SKILL_NAME" \
-                --agent-id "routing-worker-$worker_id" \
-                --strategy "$channel_type"
-            ;;
-        *)
-            echo "Unsupported channel type: $channel_type"
-            exit 1
-            ;;
-    esac
-}
-
-# Spawn primary and secondary workers
-spawn_routing_worker "$PRIMARY_CHANNEL" "primary"
-spawn_routing_worker "$SECONDARY_CHANNEL" "secondary"
-
-# Final status report
-echo "Hybrid Routing Workers Spawned Successfully"

package/claude-assets/skills/cfn-routing-config/lib/provider/README.md

@@ -1,129 +0,0 @@
-# CFN Provider Routing - Cross-Provider Model Compatibility
-
-## Overview
-
-This module provides cross-provider model compatibility for CFN Loop agent routing. It translates agent-specified models (sonnet/haiku/opus) to provider-specific model names without requiring Redis calls.
-
-## Problem Solved
-
-**Before:** Agent profiles specified Anthropic-specific models (`model: sonnet`, `model: haiku`) but providers use different model names:
-- Z.ai: `glm-4.6`
-- Kimi: `kimi-k2-turbo-preview`
-- OpenRouter: `anthropic/claude-sonnet-4.5`
-- Gemini: `google/gemini-2.0-flash-001`
-- XAi: `grok-beta`
-
-**After:** Centralized mapping system automatically translates agent models to provider-specific models.
-
-## Files
-
-- **`provider-model-mappings.yaml`** - Configuration file with all provider model mappings
-- **`resolve-provider-model.ts`** - TypeScript resolver service (NO REDIS CALLS)
-- **`README.md`** - This documentation
-
-## Usage
-
-### Command Line
-```bash
-# Resolve model for provider
-./resolve-provider-model.ts --provider zai --model sonnet
-# Output: glm-4.6
-
-# Get configuration summary
-./resolve-provider-model.ts --summary
-
-# Use cost tier optimization
-./resolve-provider-model.ts --provider kimi --model haiku --tier economy
-```
-
-### Programmatic
-```typescript
-import ProviderModelResolver from './resolve-provider-model';
-
-const resolver = new ProviderModelResolver();
-
-// Basic resolution
-const model = resolver.resolveModel('zai', 'sonnet'); // glm-4.6
-
-// With cost optimization
-const economyModel = resolver.resolveModel('kimi', 'haiku', 'economy');
-
-// Check provider support
-if (resolver.isProviderSupported('zai')) {
-  // Use Z.ai routing
-}
-```
-
-## Integration Points
-
-The resolver integrates with existing CFN Loop components:
-
-1. **Agent Spawning**: `cfn-agent-spawning` scripts use resolver to set ANTHROPIC_MODEL
-2. **Provider Selection**: `get-agent-provider-env.sh` calls resolver for model mapping
-3. **Cost Optimization**: CLI mode can specify cost tiers for agent execution
-
-## Configuration
-
-### Adding New Providers
-
-1. Add provider to `provider-model-mappings.yaml`:
-```yaml
-mappings:
-  sonnet:
-    newprovider: newprovider-sonnet-model
-  haiku:
-    newprovider: newprovider-haiku-model
-
-defaults:
-  newprovider: newprovider-default-model
-```
-
-2. Update provider detection logic in existing routing scripts
-
-### Adding New Agent Models
-
-1. Add model mapping for all providers:
-```yaml
-mappings:
-  newmodel:
-    anthropic: claude-3-5-newmodel
-    zai: glm-4.6-newmodel
-    kimi: kimi-newmodel
-    # ... etc for all providers
-```
-
-## Architecture Benefits
-
-- ✅ **Single source of truth** - All mappings in one YAML file
-- ✅ **Zero Redis dependency** - Pure configuration resolution
-- ✅ **Easy provider addition** - Add provider to config only
-- ✅ **Cost optimization support** - Built-in tier-based model selection
-- ✅ **TypeScript safety** - Full type checking and validation
-- ✅ **Agent profile simplicity** - No need to update 65+ agent files
-- ✅ **Testing simplicity** - Validate mappings in isolation
-
-## Migration Path
-
-1. **Phase 1**: Deploy resolver alongside existing system
-2. **Phase 2**: Update agent spawning to use resolver
-3. **Phase 3**: Remove hardcoded model logic from routing scripts
-4. **Phase 4**: Add cost tier optimization to CLI mode
-
-## Testing
-
-```bash
-# Test all provider mappings
-./resolve-provider-model.ts --summary
-
-# Validate specific mappings
-./resolve-provider-model.ts --provider zai --model sonnet
-./resolve-provider-model.ts --provider kimi --model haiku
-./resolve-provider-model.ts --provider openrouter --model opus
-```
-
-## Performance
-
-- **Startup time**: <10ms (YAML file load)
-- **Resolution time**: <1ms per lookup
-- **Memory usage**: <1MB (small config object)
-- **No external dependencies**: Pure Node.js implementation

package/claude-assets/skills/cfn-routing-config/lib/provider/SKILL.md

@@ -1,215 +0,0 @@
----
-name: cfn-provider-routing
-version: 1.0.0
-complexity: Low
-keywords: [
-    "provider routing",
-    "API management",
-    "cost optimization",
-    "model compatibility",
-    "cross-provider"
-]
-triggers: [
-    "agent spawning with provider selection",
-    "cost optimization requirements",
-    "multi-provider compatibility"
-]
-performance_targets: {
-    "resolution_latency_ms": 1,
-    "memory_footprint_mb": 1,
-    "startup_time_ms": 10
-}
----
-
-# CFN Provider Routing - Cross-Provider Model Compatibility
-
-**Status:** Production Ready | **Category:** Provider Integration | **Complexity:** Low
-
-## Overview
-
-Translates agent-specified models (sonnet/haiku/opus) to provider-specific model names. Enables seamless cross-provider compatibility without modifying agent profiles.
-
-## Core Function
-
-**Primary Use Case:** Agent spawning with provider-specific model resolution
-**Secondary Use Case:** Cost optimization through tier-based model selection
-**Validation:** Model mapping completeness and provider support verification
-
-## Usage Patterns
-
-### Direct Model Resolution
-```bash
-# Basic usage - resolve sonnet for Z.ai
-./resolve-provider-model.ts --provider zai --model sonnet
-# Returns: glm-4.6
-
-# With cost optimization
-./resolve-provider-model.ts --provider kimi --model haiku --tier economy
-# Returns: kimi-k2-turbo-preview
-```
-
-### Integration with Agent Spawning
-```bash
-# In agent spawning scripts
-AGENT_MODEL="sonnet"
-PROVIDER="zai"
-RESOLVED_MODEL=$(./resolve-provider-model.ts --provider "$PROVIDER" --model "$AGENT_MODEL")
-export ANTHROPIC_MODEL="$RESOLVED_MODEL"
-```
-
-### Configuration Validation
-```bash
-# Check provider support
-./resolve-provider-model.ts --summary
-# Returns JSON with supported providers and models
-```
-
-## Parameters
-
-### Required Parameters
-- `--provider <provider>`: Target provider (zai, kimi, openrouter, gemini, xai, anthropic)
-
-### Optional Parameters
-- `--model <agent-model>`: Agent-specified model (sonnet, haiku, opus)
-- `--tier <cost-tier>`: Cost optimization tier (economy, standard, premium)
-- `--summary`: Show configuration summary
-
-## Return Values
-
-### Success
-- **Model resolution**: Returns provider-specific model name as string
-- **Configuration summary**: Returns JSON with provider/model mappings
-
-### Error Conditions
-- **Provider not supported**: Returns error with supported providers list
-- **Configuration missing**: Falls back to basic mappings with warning
-- **Invalid parameters**: Returns usage information
-
-## Integration Points
-
-### Agent Spawning Pipeline
-```
-Agent Profile (model: sonnet) → Provider Router → Z.ai (glm-4.6)
-```
-
-### CLI Mode Provider Selection
-```
-/cfn-loop-cli "task" --provider zai → Router → Agent with glm-4.6
-```
-
-### Cost Optimization
-```
---tier economy → Router → Fast models for simple tasks
---tier premium → Router → High-quality models for complex tasks
-```
-
-## Examples
-
-### Basic Provider Routing
-```bash
-# Spawn backend-developer with Z.ai
-AGENT_TYPE="backend-developer"  # Has model: sonnet
-PROVIDER="zai"
-MODEL=$(./resolve-provider-model.ts --provider "$PROVIDER" --model sonnet)
-# MODEL="glm-4.6"
-```
-
-### Cross-Provider Compatibility
-```bash
-# Same agent, different providers
-./resolve-provider-model.ts --provider zai --model sonnet      # glm-4.6
-./resolve-provider-model.ts --provider kimi --model sonnet     # kimi-k2-turbo-preview
-./resolve-provider-model.ts --provider openrouter --model sonnet # anthropic/claude-sonnet-4.5
-```
-
-### Cost-Optimized Execution
-```bash
-# Economy mode for bulk operations
-ECONOMY_MODEL=$(./resolve-provider-model.ts --provider kimi --model haiku --tier economy)
-# Returns: kimi-k2-turbo-preview (fast, cost-effective)
-
-# Premium mode for critical tasks
-PREMIUM_MODEL=$(./resolve-provider-model.ts --provider openrouter --model sonnet --tier premium)
-# Returns: anthropic/claude-sonnet-4.5 (high quality)
-```
-
-## Dependencies
-
-### External Dependencies
-- **Node.js**: Runtime environment
-- **js-yaml**: YAML configuration parsing (bundled)
-
-### Configuration Dependencies
-- **provider-model-mappings.yaml**: Model mapping configuration
-- **No Redis required**: Pure configuration resolution
-
-## Anti-Patterns
-
-### ❌ Manual Model Hardcoding
-```bash
-# AVOID: Hardcoded provider-specific models
-if [[ "$PROVIDER" == "zai" ]]; then
-  export ANTHROPIC_MODEL="glm-4.6"
-fi
-```
-
-### ❌ Agent Profile Modification
-```yaml
-# AVOID: Updating 65+ agent files for new provider
-<!-- PROVIDER_PARAMETERS
-provider: zai
-model: glm-4.6  # Wrong approach - maintenance nightmare
--->
-```
-
-### ✅ Centralized Mapping
-```bash
-# CORRECT: Use centralized resolver
-MODEL=$(./resolve-provider-model.ts --provider "$PROVIDER" --model "$AGENT_MODEL")
-export ANTHROPIC_MODEL="$MODEL"
-```
-
-## Performance Characteristics
-
-- **Resolution latency**: <1ms per lookup
-- **Memory footprint**: <1MB configuration object
-- **Startup time**: <10ms YAML file load
-- **Scalability**: O(1) lookup time, unlimited concurrent requests
-
-## Monitoring & Troubleshooting
-
-### Configuration Validation
-```bash
-# Check if all providers are supported
-./resolve-provider-model.ts --summary
-```
-
-### Model Resolution Testing
-```bash
-# Test all agent models for a provider
-for model in sonnet haiku opus; do
-  echo "$model → $(./resolve-provider-model.ts --provider zai --model "$model")"
-done
-```
-
-### Common Issues
-- **Provider not found**: Check provider name spelling in configuration
-- **Model resolution fails**: Verify agent model exists in mappings
-- **Configuration missing**: Fallback to basic mappings automatically
-
-## Evolution Path
-
-### Phase 1: Current Implementation
-- Basic model mapping resolution
-- Configuration file-based approach
-- CLI integration for agent spawning
-
-### Phase 2: Enhanced Features
-- Dynamic model capability detection
-- Provider-specific optimization hints
-- Integration with cost tracking
-
-### Phase 3: Advanced Routing
-- AI-driven model selection based on task complexity
-- Performance-based model switching
-- Multi-provider failover routing

package/claude-assets/skills/cfn-routing-config/lib/provider/resolve-provider-model.ts

@@ -1,223 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Provider Model Resolution Service
- *
- * Resolves cross-provider model mappings for CFN Loop agent routing.
- * Translates agent-specified models (sonnet/haiku/opus) to
- * provider-specific model names.
- *
- * NO REDIS CALLS - This is a pure configuration resolver.
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import * as yaml from 'js-yaml';
-
-interface ProviderMappings {
-  mappings: {
-    [agentModel: string]: {
-      [provider: string]: string;
-    };
-  };
-  defaults: {
-    [provider: string]: string;
-  };
-  cost_tiers?: {
-    [tier: string]: {
-      [provider: string]: string;
-    };
-  };
-}
-
-class ProviderModelResolver {
-  private mappings: ProviderMappings | null = null;
-  private configPath: string;
-
-  constructor() {
-    this.configPath = path.join(process.cwd(), '.claude/config/provider-model-mappings.yaml');
-    this.loadMappings();
-  }
-
-  private loadMappings(): void {
-    try {
-      const configContent = fs.readFileSync(this.configPath, 'utf8');
-      this.mappings = yaml.load(configContent) as ProviderMappings;
-    } catch (error) {
-      console.error('Failed to load provider model mappings:', error);
-      // Fallback to basic mappings
-      this.mappings = {
-        mappings: {
-          sonnet: {
-            anthropic: 'claude-3-5-sonnet-20241022',
-            zai: 'glm-4.6',
-            kimi: 'kimi-k2-turbo-preview',
-            openrouter: 'anthropic/claude-sonnet-4.5',
-            gemini: 'google/gemini-2.0-flash-001',
-            xai: 'grok-beta'
-          },
-          haiku: {
-            anthropic: 'claude-3-5-haiku-20241022',
-            zai: 'glm-4.6-flash',
-            kimi: 'kimi-k2-turbo-preview',
-            openrouter: 'anthropic/claude-3.5-haiku',
-            gemini: 'google/gemini-2.0-flash-001',
-            xai: 'grok-beta'
-          }
-        },
-        defaults: {
-          zai: 'glm-4.6',
-          kimi: 'kimi-k2-turbo-preview',
-          openrouter: 'anthropic/claude-sonnet-4.5',
-          gemini: 'google/gemini-2.0-flash-001',
-          xai: 'grok-beta',
-          anthropic: 'claude-3-5-sonnet-20241022'
-        }
-      };
-    }
-  }
-
-  /**
-   * Resolve model for specific provider and agent model
-   */
-  resolveModel(provider: string, agentModel?: string, costTier?: string): string {
-    if (!this.mappings) {
-      throw new Error('Provider model mappings not loaded');
-    }
-
-    // If cost tier is specified, use tier-specific model
-    if (costTier && this.mappings.cost_tiers?.[costTier]?.[provider]) {
-      return this.mappings.cost_tiers[costTier][provider];
-    }
-
-    // If agent has specific model, map it to provider
-    if (agentModel && this.mappings.mappings[agentModel]?.[provider]) {
-      return this.mappings.mappings[agentModel][provider];
-    }
-
-    // Use provider default
-    if (this.mappings.defaults[provider]) {
-      return this.mappings.defaults[provider];
-    }
-
-    // Fallback to standard model
-    return this.mappings.defaults['anthropic'];
-  }
-
-  /**
-   * Get all available models for a provider
-   */
-  getProviderModels(provider: string): string[] {
-    if (!this.mappings) {
-      return [];
-    }
-
-    const models = new Set<string>();
-
-    // Collect models from mappings
-    Object.values(this.mappings.mappings).forEach(mapping => {
-      if (mapping[provider]) {
-        models.add(mapping[provider]);
-      }
-    });
-
-    // Add default model
-    if (this.mappings.defaults[provider]) {
-      models.add(this.mappings.defaults[provider]);
-    }
-
-    return Array.from(models);
-  }
-
-  /**
-   * Validate provider support
-   */
-  isProviderSupported(provider: string): boolean {
-    if (!this.mappings) {
-      return false;
-    }
-
-    return this.mappings.defaults.hasOwnProperty(provider);
-  }
-
-  /**
-   * Get configuration summary (useful for debugging)
-   */
-  getConfigSummary(): {
-    supportedProviders: string[];
-    supportedAgentModels: string[];
-    hasCostTiers: boolean;
-  } {
-    if (!this.mappings) {
-      return {
-        supportedProviders: [],
-        supportedAgentModels: [],
-        hasCostTiers: false
-      };
-    }
-
-    return {
-      supportedProviders: Object.keys(this.mappings.defaults),
-      supportedAgentModels: Object.keys(this.mappings.mappings),
-      hasCostTiers: !!this.mappings.cost_tiers
-    };
-  }
-}
-
-// CLI interface for testing
-if (require.main === module) {
-  const args = process.argv.slice(2);
-  const resolver = new ProviderModelResolver();
-
-  if (args.includes('--help') || args.length === 0) {
-    console.log(`
-Provider Model Resolver
-
-Usage:
-  resolve-provider-model.ts --provider <provider> [--model <agent-model>] [--tier <cost-tier>]
-  resolve-provider-model.ts --summary
-  resolve-provider-model.ts --providers <provider>
-
-Examples:
-  resolve-provider-model.ts --provider zai --model sonnet
-  resolve-provider-model.ts --provider kimi --model haiku --tier economy
-  resolve-provider-model.ts --summary
-  resolve-provider-model.ts --providers zai
-
-Supported providers: anthropic, zai, kimi, openrouter, gemini, xai
-Agent models: sonnet, haiku, opus (or defaults)
-Cost tiers: economy, standard, premium
-    `);
-    process.exit(0);
-  }
-
-  try {
-    if (args.includes('--summary')) {
-      const summary = resolver.getConfigSummary();
-      console.log('Configuration Summary:');
-      console.log(JSON.stringify(summary, null, 2));
-      process.exit(0);
-    }
-
-    const providerIndex = args.indexOf('--provider');
-    const modelIndex = args.indexOf('--model');
-    const tierIndex = args.indexOf('--tier');
-
-    if (providerIndex === -1) {
-      console.error('--provider is required');
-      process.exit(1);
-    }
-
-    const provider = args[providerIndex + 1];
-    const agentModel = modelIndex !== -1 ? args[modelIndex + 1] : undefined;
-    const costTier = tierIndex !== -1 ? args[tierIndex + 1] : undefined;
-
-    const resolvedModel = resolver.resolveModel(provider, agentModel, costTier);
-    console.log(resolvedModel);
-  } catch (error) {
-    console.error('Error:', error instanceof Error ? error.message : error);
-    process.exit(1);
-  }
-}
-
-export default ProviderModelResolver;