claude-flow-novice 2.9.0 → 2.10.0

package/.claude/skills/cfn-event-bus/eventbus-wrapper.cjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+/**
+ * Event Bus Wrapper - Standalone Implementation
+ *
+ * Provides a simple event bus without external dependencies
+ */
+
+const EventEmitter = require('events');
+
+class SimpleEventBus extends EventEmitter {
+    constructor() {
+        super();
+        this.eventCounts = new Map();
+        this.lastEventTimes = new Map();
+        this.setMaxListeners(100); // Prevent memory leak warnings
+    }
+
+    /**
+     * Emit an event with tracking
+     */
+    emitEvent(topic, payload) {
+        // Track event metrics
+        const count = this.eventCounts.get(topic) || 0;
+        this.eventCounts.set(topic, count + 1);
+        this.lastEventTimes.set(topic, Date.now());
+
+        // Emit the event
+        this.emit(topic, payload);
+    }
+
+    /**
+     * Get event statistics
+     */
+    getEventStats() {
+        const stats = [];
+        for (const [event, count] of this.eventCounts.entries()) {
+            const lastTime = this.lastEventTimes.get(event);
+            stats.push({
+                event: String(event),
+                count,
+                lastEmitted: lastTime ? new Date(lastTime) : null
+            });
+        }
+        return stats.sort((a, b) => b.count - a.count);
+    }
+
+    /**
+     * Reset event statistics
+     */
+    resetStats() {
+        this.eventCounts.clear();
+        this.lastEventTimes.clear();
+    }
+}
+
+// Singleton instance
+let instance = null;
+
+function getInstance() {
+    if (!instance) {
+        instance = new SimpleEventBus();
+    }
+    return instance;
+}
+
+module.exports = {
+    eventBus: getInstance(),
+    SimpleEventBus
+};

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

@@ -0,0 +1,147 @@
+#!/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/.claude/skills/cfn-cfn-.claude/skills/cfn-cfn-.." && 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/cfn-event-bus/invoke-event-subscribe.sh

@@ -0,0 +1,171 @@
+#!/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/.claude/skills/cfn-cfn-.claude/skills/cfn-cfn-.." && 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/cfn-event-bus/invoke-lifecycle-track.sh

@@ -0,0 +1,201 @@
+#!/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/.claude/skills/cfn-cfn-.claude/skills/cfn-cfn-.." && 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'