claude-flow-novice 2.15.2 → 2.15.4

package/claude-assets/skills/cfn-utilities/test.sh

@@ -0,0 +1,317 @@
+#!/usr/bin/env bash
+# CFN Utilities Test Suite
+# Tests all utility functions in lib/
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/execute.sh"
+
+# Test counters
+TESTS_RUN=0
+TESTS_PASSED=0
+TESTS_FAILED=0
+
+# Test result helpers
+pass() {
+    echo "PASS: $1"
+    TESTS_PASSED=$((TESTS_PASSED + 1))
+    TESTS_RUN=$((TESTS_RUN + 1))
+}
+
+fail() {
+    echo "FAIL: $1"
+    TESTS_FAILED=$((TESTS_FAILED + 1))
+    TESTS_RUN=$((TESTS_RUN + 1))
+}
+
+assert_equals() {
+    local expected="$1"
+    local actual="$2"
+    local test_name="$3"
+
+    if [ "$expected" = "$actual" ]; then
+        pass "$test_name"
+    else
+        fail "$test_name (expected: '$expected', got: '$actual')"
+    fi
+}
+
+assert_contains() {
+    local haystack="$1"
+    local needle="$2"
+    local test_name="$3"
+
+    if [[ "$haystack" == *"$needle"* ]]; then
+        pass "$test_name"
+    else
+        fail "$test_name (string '$needle' not found in output)"
+    fi
+}
+
+assert_success() {
+    local test_name="$1"
+    pass "$test_name"
+}
+
+assert_failure() {
+    local test_name="$1"
+    fail "$test_name"
+}
+
+# Cleanup temporary test files
+cleanup() {
+    rm -f /tmp/cfn-test-*
+}
+trap cleanup EXIT
+
+echo "=== CFN Utilities Test Suite ==="
+echo ""
+
+# ===== LOGGING TESTS =====
+echo "--- Testing Logging Functions ---"
+
+# Test: log_json outputs valid JSON
+output=$(log_json "info" "test message" '{"key":"value"}' 2>&1)
+if echo "$output" | grep -q '"timestamp"' && echo "$output" | grep -q '"level":"info"' && echo "$output" | grep -q '"message":"test message"'; then
+    pass "log_json outputs valid JSON structure"
+else
+    fail "log_json output invalid: $output"
+fi
+
+# Test: log_info outputs to stderr
+output=$(log_info "info test" '{}' 2>&1 >/dev/null)
+if echo "$output" | grep -q '"level":"info"'; then
+    pass "log_info outputs to stderr"
+else
+    fail "log_info output incorrect"
+fi
+
+# Test: log_error includes error level
+output=$(log_error "error test" '{"code":"E001"}' 2>&1)
+if echo "$output" | grep -q '"level":"error"' && echo "$output" | grep -q 'E001'; then
+    pass "log_error includes error level and context"
+else
+    fail "log_error output incorrect"
+fi
+
+# Test: log_debug respects LOG_LEVEL
+LOG_LEVEL=info
+output=$(log_debug "debug test" '{}' 2>&1)
+if [ -z "$output" ]; then
+    pass "log_debug respects LOG_LEVEL=info (no output)"
+else
+    fail "log_debug should not output when LOG_LEVEL=info"
+fi
+
+LOG_LEVEL=debug
+output=$(log_debug "debug test" '{}' 2>&1)
+if echo "$output" | grep -q '"level":"debug"'; then
+    pass "log_debug outputs when LOG_LEVEL=debug"
+else
+    fail "log_debug should output when LOG_LEVEL=debug"
+fi
+
+# Test: generate_correlation_id produces output
+corr_id=$(generate_correlation_id)
+if [ -n "$corr_id" ]; then
+    pass "generate_correlation_id produces non-empty ID"
+else
+    fail "generate_correlation_id produced empty ID"
+fi
+
+# ===== ERROR HANDLING TESTS =====
+echo ""
+echo "--- Testing Error Handling Functions ---"
+
+# Test: error_handle returns error code
+if error_handle "test error" '{}' 2>/dev/null; then
+    fail "error_handle should return non-zero exit code"
+else
+    pass "error_handle returns non-zero exit code"
+fi
+
+# Test: is_error_code detects specific codes
+EXITCODE=7
+if is_error_code $EXITCODE 7; then
+    pass "is_error_code detects correct exit code"
+else
+    fail "is_error_code should detect exit code 7"
+fi
+
+# Test: get_error_context returns JSON structure
+test_exit_42() { return 42; }
+test_exit_42 || true
+context=$(get_error_context)
+if echo "$context" | grep -q '"exit_code"' && echo "$context" | grep -q '"line"'; then
+    pass "get_error_context returns JSON structure"
+else
+    fail "get_error_context output invalid: $context"
+fi
+
+# ===== RETRY TESTS =====
+echo ""
+echo "--- Testing Retry Functions ---"
+
+# Test: retry_with_backoff succeeds on first try
+counter=0
+test_command() {
+    counter=$((counter + 1))
+    return 0
+}
+if retry_with_backoff 3 1 test_command 2>/dev/null; then
+    pass "retry_with_backoff succeeds immediately"
+else
+    fail "retry_with_backoff should succeed"
+fi
+
+# Test: retry_with_backoff retries on failure
+attempt_count=0
+failing_command() {
+    attempt_count=$((attempt_count + 1))
+    [ $attempt_count -ge 3 ]
+}
+if retry_with_backoff 5 1 failing_command 2>/dev/null; then
+    assert_equals "3" "$attempt_count" "retry_with_backoff retries correct number of times"
+else
+    fail "retry_with_backoff should eventually succeed"
+fi
+
+# Test: retry_with_backoff gives up after max attempts
+always_fail() {
+    return 1
+}
+if retry_with_backoff 2 1 always_fail 2>/dev/null; then
+    fail "retry_with_backoff should fail after max attempts"
+else
+    pass "retry_with_backoff gives up after max attempts"
+fi
+
+# Test: retry_fixed uses fixed delay
+fixed_count=0
+fixed_test() {
+    fixed_count=$((fixed_count + 1))
+    [ $fixed_count -ge 2 ]
+}
+if retry_fixed 3 1 fixed_test 2>/dev/null; then
+    pass "retry_fixed works with fixed delay"
+else
+    fail "retry_fixed should succeed"
+fi
+
+# ===== FILE OPERATIONS TESTS =====
+echo ""
+echo "--- Testing File Operations ---"
+
+# Test: atomic_write creates file
+test_file="/tmp/cfn-test-atomic-$$"
+if atomic_write "$test_file" "test content" 2>/dev/null; then
+    if [ -f "$test_file" ] && [ "$(cat "$test_file")" = "test content" ]; then
+        pass "atomic_write creates file with correct content"
+    else
+        fail "atomic_write file content incorrect"
+    fi
+else
+    fail "atomic_write failed"
+fi
+
+# Test: atomic_write is actually atomic (no .tmp files left)
+test_file2="/tmp/cfn-test-atomic2-$$"
+atomic_write "$test_file2" "content" 2>/dev/null
+if ! ls /tmp/cfn-test-atomic2-$$.tmp* 2>/dev/null; then
+    pass "atomic_write cleans up temporary files"
+else
+    fail "atomic_write left temporary files"
+fi
+
+# Test: acquire_lock creates lock file
+lock_file="/tmp/cfn-test-lock-$$"
+if acquire_lock "$lock_file" 5 2>/dev/null; then
+    if [ -f "$lock_file" ] && [ "$(cat "$lock_file")" = "$$" ]; then
+        pass "acquire_lock creates lock file with PID"
+        release_lock "$lock_file" 2>/dev/null
+    else
+        fail "acquire_lock file content incorrect"
+        release_lock "$lock_file" 2>/dev/null
+    fi
+else
+    fail "acquire_lock failed"
+fi
+
+# Test: acquire_lock blocks concurrent access
+lock_file2="/tmp/cfn-test-lock2-$$"
+acquire_lock "$lock_file2" 30 2>/dev/null
+if acquire_lock "$lock_file2" 1 2>/dev/null; then
+    fail "acquire_lock should block when lock is held"
+    release_lock "$lock_file2" 2>/dev/null
+else
+    pass "acquire_lock blocks concurrent access"
+    release_lock "$lock_file2" 2>/dev/null
+fi
+
+# Test: release_lock removes lock file
+lock_file3="/tmp/cfn-test-lock3-$$"
+acquire_lock "$lock_file3" 5 2>/dev/null
+if release_lock "$lock_file3" 2>/dev/null; then
+    if [ ! -f "$lock_file3" ]; then
+        pass "release_lock removes lock file"
+    else
+        fail "release_lock did not remove lock file"
+    fi
+else
+    fail "release_lock failed"
+fi
+
+# Test: with_lock executes command with lock
+lock_file4="/tmp/cfn-test-lock4-$$"
+output_file="/tmp/cfn-test-output-$$"
+if with_lock "$lock_file4" 5 bash -c "echo 'locked' > $output_file" 2>/dev/null; then
+    if [ -f "$output_file" ] && [ "$(cat "$output_file")" = "locked" ]; then
+        pass "with_lock executes command successfully"
+    else
+        fail "with_lock command did not execute correctly"
+    fi
+else
+    fail "with_lock failed"
+fi
+
+# Test: with_lock releases lock after execution
+if [ -f "$lock_file4" ]; then
+    fail "with_lock did not release lock after execution"
+else
+    pass "with_lock releases lock after execution"
+fi
+
+# Test: is_locked detects active locks
+lock_file5="/tmp/cfn-test-lock5-$$"
+acquire_lock "$lock_file5" 5 2>/dev/null
+if is_locked "$lock_file5"; then
+    pass "is_locked detects active lock"
+else
+    fail "is_locked should detect active lock"
+fi
+release_lock "$lock_file5" 2>/dev/null
+
+# Test: is_locked returns false when no lock
+lock_file6="/tmp/cfn-test-lock6-$$"
+if is_locked "$lock_file6"; then
+    fail "is_locked should return false when no lock exists"
+else
+    pass "is_locked returns false when no lock exists"
+fi
+
+# ===== SUMMARY =====
+echo ""
+echo "==================================="
+echo "Tests run: $TESTS_RUN"
+echo "Passed: $TESTS_PASSED"
+echo "Failed: $TESTS_FAILED"
+echo "==================================="
+
+if [ $TESTS_FAILED -eq 0 ]; then
+    echo "All tests passed!"
+    exit 0
+else
+    echo "Some tests failed!"
+    exit 1
+fi

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

