claude-flow-novice 2.6.0 → 2.9.0

package/.claude/skills/event-bus/invoke-event-publish.sh

@@ -1,147 +0,0 @@
-#!/bin/bash
-#
-# Event Bus - Publish Event CLI Wrapper
-#
-# Usage:
-#   ./invoke-event-publish.sh --topic <topic> --payload <json> [--trace-id <id>]
-#
-# Examples:
-#   # Basic event publishing
-#   ./invoke-event-publish.sh \
-#     --topic "task:completed" \
-#     --payload '{"taskId": "auth", "agentId": "backend-dev-1", "confidence": 0.92}'
-#
-#   # Publishing with trace ID
-#   ./invoke-event-publish.sh \
-#     --topic "validation:passed" \
-#     --payload '{"validator": "security-agent", "checks": ["auth"]}' \
-#     --trace-id "trace-123-abc"
-
-set -euo pipefail
-
-# Script directory
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-
-# Parse arguments
-TOPIC=""
-PAYLOAD=""
-TRACE_ID=""
-
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        --topic)
-            TOPIC="$2"
-            shift 2
-            ;;
-        --payload)
-            PAYLOAD="$2"
-            shift 2
-            ;;
-        --trace-id)
-            TRACE_ID="$2"
-            shift 2
-            ;;
-        *)
-            echo "Unknown argument: $1"
-            exit 1
-            ;;
-    esac
-done
-
-# Validate required arguments
-if [ -z "$TOPIC" ] || [ -z "$PAYLOAD" ]; then
-    echo "Error: --topic and --payload are required"
-    echo ""
-    echo "Usage: $0 --topic <topic> --payload <json> [--trace-id <id>]"
-    echo ""
-    echo "Examples:"
-    echo "  $0 --topic task:completed --payload '{\"taskId\": \"auth\"}'"
-    echo "  $0 --topic validation:passed --payload '{...}' --trace-id trace-123"
-    exit 1
-fi
-
-# Validate JSON payload
-if ! echo "$PAYLOAD" | jq empty 2>/dev/null; then
-    echo "Error: Invalid JSON payload"
-    exit 1
-fi
-
-# Build event object
-EVENT_ID="evt-$(date +%s)-$(printf '%04d' $RANDOM)"
-TIMESTAMP=$(date +%s)
-
-EVENT_DATA=$(jq -n \
-    --arg eventId "$EVENT_ID" \
-    --arg topic "$TOPIC" \
-    --argjson payload "$PAYLOAD" \
-    --arg traceId "$TRACE_ID" \
-    --arg timestamp "$TIMESTAMP" \
-    '{
-        eventId: $eventId,
-        topic: $topic,
-        payload: $payload,
-        traceId: (if $traceId == "" then null else $traceId end),
-        timestamp: ($timestamp | tonumber),
-        publishedAt: (now | todate)
-    }' 2>&1)
-
-# Debug output
-if [ "${EVENTBUS_DEBUG:-false}" == "true" ]; then
-    echo "[DEBUG] EVENT_DATA: $EVENT_DATA" >&2
-fi
-
-# Check if EVENT_DATA is empty
-if [ -z "$EVENT_DATA" ]; then
-    echo "Error: Failed to generate event data"
-    exit 1
-fi
-
-# Publish event via Node.js event bus
-# Create temp script to avoid heredoc issues
-TEMP_SCRIPT=$(mktemp)
-trap "rm -f $TEMP_SCRIPT" EXIT
-
-cat > "$TEMP_SCRIPT" << 'EOF'
-const path = require('path');
-const { eventBus } = require(path.join(process.env.PROJECT_ROOT, '.claude', 'skills', 'event-bus', 'eventbus-wrapper.cjs'));
-
-const eventData = JSON.parse(process.env.EVENT_DATA);
-
-try {
-    // Emit the event
-    eventBus.emitEvent(eventData.topic, eventData.payload);
-
-    // Return success result
-    console.log(JSON.stringify({
-        status: 'published',
-        eventId: eventData.eventId,
-        topic: eventData.topic,
-        timestamp: eventData.timestamp,
-        traceId: eventData.traceId || null
-    }));
-} catch (error) {
-    console.error(JSON.stringify({
-        status: 'error',
-        error: error.message,
-        topic: eventData.topic
-    }));
-    process.exit(1);
-}
-EOF
-
-export EVENT_DATA
-export PROJECT_ROOT
-RESULT=$(node "$TEMP_SCRIPT")
-
-# Output result
-echo "$RESULT" | jq '.'
-
-# Log successful publish
-if [ "${EVENTBUS_DEBUG:-false}" == "true" ]; then
-    echo "[EventBus] Published event: $TOPIC (ID: $EVENT_ID)" >&2
-    [ -n "$TRACE_ID" ] && echo "[EventBus] Trace ID: $TRACE_ID" >&2
-fi
-
-# Return event ID for chaining
-echo "$RESULT" | jq -r '.eventId'

