claude-flow-novice 2.15.0 → 2.15.2

package/claude-assets/skills/cfn-wave-checkpoint/save-checkpoint.sh

@@ -0,0 +1,284 @@
+#!/bin/bash
+
+################################################################################
+# CFN Wave Checkpoint - Save Execution State
+# Purpose: Persist wave execution state to Redis for recovery
+# Version: 1.0.0
+# Exit Codes: 0=success, 1=validation_error, 2=redis_error
+################################################################################
+
+set -euo pipefail
+
+# Script configuration
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../../" && pwd)"
+
+# Redis configuration
+readonly REDIS_HOST="${REDIS_HOST:-localhost}"
+readonly REDIS_PORT="${REDIS_PORT:-6379}"
+readonly DEFAULT_REDIS_DB=0
+readonly DEFAULT_TIMEOUT=30
+readonly CHECKPOINT_TTL="${CHECKPOINT_TTL:-3600}"
+
+# Helper: Check Redis connection
+check_redis_connection() {
+    if ! command -v redis-cli &> /dev/null; then
+        return 1
+    fi
+
+    redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" ping >/dev/null 2>&1
+    return $?
+}
+
+# Color codes
+readonly RED='\033[0;31m'
+readonly GREEN='\033[0;32m'
+readonly YELLOW='\033[1;33m'
+readonly BLUE='\033[0;34m'
+readonly NC='\033[0m'
+
+# Logging functions
+log_info() {
+    echo -e "${BLUE}[INFO]${NC} $(date '+%H:%M:%S') $*" >&2
+}
+
+log_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $(date '+%H:%M:%S') $*" >&2
+}
+
+log_error() {
+    echo -e "${RED}[ERROR]${NC} $(date '+%H:%M:%S') $*" >&2
+}
+
+log_warning() {
+    echo -e "${YELLOW}[WARN]${NC} $(date '+%H:%M:%S') $*" >&2
+}
+
+################################################################################
+# CHECKPOINT SAVE FUNCTION
+################################################################################
+
+save_checkpoint() {
+    local task_id="$1"
+    local wave_number="$2"
+    local container_ids="$3"
+    local spawn_time="$4"
+    local expected_count="$5"
+
+    # Validation
+    if [[ -z "$task_id" ]] || [[ -z "$wave_number" ]] || [[ -z "$expected_count" ]]; then
+        log_error "Usage: save_checkpoint TASK_ID WAVE_NUMBER CONTAINER_IDS SPAWN_TIME EXPECTED_COUNT"
+        return 1
+    fi
+
+    # Verify Redis connectivity
+    if ! check_redis_connection >/dev/null 2>&1; then
+        log_error "Redis not available - checkpoint persistence disabled"
+        log_warning "Wave execution will proceed without recovery capability"
+        return 0  # Non-fatal: continue execution
+    fi
+
+    # Build checkpoint JSON
+    local checkpoint_json
+    checkpoint_json=$(jq -n \
+        --arg task_id "$task_id" \
+        --arg wave_number "$wave_number" \
+        --arg container_ids "$container_ids" \
+        --arg spawn_time "$spawn_time" \
+        --arg expected_count "$expected_count" \
+        --arg created_at "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+        '{
+            task_id: $task_id,
+            wave_number: ($wave_number | tonumber),
+            container_ids: ($container_ids | split(",")),
+            spawn_time: ($spawn_time | tonumber),
+            expected_count: ($expected_count | tonumber),
+            created_at: $created_at,
+            status: "in_progress"
+        }')
+
+    # Generate checkpoint key
+    local checkpoint_key="cfn:wave:checkpoint:${task_id}:${wave_number}"
+
+    # Store in Redis with TTL
+    log_info "Saving checkpoint: $checkpoint_key"
+
+    if redis-cli \
+        -h "${REDIS_HOST:-localhost}" \
+        -p "${REDIS_PORT:-6379}" \
+        SET "$checkpoint_key" "$checkpoint_json" \
+        EX "${CHECKPOINT_TTL:-3600}" 2>/dev/null; then
+
+        log_success "Checkpoint saved for task=$task_id wave=$wave_number"
+
+        # Also track in a set for recovery scanning
+        redis-cli \
+            -h "${REDIS_HOST:-localhost}" \
+            -p "${REDIS_PORT:-6379}" \
+            SADD "cfn:wave:checkpoints:${task_id}" "$wave_number" 2>/dev/null || true
+
+        # Set expiry separately (SADD doesn't support EX)
+        redis-cli \
+            -h "${REDIS_HOST:-localhost}" \
+            -p "${REDIS_PORT:-6379}" \
+            EXPIRE "cfn:wave:checkpoints:${task_id}" "${CHECKPOINT_TTL:-3600}" 2>/dev/null || true
+
+        return 0
+    else
+        log_error "Failed to save checkpoint to Redis"
+        return 2
+    fi
+}
+
+################################################################################
+# CHECKPOINT EXISTS CHECK
+################################################################################
+
+checkpoint_exists() {
+    local task_id="$1"
+    local wave_number="${2:-}"
+
+    if [[ -z "$task_id" ]]; then
+        log_error "checkpoint_exists requires TASK_ID"
+        return 1
+    fi
+
+    # Verify Redis connectivity
+    if ! check_redis_connection >/dev/null 2>&1; then
+        log_warning "Redis not available - checkpoint check skipped"
+        return 1
+    fi
+
+    if [[ -z "$wave_number" ]]; then
+        # Check if any checkpoints exist for task
+        local checkpoint_count
+        checkpoint_count=$(redis-cli \
+            -h "${REDIS_HOST:-localhost}" \
+            -p "${REDIS_PORT:-6379}" \
+            SCARD "cfn:wave:checkpoints:${task_id}" 2>/dev/null || echo "0")
+
+        [[ "$checkpoint_count" -gt 0 ]]
+    else
+        # Check specific wave checkpoint
+        local checkpoint_key="cfn:wave:checkpoint:${task_id}:${wave_number}"
+        redis-cli \
+            -h "${REDIS_HOST:-localhost}" \
+            -p "${REDIS_PORT:-6379}" \
+            EXISTS "$checkpoint_key" 2>/dev/null | grep -q "^1$"
+    fi
+}
+
+################################################################################
+# GET CHECKPOINT DATA
+################################################################################
+
+get_checkpoint() {
+    local task_id="$1"
+    local wave_number="$2"
+
+    if [[ -z "$task_id" ]] || [[ -z "$wave_number" ]]; then
+        log_error "Usage: get_checkpoint TASK_ID WAVE_NUMBER"
+        return 1
+    fi
+
+    # Verify Redis connectivity
+    if ! check_redis_connection >/dev/null 2>&1; then
+        log_error "Redis not available"
+        return 2
+    fi
+
+    local checkpoint_key="cfn:wave:checkpoint:${task_id}:${wave_number}"
+
+    redis-cli \
+        -h "${REDIS_HOST:-localhost}" \
+        -p "${REDIS_PORT:-6379}" \
+        GET "$checkpoint_key" 2>/dev/null || {
+        log_error "Failed to retrieve checkpoint"
+        return 2
+    }
+}
+
+################################################################################
+# UPDATE CHECKPOINT STATUS
+################################################################################
+
+update_checkpoint_status() {
+    local task_id="$1"
+    local wave_number="$2"
+    local status="$3"
+
+    if [[ -z "$task_id" ]] || [[ -z "$wave_number" ]] || [[ -z "$status" ]]; then
+        log_error "Usage: update_checkpoint_status TASK_ID WAVE_NUMBER STATUS"
+        return 1
+    fi
+
+    # Verify Redis connectivity
+    if ! check_redis_connection >/dev/null 2>&1; then
+        log_warning "Redis not available - status update skipped"
+        return 0
+    fi
+
+    local checkpoint_key="cfn:wave:checkpoint:${task_id}:${wave_number}"
+
+    # Get existing checkpoint
+    local existing
+    existing=$(redis-cli \
+        -h "${REDIS_HOST:-localhost}" \
+        -p "${REDIS_PORT:-6379}" \
+        GET "$checkpoint_key" 2>/dev/null || echo "{}")
+
+    # Update status
+    local updated
+    updated=$(echo "$existing" | jq --arg status "$status" '.status = $status')
+
+    # Save updated checkpoint
+    redis-cli \
+        -h "${REDIS_HOST:-localhost}" \
+        -p "${REDIS_PORT:-6379}" \
+        SET "$checkpoint_key" "$updated" \
+        EX "${CHECKPOINT_TTL:-3600}" 2>/dev/null || {
+        log_error "Failed to update checkpoint status"
+        return 2
+    }
+
+    log_success "Updated checkpoint status: $status"
+    return 0
+}
+
+################################################################################
+# MAIN OPERATION DISPATCH
+################################################################################
+
+main() {
+    local operation="${1:-}"
+    shift || true
+
+    case "$operation" in
+        save)
+            # save TASK_ID WAVE_NUMBER CONTAINER_IDS SPAWN_TIME EXPECTED_COUNT
+            save_checkpoint "$@"
+            ;;
+        exists)
+            # exists TASK_ID [WAVE_NUMBER]
+            checkpoint_exists "$@"
+            ;;
+        get)
+            # get TASK_ID WAVE_NUMBER
+            get_checkpoint "$@"
+            ;;
+        update-status)
+            # update-status TASK_ID WAVE_NUMBER STATUS
+            update_checkpoint_status "$@"
+            ;;
+        *)
+            log_error "Unknown operation: $operation"
+            echo "Available operations: save, exists, get, update-status"
+            return 1
+            ;;
+    esac
+}
+
+# Execute if not sourced
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    main "$@"
+fi