@@ -1,203 +1,96 @@
-# 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
+# Docker Build Skill - WSL2 Optimized
+
+**Version:** 1.0.0
+**Purpose:** Build Docker images with 96% faster build times on WSL2 environments
+**Location:** `.claude/skills/docker-build/`
+
+## Overview
+
+This skill provides WSL2-optimized Docker image building by syncing build context to Linux native storage (`/tmp/cfn-build`) before building, avoiding severe I/O performance penalties from Windows mounts.
+
+**Performance Impact:**
+- Windows mount: 755 seconds build time
+- Linux native: 20 seconds build time
+- **96% faster builds**
+
+## Usage
+
+```bash
+# Build any Docker image (automatic detection)
+./.claude/skills/docker-build/build.sh \
+  --dockerfile docker/Dockerfile.agent \
+  --tag cfn-agent:latest
+
+# Build with custom context
+./.claude/skills/docker-build/build.sh \
+  --dockerfile docker/Dockerfile.orchestrator \
+  --tag cfn-orchestrator:latest \
+  --context ./custom-context
+
+# Specify platform
+./.claude/skills/docker-build/build.sh \
+  --dockerfile docker/Dockerfile.coordinator \
+  --tag cfn-coordinator:latest \
+  --platform linux/amd64
+```
+
+## Parameters
+
+| Parameter | Required | Description | Default |
+|-----------|----------|-------------|---------|
+| `--dockerfile` | Yes | Path to Dockerfile | - |
+| `--tag` | Yes | Image tag to build | - |
+| `--context` | No | Build context directory | Project root |
+| `--platform` | No | Target platform | Current platform |
+
+## How It Works
+
+1. **Sync Phase:** Copies build context from Windows mount to `/tmp/cfn-build/`
+2. **Build Phase:** Runs `docker build` from Linux native storage
+3. **Cleanup Phase:** Returns built image to host, removes temp directory
+
+## WSL2 Performance Context
+
+WSL2 has severe I/O performance issues when Docker accesses Windows mounts:
+- File enumeration: 0.1s (Linux) vs 755s (Windows)
+- Context transfer becomes the bottleneck
+- Every file operation crosses mount boundary
+
+This skill eliminates the bottleneck by working entirely in Linux filesystem.
+
+## Requirements
+
+- WSL2 environment
+- Docker installed and running
+- `/tmp/` writable (standard Linux configuration)
+- Sufficient disk space in `/tmp/` for build context
+
+## Error Handling
+
+- Validates Dockerfile exists
+- Validates tag is provided
+- Creates temp directory with cleanup trap
+- Preserves error codes from docker build
+- Automatic cleanup on success/failure
+
+## Integration with CFN Docker Infrastructure
+
+All CFN Docker images should use this skill:
+```bash
+# cfn-agent
+./.claude/skills/docker-build/build.sh --dockerfile docker/Dockerfile.agent --tag cfn-agent:latest
+
+# cfn-orchestrator
+./.claude/skills/docker-build/build.sh --dockerfile docker/Dockerfile.orchestrator --tag cfn-orchestrator:latest
+
+# cfn-coordinator
+./.claude/skills/docker-build/build.sh --dockerfile docker/Dockerfile.coordinator --tag cfn-coordinator:latest
+```
+
+## See Also
+
+- `docker/Dockerfile.agent` - Base agent image
+- `docker/Dockerfile.orchestrator` - Orchestration image
+- `docker/Dockerfile.coordinator` - Coordination image
+- `CLAUDE.md` lines 60-90 - Docker build requirements
+- `docs/CFN_DOCKER_INFRASTRUCTURE_REQUIREMENTS_SPEC.md` - Full infrastructure spec