package/.claude/skills/event-bus/invoke-event-subscribe.sh

@@ -1,171 +0,0 @@
-#!/bin/bash
-#
-# Event Bus - Subscribe to Events CLI Wrapper
-#
-# Usage:
-#   ./invoke-event-subscribe.sh --topic <topic> --callback <function> [--filter <jq-expr>]
-#
-# Examples:
-#   # Basic subscription
-#   ./invoke-event-subscribe.sh \
-#     --topic "agent:completed" \
-#     --callback "handle_agent_complete"
-#
-#   # Filtered subscription
-#   ./invoke-event-subscribe.sh \
-#     --topic "agent:completed" \
-#     --filter 'select(.confidence >= 0.90)' \
-#     --callback "handle_high_confidence"
-
-set -euo pipefail
-
-# Script directory
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-
-# Parse arguments
-TOPIC=""
-CALLBACK=""
-FILTER=""
-
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        --topic)
-            TOPIC="$2"
-            shift 2
-            ;;
-        --callback)
-            CALLBACK="$2"
-            shift 2
-            ;;
-        --filter)
-            FILTER="$2"
-            shift 2
-            ;;
-        *)
-            echo "Unknown argument: $1"
-            exit 1
-            ;;
-    esac
-done
-
-# Validate required arguments
-if [ -z "$TOPIC" ] || [ -z "$CALLBACK" ]; then
-    echo "Error: --topic and --callback are required"
-    echo ""
-    echo "Usage: $0 --topic <topic> --callback <function> [--filter <jq-expr>]"
-    echo ""
-    echo "Examples:"
-    echo "  $0 --topic agent:completed --callback handle_agent_complete"
-    echo "  $0 --topic agent:completed --filter 'select(.confidence >= 0.90)' --callback handle_high"
-    exit 1
-fi
-
-# Validate callback function exists
-if ! declare -f "$CALLBACK" >/dev/null 2>&1; then
-    echo "Warning: Callback function '$CALLBACK' is not defined in current shell"
-    echo "Ensure the function is defined before events are received"
-fi
-
-# Generate subscription ID
-SUB_ID="sub-$(date +%s)-$(printf '%04d' $RANDOM)"
-
-# Create subscription handler script
-HANDLER_SCRIPT=$(mktemp)
-trap "rm -f $HANDLER_SCRIPT" EXIT
-
-cat > "$HANDLER_SCRIPT" <<'EOF'
-const path = require('path');
-const { eventBus } = require(path.join(process.env.PROJECT_ROOT, '.claude', 'core', 'event-bus.js'));
-const { spawn } = require('child_process');
-
-const topic = process.env.TOPIC;
-const callback = process.env.CALLBACK;
-const filter = process.env.FILTER || '';
-const subId = process.env.SUB_ID;
-
-// Define event handler
-const handler = (data) => {
-    let eventData = data;
-
-    // Apply filter if provided
-    if (filter) {
-        try {
-            const filterProc = spawn('jq', ['-e', filter], {
-                stdio: ['pipe', 'pipe', 'inherit']
-            });
-
-            filterProc.stdin.write(JSON.stringify(data));
-            filterProc.stdin.end();
-
-            filterProc.on('exit', (code) => {
-                if (code === 0) {
-                    // Filter passed, invoke callback
-                    invokeCallback(data);
-                }
-            });
-        } catch (error) {
-            console.error(`[EventBus] Filter error for ${topic}:`, error.message);
-        }
-    } else {
-        // No filter, invoke callback directly
-        invokeCallback(data);
-    }
-};
-
-// Invoke bash callback function
-function invokeCallback(data) {
-    const proc = spawn('bash', ['-c', `${callback} '${JSON.stringify(data)}'`], {
-        stdio: 'inherit',
-        env: { ...process.env, EVENT_DATA: JSON.stringify(data) }
-    });
-
-    proc.on('error', (error) => {
-        console.error(`[EventBus] Callback error for ${callback}:`, error.message);
-    });
-}
-
-// Register event listener
-eventBus.on(topic, handler);
-
-console.log(JSON.stringify({
-    status: 'subscribed',
-    subscriptionId: subId,
-    topic: topic,
-    callback: callback,
-    filter: filter || null,
-    timestamp: Date.now()
-}));
-
-// Keep process alive
-console.error(`[EventBus] Listening for events on topic: ${topic}`);
-console.error(`[EventBus] Subscription ID: ${subId}`);
-console.error('[EventBus] Press Ctrl+C to unsubscribe');
-
-// Handle graceful shutdown
-process.on('SIGINT', () => {
-    console.error('\n[EventBus] Unsubscribing...');
-    eventBus.off(topic, handler);
-    console.log(JSON.stringify({
-        status: 'unsubscribed',
-        subscriptionId: subId,
-        topic: topic
-    }));
-    process.exit(0);
-});
-EOF
-
-# Execute subscription handler
-export PROJECT_ROOT
-export TOPIC
-export CALLBACK
-export FILTER
-export SUB_ID
-
-if [ "${EVENTBUS_DEBUG:-false}" == "true" ]; then
-    echo "[EventBus] Creating subscription: $TOPIC -> $CALLBACK" >&2
-    [ -n "$FILTER" ] && echo "[EventBus] Filter: $FILTER" >&2
-fi
-
-# Run handler (blocks until Ctrl+C)
-node "$HANDLER_SCRIPT"