package/claude-assets/skills/docker-build/SKILL.md

@@ -0,0 +1,203 @@
+# Docker Build Skill
+
+## Metadata
+- **Skill ID:** docker-build
+- **Version:** 1.0.0
+- **Category:** Build & Infrastructure
+- **Dependencies:** None
+- **Maturity:** Production
+- **Last Updated:** 2025-11-12
+
+## Purpose
+Fast Docker image building using Linux native storage to avoid WSL2 performance bottlenecks. Syncs project from Windows to Linux storage, builds image, then provides ready-to-use image.
+
+## Performance Benefits
+- **Build Time**: 755s → <20s (96% faster)
+- **Context Transfer**: 0.1s vs 755s on Windows mounts
+- **Method**: rsync to Linux native storage, build from there
+
+## Responsibilities
+1. Sync project files from Windows to Linux native storage
+2. Build Docker images using Linux filesystem
+3. Tag images appropriately for use
+4. Clean up old build artifacts
+
+## Interface
+
+### Main Entry Point
+```bash
+./.claude/skills/docker-build/build.sh \
+  [--dockerfile <path>] \
+  [--tag <name>] \
+  [--no-cache]
+```
+
+### Quick Use (Default)
+```bash
+# Build agent image (most common)
+./.claude/skills/docker-build/build.sh
+
+# Build with specific tag
+./.claude/skills/docker-build/build.sh --tag my-custom-tag
+
+# Force rebuild without cache
+./.claude/skills/docker-build/build.sh --no-cache
+```
+
+### Parameters
+- `dockerfile`: Path to Dockerfile (default: `Dockerfile.agent`)
+- `tag`: Image tag (default: `claude-flow-novice:agent`)
+- `no-cache`: Force rebuild without cache
+
+### Output
+- Docker image tagged and ready to use
+- Build time and performance stats
+- Success/failure status
+
+## Implementation Details
+
+### File Structure
+```
+.claude/skills/docker-build/
+├── SKILL.md           # This file
+└── build.sh           # Main build script (wrapper for scripts/docker/build-from-linux.sh)
+```
+
+### Build Process
+1. **Sync Phase**
+   - Rsync from Windows project directory to `/tmp/cfn-build`
+   - Excludes: node_modules, .git, legacy directories
+   - Time: ~0.1s
+
+2. **Build Phase**
+   - Docker build from Linux native storage
+   - Uses BuildKit for optimization
+   - Time: ~15-20s
+
+3. **Tag Phase**
+   - Tags image with requested name
+   - Default: `claude-flow-novice:agent`
+
+## Usage Examples
+
+### Example 1: Standard Agent Build
+```bash
+# Build with modified agent templates
+./.claude/skills/docker-build/build.sh
+
+# Wait for completion
+# Image ready: claude-flow-novice:agent
+```
+
+### Example 2: Custom Build
+```bash
+# Build with custom Dockerfile and tag
+./.claude/skills/docker-build/build.sh \
+  --dockerfile Dockerfile.custom \
+  --tag my-project:latest
+```
+
+### Example 3: Force Rebuild
+```bash
+# Rebuild everything from scratch
+./.claude/skills/docker-build/build.sh --no-cache
+```
+
+## Integration Points
+
+### Used By
+- B10 TypeScript fix tests
+- Docker agent testing
+- CFN Loop container execution
+- Development workflows
+
+### Depends On
+- `scripts/docker/build-from-linux.sh` (core build logic)
+- `scripts/docker/linux-build.config` (configuration)
+- Linux native filesystem at `/tmp/cfn-build`
+
+## Error Handling
+
+### Common Issues
+
+**Issue**: Rsync fails
+- **Cause**: Permission issues or disk space
+- **Solution**: Check `/tmp` permissions and disk space
+
+**Issue**: Docker build fails
+- **Cause**: Syntax errors in Dockerfile or missing files
+- **Solution**: Check Dockerfile and .dockerignore patterns
+
+**Issue**: Image not tagged correctly
+- **Cause**: Build failed but not caught
+- **Solution**: Check build logs for errors
+
+## Performance Monitoring
+
+### Metrics Tracked
+- Sync time (should be <1s)
+- Build time (should be <30s)
+- Total time
+- Image size
+
+### Expected Performance
+```
+Sync time: 0.1s
+Build time: 15-20s
+Total time: <25s
+Image size: ~443MB
+```
+
+## Maintenance
+
+### When to Update
+- Agent definitions change
+- Source code changes
+- Dependencies update
+- Dockerfile modifications
+
+### Cleanup
+```bash
+# Remove old build directory
+rm -rf /tmp/cfn-build
+
+# Remove old images
+docker image prune -f
+```
+
+## Success Criteria
+- ✅ Build completes in <30s
+- ✅ Image tagged correctly
+- ✅ Image size reasonable (<500MB)
+- ✅ No build errors or warnings
+
+## Skill Invocation from Main Chat
+
+### Quick Commands
+```bash
+# Rebuild Docker image after agent changes
+Skill: docker-build
+
+# Rebuild with no cache
+Skill: docker-build --no-cache
+
+# Custom build
+Skill: docker-build --tag my-image:v1
+```
+
+### When to Use This Skill
+- After modifying agent templates (`.claude/agents/`)
+- After changing source code
+- After updating dependencies
+- Before running Docker-based tests
+- When WSL2 build is too slow
+
+## Related Skills
+- `cfn-loop-orchestration`: Uses Docker images for agent execution
+- `cfn-coordination`: Coordinates Docker container agents
+
+## Notes
+- **WSL2 Performance**: Direct Docker builds from Windows mounts are 96% slower
+- **Linux Native**: Building from `/tmp/cfn-build` is near-instant
+- **Automatic Sync**: Script handles sync automatically
+- **Safe**: Original Windows files never modified

