claude-flow-novice 2.18.5 → 2.18.6

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-project-management/lib/backlog/SKILL.md

@@ -0,0 +1,199 @@
+---
+skill_id: cfn-backlog-management
+name: CFN Backlog Management
+version: 1.0.0
+category: coordination
+tags: [backlog, documentation, sprint-planning, technical-debt]
+dependencies: []
+---
+
+# CFN Backlog Management Skill
+
+## Purpose
+Systematically capture and track backlogged items during CFN sprints to prevent work from being forgotten. Provides centralized documentation of deferred tasks with context, rationale, and proposed solutions.
+
+## Problem Solved
+During CFN Loop execution, agents frequently identify improvements, optimizations, or edge cases that should be addressed but are out of scope for the current sprint. Without systematic capture, these items are lost in chat history or forgotten entirely.
+
+## When to Use
+- **During CFN sprints** when identifying work that should be deferred
+- **After consensus** when validators identify future improvements
+- **During retrospectives** when documenting technical debt
+- **Architecture reviews** when noting long-term refactoring needs
+
+## Interface
+
+### Primary Script: `add-backlog-item.sh`
+
+**Required Parameters:**
+- `--item`: Brief description of backlogged work (1-2 sentences)
+- `--why`: Rationale for deferring (why not now?)
+- `--solution`: Proposed implementation approach
+
+**Optional Parameters:**
+- `--sprint`: Sprint identifier (default: auto-detected from context)
+- `--priority`: P0-P3 (default: P2)
+- `--tags`: Comma-separated tags (e.g., "optimization,redis,testing")
+- `--category`: Feature/Bug/Technical-Debt/Optimization (default: Technical-Debt)
+
+**Usage:**
+```bash
+./.claude/skills/cfn-backlog-management/add-backlog-item.sh \
+  --sprint "Sprint 10" \
+  --item "Implement Redis connection pooling for multi-agent coordination" \
+  --why "Current single-connection model causes bottlenecks with 10+ agents, but Sprint 10 scope limited to 3-agent validation" \
+  --solution "Use ioredis library with configurable pool size (min: 5, max: 20). Add pool metrics to monitoring dashboard" \
+  --priority "P2" \
+  --tags "optimization,redis,performance" \
+  --category "Optimization"
+```
+
+### Output Location
+All backlog items are appended to: `readme/BACKLOG.md`
+
+## Backlog File Structure
+
+```markdown
+# Claude Flow Novice - Backlog
+
+Last Updated: 2025-10-31
+
+## Active Items
+
+### P0 - Critical
+[Items requiring immediate attention in next sprint]
+
+### P1 - High Priority
+[Items to address within 2-3 sprints]
+
+### P2 - Medium Priority
+[Items to address when capacity allows]
+
+### P3 - Low Priority / Nice-to-Have
+[Items for future consideration]
+
+## Completed Items
+[Moved here when implemented, with resolution sprint noted]
+
+---
+
+## Item Template
+
+**[PRIORITY] - [Item Title]**
+- **Sprint Backlogged**: Sprint X
+- **Category**: Feature/Bug/Technical-Debt/Optimization
+- **Description**: What needs to be done
+- **Rationale**: Why it was deferred
+- **Proposed Solution**: How to implement
+- **Tags**: `tag1`, `tag2`, `tag3`
+- **Status**: Backlogged | In Progress | Completed
+- **Date Added**: YYYY-MM-DD
+```
+
+## Validation Rules
+
+The skill enforces:
+1. **All required fields present** (item, why, solution)
+2. **Item description clarity** (≥10 characters, ≤500 characters)
+3. **Rationale specificity** (must explain deferral reason, not just "out of scope")
+4. **Solution actionability** (must include concrete implementation approach)
+5. **No duplicates** (checks existing BACKLOG.md for similar items)
+
+## Integration with CFN Loops
+
+### Loop 2 Validators
+When validators identify improvements outside current scope:
+```bash
+# In validator agent
+./.claude/skills/cfn-backlog-management/add-backlog-item.sh \
+  --item "Add integration tests for Redis failure scenarios" \
+  --why "Current sprint validates happy path only; failure testing requires additional test infrastructure" \
+  --solution "Create test-redis-failures.sh with Docker-based Redis crash simulation" \
+  --tags "testing,redis,edge-cases"
+```
+
+### Product Owner Decision
+When Product Owner defers work for future sprint:
+```bash
+# In product-owner agent
+./.claude/skills/cfn-backlog-management/add-backlog-item.sh \
+  --item "Migrate coordination from Redis to etcd for production scale" \
+  --why "Redis sufficient for current 10-agent limit; etcd needed for 100+ agent deployments" \
+  --solution "Abstract coordination layer behind interface, implement etcd adapter" \
+  --priority "P3" \
+  --category "Technical-Debt"
+```
+
+### Coordinator Context
+Coordinators can query backlog for related items before spawning agents:
+```bash
+# Check if backlog contains relevant context
+grep -i "redis pooling" readme/BACKLOG.md
+# Use results to inform agent context injection
+```
+
+## Query Interface
+
+**Search by tag:**
+```bash
+grep -A 10 "Tags:.*redis" readme/BACKLOG.md
+```
+
+**Filter by priority:**
+```bash
+sed -n '/^### P1/,/^### P2/p' readme/BACKLOG.md
+```
+
+**List all optimization items:**
+```bash
+grep -B 2 "Category: Optimization" readme/BACKLOG.md
+```
+
+## Maintenance
+
+**Weekly Review**: Product Owner reviews P0-P1 items for sprint planning
+**Monthly Cleanup**: Archive completed items, reassess P3 priorities
+**Quarterly Audit**: Remove stale items (>6 months old, no activity)
+
+## Best Practices
+
+1. **Be specific**: "Add caching" → "Implement Redis LRU cache for agent context with 1h TTL"
+2. **Explain constraints**: "Not enough time" → "Requires 8h estimation work; current sprint has 2h budget"
+3. **Provide actionable solutions**: "Fix later" → "Refactor using Strategy pattern from planning/PATTERNS.md"
+4. **Tag appropriately**: Enables filtering and sprint planning
+5. **Update status**: Move to "Completed" when resolved, note resolution sprint
+
+## Anti-Patterns
+
+❌ **Vague items**: "Improve performance" (What component? How much improvement?)
+❌ **No rationale**: "Backlog this" (Why defer? What's the blocker?)
+❌ **Solution-less**: "Fix Redis issues" (What's the approach? What research is needed?)
+❌ **Duplicate entries**: Check BACKLOG.md before adding
+❌ **Scope creep**: Backlog is for deferred work, not scope expansion
+
+## Example Backlog Item
+
+```markdown
+**[P1] - Implement Adaptive Validator Scaling**
+- **Sprint Backlogged**: Sprint 9 - CFN v3 Implementation
+- **Category**: Optimization
+- **Description**: Dynamically adjust number of Loop 2 validators (2-5) based on task complexity. Currently fixed at 3-4 validators regardless of task size.
+- **Rationale**: Sprint 9 focused on dual-mode architecture validation. Adaptive scaling requires task complexity classifier (NLP or heuristic-based), estimated 12h implementation vs 4h sprint budget.
+- **Proposed Solution**: Create task-classifier skill that analyzes task description (file count, domain keywords, integration points) and returns complexity score (0.0-1.0). Map score to validator count: <0.3 → 2 validators, 0.3-0.7 → 3-4 validators, >0.7 → 5 validators. Reference: CFN_LOOP_TASK_MODE.md section on adaptive validator scaling.
+- **Tags**: `optimization`, `cfn-loop`, `validation`, `adaptive-scaling`
+- **Status**: Backlogged
+- **Date Added**: 2025-10-31
+```
+
+## Success Metrics
+
+- **Backlog utilization**: ≥30% of backlog items addressed within 3 sprints
+- **Item clarity**: 0 items missing required fields
+- **Discovery rate**: ≥50% of technical debt captured vs lost in chat
+- **Sprint planning efficiency**: Backlog queries reduce planning time by 20%
+
+## References
+
+- **STRAT-025**: Explicit Deliverable Tracking (adaptive context)
+- **CFN Loop Documentation**: `.claude/commands/CFN_LOOP_TASK_MODE.md`
+- **Sprint Execution**: CLAUDE.md Section 6 - Sprint Context Injection