package/.claude/skills/event-bus/invoke-lifecycle-track.sh

@@ -1,201 +0,0 @@
-#!/bin/bash
-#
-# Event Bus - Agent Lifecycle Tracking CLI Wrapper
-#
-# Usage:
-#   ./invoke-lifecycle-track.sh --agent-id <id> --event <type> --metadata <json>
-#
-# Event Types:
-#   - spawn: Agent created and initialized
-#   - complete: Agent successfully finished task
-#   - fail: Agent encountered critical error
-#   - timeout: Agent exceeded execution time limit
-#
-# Examples:
-#   # Track agent spawn
-#   ./invoke-lifecycle-track.sh \
-#     --agent-id "backend-dev-1" \
-#     --event "spawn" \
-#     --metadata '{"taskId": "auth-system", "role": "backend-developer"}'
-#
-#   # Track agent completion
-#   ./invoke-lifecycle-track.sh \
-#     --agent-id "backend-dev-1" \
-#     --event "complete" \
-#     --metadata '{"taskId": "auth-system", "confidence": 0.92, "duration": 45000}'
-#
-#   # Track agent failure
-#   ./invoke-lifecycle-track.sh \
-#     --agent-id "backend-dev-1" \
-#     --event "fail" \
-#     --metadata '{"taskId": "auth-system", "error": "TypeScript compilation failed"}'
-#
-#   # Track agent timeout
-#   ./invoke-lifecycle-track.sh \
-#     --agent-id "backend-dev-1" \
-#     --event "timeout" \
-#     --metadata '{"taskId": "auth-system", "timeLimit": 300000, "elapsed": 305000}'
-
-set -euo pipefail
-
-# Script directory
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-
-# Parse arguments
-AGENT_ID=""
-EVENT_TYPE=""
-METADATA=""
-
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        --agent-id)
-            AGENT_ID="$2"
-            shift 2
-            ;;
-        --event)
-            EVENT_TYPE="$2"
-            shift 2
-            ;;
-        --metadata)
-            METADATA="$2"
-            shift 2
-            ;;
-        *)
-            echo "Unknown argument: $1"
-            exit 1
-            ;;
-    esac
-done
-
-# Validate required arguments
-if [ -z "$AGENT_ID" ] || [ -z "$EVENT_TYPE" ] || [ -z "$METADATA" ]; then
-    echo "Error: --agent-id, --event, and --metadata are required"
-    echo ""
-    echo "Usage: $0 --agent-id <id> --event <type> --metadata <json>"
-    echo ""
-    echo "Event Types: spawn, complete, fail, timeout"
-    echo ""
-    echo "Examples:"
-    echo "  $0 --agent-id backend-dev-1 --event spawn --metadata '{\"taskId\": \"auth\"}'"
-    echo "  $0 --agent-id backend-dev-1 --event complete --metadata '{\"confidence\": 0.92}'"
-    exit 1
-fi
-
-# Validate event type
-VALID_EVENTS=("spawn" "complete" "fail" "timeout")
-if [[ ! " ${VALID_EVENTS[@]} " =~ " ${EVENT_TYPE} " ]]; then
-    echo "Error: Invalid event type '$EVENT_TYPE'"
-    echo "Valid types: ${VALID_EVENTS[*]}"
-    exit 1
-fi
-
-# Validate JSON metadata
-if ! echo "$METADATA" | jq empty 2>/dev/null; then
-    echo "Error: Invalid JSON metadata"
-    exit 1
-fi
-
-# Build lifecycle event
-TIMESTAMP=$(date +%s)
-TRACKING_ID="track-$(date +%s)-$(printf '%04d' $RANDOM)"
-
-LIFECYCLE_EVENT=$(jq -n \
-    --arg trackingId "$TRACKING_ID" \
-    --arg eventType "lifecycle" \
-    --arg stage "$EVENT_TYPE" \
-    --arg agentId "$AGENT_ID" \
-    --argjson metadata "$METADATA" \
-    --arg timestamp "$TIMESTAMP" \
-    '{
-        trackingId: $trackingId,
-        eventType: $eventType,
-        stage: $stage,
-        agentId: $agentId,
-        timestamp: ($timestamp | tonumber),
-        recordedAt: (now | todate),
-        metadata: $metadata
-    }')
-
-# Determine event topic based on lifecycle stage
-case "$EVENT_TYPE" in
-    spawn)
-        TOPIC="agent:spawned"
-        ;;
-    complete)
-        TOPIC="agent:completed"
-        ;;
-    fail)
-        TOPIC="agent:failed"
-        ;;
-    timeout)
-        TOPIC="agent:timeout"
-        ;;
-esac
-
-# Publish lifecycle event
-# Create temp script to avoid heredoc issues
-TEMP_SCRIPT=$(mktemp)
-trap "rm -f $TEMP_SCRIPT" EXIT
-
-cat > "$TEMP_SCRIPT" << 'EOF'
-const path = require('path');
-const { eventBus } = require(path.join(process.env.PROJECT_ROOT, '.claude', 'skills', 'event-bus', 'eventbus-wrapper.cjs'));
-
-const lifecycleEvent = JSON.parse(process.env.LIFECYCLE_EVENT);
-const topic = process.env.TOPIC;
-
-try {
-    // Emit lifecycle event
-    eventBus.emitEvent(topic, lifecycleEvent);
-
-    // Also emit generic lifecycle event
-    eventBus.emitEvent('lifecycle', lifecycleEvent);
-
-    // Return success result
-    console.log(JSON.stringify({
-        status: 'tracked',
-        trackingId: lifecycleEvent.trackingId,
-        agentId: lifecycleEvent.agentId,
-        event: lifecycleEvent.stage,
-        topic: topic,
-        timestamp: lifecycleEvent.timestamp
-    }));
-} catch (error) {
-    console.error(JSON.stringify({
-        status: 'error',
-        error: error.message,
-        agentId: lifecycleEvent.agentId,
-        event: lifecycleEvent.stage
-    }));
-    process.exit(1);
-}
-EOF
-
-export LIFECYCLE_EVENT
-export PROJECT_ROOT
-export TOPIC
-RESULT=$(node "$TEMP_SCRIPT")
-
-# Output result
-echo "$RESULT" | jq '.'
-
-# Log successful tracking
-if [ "${EVENTBUS_DEBUG:-false}" == "true" ]; then
-    echo "[EventBus] Lifecycle tracked: $AGENT_ID -> $EVENT_TYPE (ID: $TRACKING_ID)" >&2
-    echo "[EventBus] Published to topics: $TOPIC, lifecycle" >&2
-fi
-
-# Optional: Store lifecycle event in Redis for persistence
-if [ "${EVENTBUS_PERSIST:-false}" == "true" ]; then
-    LIFECYCLE_KEY="lifecycle:${AGENT_ID}"
-    echo "$LIFECYCLE_EVENT" | redis-cli -x LPUSH "$LIFECYCLE_KEY" >/dev/null
-    redis-cli EXPIRE "$LIFECYCLE_KEY" 86400 >/dev/null  # 24-hour TTL
-
-    if [ "${EVENTBUS_DEBUG:-false}" == "true" ]; then
-        echo "[EventBus] Persisted to Redis: $LIFECYCLE_KEY" >&2
-    fi
-fi
-
-# Return tracking ID for reference
-echo "$RESULT" | jq -r '.trackingId'