package/claude-assets/skills/docker-build/build.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+# Docker Build Skill - Fast builds using Linux native storage
+set -euo pipefail
+
+# Defaults
+DOCKERFILE="Dockerfile.agent"
+TAG="claude-flow-novice:agent"
+NO_CACHE=""
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --dockerfile)
+            DOCKERFILE="$2"
+            shift 2
+            ;;
+        --tag)
+            TAG="$2"
+            shift 2
+            ;;
+        --no-cache)
+            NO_CACHE="--no-cache"
+            shift
+            ;;
+        *)
+            echo "Unknown option: $1"
+            echo "Usage: $0 [--dockerfile <path>] [--tag <name>] [--no-cache]"
+            exit 1
+            ;;
+    esac
+done
+
+echo "🐳 Docker Build Skill"
+echo "===================="
+echo "Dockerfile: $DOCKERFILE"
+echo "Tag: $TAG"
+echo "No Cache: ${NO_CACHE:-false}"
+echo ""
+
+# Get project root (skill is in .claude/skills/docker-build/)
+SKILL_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SKILL_DIR/../../.." && pwd)"
+
+cd "$PROJECT_ROOT"
+
+# Check if Linux build script exists
+if [ ! -f "./scripts/docker/build-from-linux.sh" ]; then
+    echo "❌ Error: scripts/docker/build-from-linux.sh not found"
+    exit 1
+fi
+
+# Export settings for build script
+export DOCKERFILE
+export TAG
+export DOCKER_BUILD_ARGS="$NO_CACHE"
+
+# Run the build
+echo "🚀 Starting build process..."
+./scripts/docker/build-from-linux.sh
+
+BUILD_EXIT=$?
+
+if [ $BUILD_EXIT -eq 0 ]; then
+    echo ""
+    echo "✅ Build complete!"
+    echo "   Image: $TAG"
+    echo ""
+    docker images | grep "$(echo $TAG | cut -d: -f1)" | head -3
+else
+    echo ""
+    echo "❌ Build failed with exit code $BUILD_EXIT"
+    exit $BUILD_EXIT
+fi

package/dist/agent/skill-mcp-selector.js

@@ -267,7 +267,7 @@ let SkillMCPSelector = class SkillMCPSelector {
                     '-e',
                     `MCP_AUTH_REQUIRED=true`,
                     '-e',
-                    `MCP_REDIS_URL=${process.env.MCP_REDIS_URL || 'redis://localhost:6379'}`,
+                    `MCP_REDIS_URL=${process.env.CFN_REDIS_URL || process.env.MCP_REDIS_URL || `redis://${process.env.CFN_REDIS_HOST || 'cfn-redis'}:${process.env.CFN_REDIS_PORT || 6379}`}`,
                     serverConfig.containerImage,
                     'node',
                     `/app/mcp-${serverName}-server.js`