claude-flow-novice 2.18.5 → 2.18.7

package/.claude/skills/cfn-process-management/lib/lifecycle/process-manager.sh

@@ -0,0 +1,334 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Process Lifecycle Advanced Management Script (Prototype/Demo)
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+CONFIG_PATH="${SCRIPT_DIR}/config.json"
+REDIS_CHANNEL="process-lifecycle"
+LOG_DIR="${HOME}/.cfn/logs/processes"
+RUN_DIR="${HOME}/.cfn/run"
+TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
+
+# Create necessary directories with error handling
+create_directories() {
+    for dir in "$LOG_DIR" "$RUN_DIR"; do
+        if ! mkdir -p "$dir" 2>/dev/null; then
+            echo "ERROR: Failed to create directory: $dir" >&2
+            exit 1
+        fi
+        
+        if [[ ! -w "$dir" ]]; then
+            echo "ERROR: Directory is not writable: $dir" >&2
+            exit 1
+        fi
+    done
+}
+
+# Ensure directories exist and are writable
+create_directories
+
+# Logging function with multiple verbosity levels
+log() {
+    local level="$1"
+    local message="$2"
+    local log_file="${LOG_DIR}/${level,,}_${TIMESTAMP}.log"
+    local color=""
+
+    case "$level" in
+        ERROR)   color="\e[31m" ;; # Red
+        WARN)    color="\e[33m" ;; # Yellow
+        INFO)    color="\e[34m" ;; # Blue
+        DEBUG)   color="\e[37m" ;; # White
+        *)       color="\e[0m"  ;; # Default
+    esac
+
+    # Log to file and stderr with color
+    echo -e "[${color}${level^^}\e[0m] $(date -Iseconds) - $message" | tee -a "$log_file" >&2
+}
+
+# Environment configuration and defaults
+PROCESS_ID="${PROCESS_ID:-}"
+ACTION="${1:-}"
+VERBOSE="${VERBOSE:-false}"
+
+# Configuration and validation
+load_config() {
+    if [[ ! -f "$CONFIG_PATH" ]]; then
+        log "ERROR" "Configuration file not found: $CONFIG_PATH"
+        exit 1
+    fi
+    jq -c '.' "$CONFIG_PATH"
+}
+
+validate_process() {
+    local process_id="$1"
+    jq -e --arg process "$process_id" \
+        '.processTypes[$process]' "$CONFIG_PATH" > /dev/null 2>&1
+}
+
+# PID file management
+get_pid_file() {
+    echo "${RUN_DIR}/${PROCESS_ID}.pid"
+}
+
+is_process_running() {
+    local pid_file="$1"
+    if [[ -f "$pid_file" ]]; then
+        local pid=$(cat "$pid_file")
+        if kill -0 "$pid" 2>/dev/null; then
+            return 0
+        else
+            # PID file exists but process is dead, clean up
+            rm -f "$pid_file"
+            return 1
+        fi
+    fi
+    return 1
+}
+
+# Process health checking
+check_process_health() {
+    local process_id="$1"
+    local pid_file=$(get_pid_file)
+    
+    if ! is_process_running "$pid_file"; then
+        echo "STOPPED"
+        return 0
+    fi
+    
+    local pid=$(cat "$pid_file")
+    local health_status="RUNNING"
+    
+    # Check CPU usage (simulation)
+    local cpu_usage=$(ps -p "$pid" -o %cpu --no-headers 2>/dev/null | tr -d ' ' || echo "0")
+    if (( $(echo "$cpu_usage > 90" | bc -l) )); then
+        health_status="HIGH_CPU"
+    fi
+    
+    # Check memory usage (simulation)
+    local mem_usage=$(ps -p "$pid" -o %mem --no-headers 2>/dev/null | tr -d ' ' || echo "0")
+    if (( $(echo "$mem_usage > 80" | bc -l) )); then
+        health_status="HIGH_MEM"
+    fi
+    
+    echo "$health_status"
+}
+
+# Advanced process management functions
+start_process() {
+    local process_id="$1"
+    local pid_file=$(get_pid_file)
+
+    if ! validate_process "$process_id"; then
+        log "ERROR" "Invalid process type: $process_id"
+        return 1
+    fi
+
+    # Check if already running
+    if is_process_running "$pid_file"; then
+        log "WARN" "Process $process_id is already running"
+        return 0
+    fi
+
+    # Dependency validation
+    local dependencies=$(jq -r --arg process "$process_id" \
+        '.processTypes[$process].dependencies[]' "$CONFIG_PATH" 2>/dev/null || true)
+
+    for dep in $dependencies; do
+        local dep_pid_file="${RUN_DIR}/${dep}.pid"
+        if ! is_process_running "$dep_pid_file"; then
+            log "WARN" "Dependency $dep not running, cannot start $process_id"
+            return 1
+        fi
+    done
+
+    log "INFO" "Starting process: $process_id (DEMO MODE)"
+
+    # Simulate process start with a background task
+    case "$process_id" in
+        "web-server")
+            # Simulate web server with a simple HTTP server
+            (
+                echo $$ > "$pid_file"
+                log "INFO" "Process $process_id started with PID $$"
+                # Simulate work
+                while true; do
+                    sleep 5
+                    echo "$(date): $process_id heartbeat" >> "${LOG_DIR}/${process_id}_heartbeat.log"
+                done
+            ) &
+            ;;
+        "database")
+            # Simulate database process
+            (
+                echo $$ > "$pid_file"
+                log "INFO" "Process $process_id started with PID $$"
+                while true; do
+                    sleep 3
+                    echo "$(date): $process_id processing transactions" >> "${LOG_DIR}/${process_id}_heartbeat.log"
+                done
+            ) &
+            ;;
+        "cache-service")
+            # Simulate cache service
+            (
+                echo $$ > "$pid_file"
+                log "INFO" "Process $process_id started with PID $$"
+                while true; do
+                    sleep 2
+                    echo "$(date): $process_id cache refresh" >> "${LOG_DIR}/${process_id}_heartbeat.log"
+                done
+            ) &
+            ;;
+        *)
+            # Generic process simulation
+            (
+                echo $$ > "$pid_file"
+                log "INFO" "Process $process_id started with PID $$"
+                while true; do
+                    sleep 10
+                    echo "$(date): $process_id running" >> "${LOG_DIR}/${process_id}_heartbeat.log"
+                done
+            ) &
+            ;;
+    esac
+
+    # Give process time to start
+    sleep 1
+
+    # Verify process started
+    if is_process_running "$pid_file"; then
+        log "INFO" "Process $process_id successfully started"
+        
+        # Publish Redis event for coordination
+        npx redis-cli PUBLISH "$REDIS_CHANNEL" \
+            "$(jq -n \
+                --arg process "$process_id" \
+                --arg action "start" \
+                --arg pid "$(cat "$pid_file")" \
+                '{process: $process, action: $action, pid: $pid, timestamp: now}')" 2>/dev/null || true
+    else
+        log "ERROR" "Failed to start process $process_id"
+        return 1
+    fi
+}
+
+stop_process() {
+    local process_id="$1"
+    local pid_file=$(get_pid_file)
+
+    # Check for dependent processes
+    local dependent_processes=$(jq -r \
+        --arg process "$process_id" \
+        '.processTypes | to_entries[] | select(.value.dependencies[] == $process) | .key' \
+        "$CONFIG_PATH" 2>/dev/null || true)
+
+    for dep in $dependent_processes; do
+        local dep_pid_file="${RUN_DIR}/${dep}.pid"
+        if is_process_running "$dep_pid_file"; then
+            log "WARN" "Cannot stop $process_id, dependent process $dep is running"
+            return 1
+        fi
+    done
+
+    if ! is_process_running "$pid_file"; then
+        log "WARN" "Process $process_id is not running"
+        return 0
+    fi
+
+    log "INFO" "Stopping process: $process_id"
+
+    local pid=$(cat "$pid_file")
+    
+    # Graceful shutdown
+    if kill -TERM "$pid" 2>/dev/null; then
+        # Wait for graceful shutdown
+        local count=0
+        while is_process_running "$pid_file" && [[ $count -lt 10 ]]; do
+            sleep 1
+            ((count++))
+        done
+        
+        # Force kill if still running
+        if is_process_running "$pid_file"; then
+            log "WARN" "Force killing process $process_id"
+            kill -KILL "$pid" 2>/dev/null || true
+            sleep 1
+        fi
+    fi
+
+    # Clean up PID file
+    rm -f "$pid_file"
+    
+    log "INFO" "Process $process_id stopped"
+
+    # Publish Redis event for coordination
+    npx redis-cli PUBLISH "$REDIS_CHANNEL" \
+        "$(jq -n \
+            --arg process "$process_id" \
+            --arg action "stop" \
+            '{process: $process, action: $action, timestamp: now}')" 2>/dev/null || true
+}
+
+# Cleanup function for orphaned processes
+cleanup_orphaned() {
+    log "INFO" "Checking for orphaned processes..."
+    
+    for pid_file in "${RUN_DIR}"/*.pid; do
+        if [[ -f "$pid_file" ]]; then
+            local process_name=$(basename "$pid_file" .pid)
+            if ! is_process_running "$pid_file"; then
+                log "INFO" "Cleaning up orphaned PID file for $process_name"
+                rm -f "$pid_file"
+            fi
+        fi
+    done
+}
+
+# Main CLI router with enhanced error handling
+main() {
+    # Cleanup orphaned processes on startup
+    cleanup_orphaned
+
+    # Validate inputs
+    if [[ -z "$PROCESS_ID" ]]; then
+        log "ERROR" "PROCESS_ID must be specified"
+        exit 1
+    fi
+
+    case "$ACTION" in
+        start)
+            start_process "$PROCESS_ID"
+            ;;
+        stop)
+            stop_process "$PROCESS_ID"
+            ;;
+        restart)
+            stop_process "$PROCESS_ID"
+            sleep 2
+            start_process "$PROCESS_ID"
+            ;;
+        status)
+            local status=$(check_process_health "$PROCESS_ID")
+            echo "$status"
+            ;;
+        health)
+            local health=$(check_process_health "$PROCESS_ID")
+            log "INFO" "Process $PROCESS_ID health: $health"
+            echo "$health"
+            ;;
+        cleanup)
+            cleanup_orphaned
+            ;;
+        *)
+            log "ERROR" "Invalid action. Use: start|stop|restart|status|health|cleanup"
+            exit 1
+            ;;
+    esac
+}
+
+# Enable verbose mode if requested
+$VERBOSE && set -x
+
+# Execute main function
+main "$@"

package/.claude/skills/cfn-project-management/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: cfn-project-management
+description: Backlog and changelog management for CFN projects
+version: 1.0.0
+tags: [mega-skill, backlog, changelog, tracking]
+status: production
+---
+
+# Project Management Skill (Mega-Skill)
+
+**Version:** 1.0.0
+**Purpose:** Backlog and changelog management for CFN projects
+**Status:** Production
+**Consolidates:** cfn-backlog-management, cfn-changelog-management
+
+---
+
+## Overview
+
+This mega-skill provides project tracking:
+- **Backlog** - Issue and task backlog management
+- **Changelog** - Version changelog generation and maintenance
+
+---
+
+## Directory Structure
+
+```
+project-management/
+├── SKILL.md
+├── lib/
+│   ├── backlog/          # From cfn-backlog-management
+│   └── changelog/        # From cfn-changelog-management
+└── cli/
+```
+
+---
+
+## Migration Paths
+
+| Old Path | New Path |
+|----------|----------|
+| cfn-backlog-management/ | project-management/lib/backlog/ |
+| cfn-changelog-management/ | project-management/lib/changelog/ |
+
+---
+
+## Version History
+
+### 1.0.0 (2025-12-02)
+- Consolidated 2 project management skills into mega-skill
+
+## Known Issues
+
+- ⚠️ **Missing Implementation**: The `lib/backlog/` and `lib/changelog/` directories referenced in the documentation do not exist
+- ⚠️ **Old Paths Missing**: The old paths referenced for migration (`cfn-backlog-management/`, `cfn-changelog-management/`) also do not exist
+- ⚠️ **Planned Consolidation**: This skill appears to be a planned consolidation that hasn't been implemented
+- ⚠️ **Use Alternative Commands**: Users should look for backlog and changelog functionality in other skills or slash commands
+- ⚠️ **Implementation Required**: This is a documentation-only skill until the consolidation is implemented
+

package/.claude/skills/cfn-provider-routing

@@ -0,0 +1 @@
+cfn-routing-config/lib/provider

package/.claude/skills/cfn-redis-coordination

@@ -0,0 +1 @@
+cfn-memory-persistence/lib/redis

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

@@ -0,0 +1,252 @@
+#!/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';
+import { URL } from 'url';
+import { fileURLToPath } from 'url';
+
+// ES module equivalents for __filename and __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+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
+    };
+  }
+}
+
+/**
+ * Helper function to determine if the module is being run directly
+ * Simplified approach for ES modules
+ */
+function isDirectExecution(): boolean {
+  try {
+    const mainModule = process.argv[1];
+    
+    if (!mainModule) {
+      return false;
+    }
+
+    // Compare the current file path with the main module path
+    const currentPath = path.resolve(__filename);
+    const mainPath = path.resolve(mainModule);
+
+    return currentPath === mainPath;
+  } catch (error) {
+    // If any error occurs during detection, assume it's not direct execution
+    return false;
+  }
+}
+
+// CLI interface for testing
+if (isDirectExecution()) {
+  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;

package/.claude/skills/cfn-session-handoff/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: cfn-session-handoff
+type: skill
+description: Session handoff functionality is provided by the handoff-coordinator agent
+version: 1.0.0
+status: delegated
+triggers:
+  - When: Session transition or context reset is needed
+  - Who: Teams requiring handoff documentation
+usage: See handoff-coordinator agent at .claude/agents/cfn-dev-team/coordinators/handoff-coordinator.md
+---
+
+# CFN Session Handoff
+
+## Status: DELEGATED TO AGENT
+
+This skill's functionality is now provided by the **handoff-coordinator agent**.
+
+## Actual Implementation Location
+
+`.claude/agents/cfn-dev-team/coordinators/handoff-coordinator.md`
+
+## Usage
+
+Instead of using this skill, invoke the handoff-coordinator agent directly:
+
+```bash
+npx claude-flow-novice agent-spawn handoff-coordinator \
+  --task-id "handoff-$(date +%s)" \
+  --prompt "Create session handoff for [domain], duration: [hours], focus: [areas]"
+```
+
+## Features Provided by Agent
+
+- Extracts recent context from conversation history
+- Generates comprehensive handoff documentation
+- Creates smoke test scripts for validation
+- Maintains context continuity across sessions
+
+## Migration Note
+
+This skill was deprecated in favor of the agent-based approach which provides:
+- Better integration with CFN Loop
+- More sophisticated context extraction
+- Direct agent-to-agent communication
+- Automated session state management
+
+## Documentation Retained
+
+This SKILL.md is retained for:
+- Historical reference
+- Search visibility
+- Redirecting users to the actual implementation