claude-flow-novice 2.18.6 → 2.18.7

package/claude-assets/skills/cfn-memory-persistence/lib/redis/dist/waiting-coordinator.js

@@ -1,419 +0,0 @@
-"use strict";
-/**
- * Waiting Coordinator
- *
- * Handles blocking coordination using Redis BLPOP for agents to wait
- * for specific conditions (gate passed, consensus reached, etc).
- *
- * Migrated from:
- * - invoke-waiting-mode.sh (223 lines)
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WaitingCoordinator = void 0;
-const types_1 = require("./types");
-class WaitingCoordinator {
-    redis;
-    logger;
-    constructor(redis, logger) {
-        this.redis = redis;
-        this.logger = logger;
-    }
-    /**
-     * Wait for a specific condition with BLPOP (blocking)
-     *
-     * Blocks until condition is signaled or timeout occurs.
-     * In Task Mode: Returns immediately with false
-     * In CLI Mode: Blocks on Redis list
-     */
-    async waitForCompletion(taskId, agentId, timeoutSeconds = 300, namespace = 'swarm') {
-        // Validate inputs
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        if (!(0, types_1.isValidAgentId)(agentId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid agent ID: ${agentId}`);
-        }
-        const startTime = Date.now();
-        // Graceful no-op in Task Mode
-        if (!this.redis.canUseRedis) {
-            this.logger.info(`Task Mode: Wait for completion skipped (no Redis) - Agent: ${agentId}`);
-            return {
-                condition: 'agent-completion',
-                met: true,
-                timedOut: false,
-                waitedMs: 0
-            };
-        }
-        // CLI Mode: Block on Redis list
-        const doneKey = `${namespace}:${taskId}:${agentId}:done`;
-        try {
-            this.logger.info(`⏳ Waiting for completion: ${agentId} (timeout: ${timeoutSeconds}s)`);
-            // BLPOP with timeout (Redis timeout in seconds)
-            const result = await this.redis.blpop(doneKey, timeoutSeconds);
-            const waitedMs = Date.now() - startTime;
-            if (result) {
-                this.logger.info(`✅ Agent completed: ${agentId} (waited ${waitedMs}ms)`);
-                return {
-                    condition: 'agent-completion',
-                    met: true,
-                    timedOut: false,
-                    waitedMs,
-                    metadata: { signal: result[1] }
-                };
-            }
-            else {
-                this.logger.warn(`⏱️ Timeout waiting for agent: ${agentId} (${timeoutSeconds}s)`);
-                return {
-                    condition: 'agent-completion',
-                    met: false,
-                    timedOut: true,
-                    waitedMs
-                };
-            }
-        }
-        catch (error) {
-            this.logger.error('Failed to wait for completion', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to wait for completion: ${error.message}`);
-        }
-    }
-    /**
-     * Wait for gate to pass (test pass rate threshold)
-     *
-     * Blocks until gate-passed signal is received.
-     * In Task Mode: Returns immediately with true
-     * In CLI Mode: Blocks on Redis list
-     */
-    async waitForGate(taskId, timeoutSeconds = 600, namespace = 'swarm') {
-        // Validate input
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        const startTime = Date.now();
-        // Graceful no-op in Task Mode
-        if (!this.redis.canUseRedis) {
-            this.logger.info('Task Mode: Wait for gate skipped (no Redis)');
-            return {
-                condition: 'gate-passed',
-                met: true,
-                timedOut: false,
-                waitedMs: 0
-            };
-        }
-        // CLI Mode: Block on Redis list
-        const gateKey = `${namespace}:${taskId}:gate-passed`;
-        try {
-            this.logger.info(`⏳ Waiting for gate to pass (timeout: ${timeoutSeconds}s)`);
-            // BLPOP with timeout
-            const result = await this.redis.blpop(gateKey, timeoutSeconds);
-            const waitedMs = Date.now() - startTime;
-            if (result) {
-                this.logger.info(`✅ Gate passed (waited ${waitedMs}ms)`);
-                return {
-                    condition: 'gate-passed',
-                    met: true,
-                    timedOut: false,
-                    waitedMs,
-                    metadata: { signal: result[1] }
-                };
-            }
-            else {
-                this.logger.warn(`⏱️ Timeout waiting for gate (${timeoutSeconds}s)`);
-                return {
-                    condition: 'gate-passed',
-                    met: false,
-                    timedOut: true,
-                    waitedMs
-                };
-            }
-        }
-        catch (error) {
-            this.logger.error('Failed to wait for gate', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to wait for gate: ${error.message}`);
-        }
-    }
-    /**
-     * Wait for consensus to be reached from validators
-     *
-     * Blocks until consensus signal is received.
-     * In Task Mode: Returns immediately with true
-     * In CLI Mode: Blocks on Redis list
-     */
-    async waitForConsensus(taskId, timeoutSeconds = 600, namespace = 'swarm') {
-        // Validate input
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        const startTime = Date.now();
-        // Graceful no-op in Task Mode
-        if (!this.redis.canUseRedis) {
-            this.logger.info('Task Mode: Wait for consensus skipped (no Redis)');
-            return {
-                condition: 'consensus-reached',
-                met: true,
-                timedOut: false,
-                waitedMs: 0
-            };
-        }
-        // CLI Mode: Block on Redis list
-        const consensusKey = `${namespace}:${taskId}:consensus-reached`;
-        try {
-            this.logger.info(`⏳ Waiting for consensus (timeout: ${timeoutSeconds}s)`);
-            // BLPOP with timeout
-            const result = await this.redis.blpop(consensusKey, timeoutSeconds);
-            const waitedMs = Date.now() - startTime;
-            if (result) {
-                this.logger.info(`✅ Consensus reached (waited ${waitedMs}ms)`);
-                return {
-                    condition: 'consensus-reached',
-                    met: true,
-                    timedOut: false,
-                    waitedMs,
-                    metadata: { signal: result[1] }
-                };
-            }
-            else {
-                this.logger.warn(`⏱️ Timeout waiting for consensus (${timeoutSeconds}s)`);
-                return {
-                    condition: 'consensus-reached',
-                    met: false,
-                    timedOut: true,
-                    waitedMs
-                };
-            }
-        }
-        catch (error) {
-            this.logger.error('Failed to wait for consensus', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to wait for consensus: ${error.message}`);
-        }
-    }
-    /**
-     * Wait for custom condition by key name
-     *
-     * Generic wait mechanism for any condition.
-     * In Task Mode: Returns immediately with true
-     * In CLI Mode: Blocks on Redis list
-     */
-    async waitForCondition(taskId, conditionName, timeoutSeconds = 300, namespace = 'swarm') {
-        // Validate input
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        if (!conditionName || conditionName.length === 0) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, 'Condition name cannot be empty');
-        }
-        const startTime = Date.now();
-        // Graceful no-op in Task Mode
-        if (!this.redis.canUseRedis) {
-            this.logger.info(`Task Mode: Wait for condition skipped (no Redis) - ${conditionName}`);
-            return {
-                condition: conditionName,
-                met: true,
-                timedOut: false,
-                waitedMs: 0
-            };
-        }
-        // CLI Mode: Block on Redis list
-        const conditionKey = `${namespace}:${taskId}:${conditionName}`;
-        try {
-            this.logger.info(`⏳ Waiting for condition: ${conditionName} (timeout: ${timeoutSeconds}s)`);
-            // BLPOP with timeout
-            const result = await this.redis.blpop(conditionKey, timeoutSeconds);
-            const waitedMs = Date.now() - startTime;
-            if (result) {
-                this.logger.info(`✅ Condition met: ${conditionName} (waited ${waitedMs}ms)`);
-                return {
-                    condition: conditionName,
-                    met: true,
-                    timedOut: false,
-                    waitedMs,
-                    metadata: { signal: result[1] }
-                };
-            }
-            else {
-                this.logger.warn(`⏱️ Timeout waiting for condition: ${conditionName} (${timeoutSeconds}s)`);
-                return {
-                    condition: conditionName,
-                    met: false,
-                    timedOut: true,
-                    waitedMs
-                };
-            }
-        }
-        catch (error) {
-            this.logger.error('Failed to wait for condition', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to wait for condition ${conditionName}: ${error.message}`);
-        }
-    }
-    /**
-     * Signal a condition to wake waiting agents
-     *
-     * In Task Mode: Logs and returns gracefully
-     * In CLI Mode: Pushes signal to Redis list
-     */
-    async signalCondition(taskId, conditionName, metadata, namespace = 'swarm') {
-        // Validate input
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        if (!conditionName || conditionName.length === 0) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, 'Condition name cannot be empty');
-        }
-        const timestamp = new Date().toISOString();
-        // Graceful no-op in Task Mode
-        if (!this.redis.canUseRedis) {
-            this.logger.info(`Task Mode: Condition signal skipped (no Redis) - ${conditionName}`);
-            return {
-                agentId: 'orchestrator',
-                signalType: conditionName,
-                status: 'signaled',
-                timestamp
-            };
-        }
-        // CLI Mode: Push signal to Redis
-        const conditionKey = `${namespace}:${taskId}:${conditionName}`;
-        try {
-            const payload = JSON.stringify({
-                conditionName,
-                timestamp,
-                metadata: metadata || {}
-            });
-            await this.redis.lpush(conditionKey, payload);
-            // Set TTL (1 hour - long enough for agents to see it)
-            await this.redis.expire(conditionKey, 3600);
-            this.logger.info(`✅ Signal sent: ${conditionName}`);
-            return {
-                agentId: 'orchestrator',
-                signalType: conditionName,
-                status: 'signaled',
-                timestamp
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to signal condition', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to signal condition ${conditionName}: ${error.message}`);
-        }
-    }
-    /**
-     * Wait for multiple agents to complete with parallel blocking
-     *
-     * In Task Mode: Returns immediately
-     * In CLI Mode: Blocks on multiple agent done keys
-     */
-    async waitForMultipleAgents(taskId, agentIds, timeoutSeconds = 600, namespace = 'swarm') {
-        // Validate input
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        if (!agentIds || agentIds.length === 0) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, 'Agent IDs list cannot be empty');
-        }
-        // Graceful no-op in Task Mode
-        if (!this.redis.canUseRedis) {
-            this.logger.info('Task Mode: Wait for multiple agents skipped (no Redis)');
-            return {
-                completed: agentIds,
-                timedOut: false,
-                waitedMs: 0
-            };
-        }
-        const startTime = Date.now();
-        const completed = [];
-        const keys = agentIds.map(id => `${namespace}:${taskId}:${id}:done`);
-        try {
-            this.logger.info(`⏳ Waiting for ${agentIds.length} agents to complete (timeout: ${timeoutSeconds}s)`);
-            while (completed.length < agentIds.length) {
-                const waitedMs = Date.now() - startTime;
-                // Check timeout
-                if (waitedMs / 1000 >= timeoutSeconds) {
-                    this.logger.warn(`⏱️ Timeout waiting for agents to complete`);
-                    return {
-                        completed,
-                        timedOut: true,
-                        waitedMs
-                    };
-                }
-                // Calculate remaining timeout for BLPOP
-                const remainingSeconds = timeoutSeconds - (waitedMs / 1000);
-                // BLPOP on all remaining keys
-                const pendingKeys = agentIds
-                    .filter(id => !completed.includes(id))
-                    .map(id => `${namespace}:${taskId}:${id}:done`);
-                if (pendingKeys.length === 0)
-                    break;
-                // BLPOP returns [key, value] or null
-                const blpopArgs = [...pendingKeys, Math.ceil(remainingSeconds)];
-                const result = await this.redis.blpop(...blpopArgs);
-                if (result) {
-                    const key = result[0];
-                    // Extract agent ID from key: "namespace:taskId:agentId:done"
-                    const agentId = key.split(':')[2];
-                    if (!completed.includes(agentId)) {
-                        completed.push(agentId);
-                        this.logger.info(`✅ Agent completed: ${agentId}`);
-                    }
-                }
-            }
-            const waitedMs = Date.now() - startTime;
-            this.logger.info(`✅ All agents completed (waited ${waitedMs}ms)`);
-            return {
-                completed,
-                timedOut: false,
-                waitedMs
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to wait for multiple agents', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to wait for multiple agents: ${error.message}`);
-        }
-    }
-    /**
-     * Poll for condition (non-blocking alternative to BLPOP)
-     *
-     * Useful when you can't use BLPOP (Task Mode stubbing issues).
-     */
-    async pollForCondition(taskId, conditionName, timeoutSeconds = 300, pollIntervalMs = 1000, namespace = 'swarm') {
-        // Validate input
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        const startTime = Date.now();
-        const conditionKey = `${namespace}:${taskId}:${conditionName}`;
-        try {
-            this.logger.info(`⏳ Polling for condition: ${conditionName} (timeout: ${timeoutSeconds}s, poll interval: ${pollIntervalMs}ms)`);
-            while (true) {
-                const waitedMs = Date.now() - startTime;
-                // Check timeout
-                if (waitedMs / 1000 >= timeoutSeconds) {
-                    this.logger.warn(`⏱️ Timeout polling for condition: ${conditionName}`);
-                    return {
-                        condition: conditionName,
-                        met: false,
-                        timedOut: true,
-                        waitedMs
-                    };
-                }
-                // Check condition
-                if (this.redis.canUseRedis) {
-                    const result = await this.redis.get(conditionKey);
-                    if (result && result === 'true') {
-                        this.logger.info(`✅ Condition met via polling: ${conditionName}`);
-                        return {
-                            condition: conditionName,
-                            met: true,
-                            timedOut: false,
-                            waitedMs
-                        };
-                    }
-                }
-                // Wait before next poll
-                await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
-            }
-        }
-        catch (error) {
-            this.logger.error('Failed to poll for condition', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to poll for condition ${conditionName}: ${error.message}`);
-        }
-    }
-}
-exports.WaitingCoordinator = WaitingCoordinator;
-//# sourceMappingURL=waiting-coordinator.js.map

package/claude-assets/skills/cfn-memory-persistence/lib/redis/get-context.sh.backup

@@ -1,146 +0,0 @@
-#!/bin/bash
-# Retrieve CFN Loop task context from Redis
-# Used by CLI-spawned agents to get structured context from orchestrator
-#
-# Usage:
-#   get-context.sh --task-id <id> [--namespace <ns>]
-#   get-context.sh --task-id <id> --key <key> [--namespace <ns>]
-#   get-context.sh <task_id> (legacy mode)
-
-set -euo pipefail
-
-# Source centralized Redis functions with defensive fallback
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REDIS_FUNCTIONS="${SCRIPT_DIR}/redis-functions.sh"
-
-# Check if redis-functions.sh exists and is readable
-if [ ! -r "$REDIS_FUNCTIONS" ]; then
-    echo "⚠️  WARNING: Cannot read redis-functions.sh at: $REDIS_FUNCTIONS" >&2
-    echo "   Operating in Task mode-only (no Redis coordination)" >&2
-    # Define minimal fallback stubs for Task mode
-    redis-cli() {
-        echo "⚠️  Redis unavailable in Task mode - no-op" >&2
-        return 0
-    }
-    export -f redis-cli
-else
-    # Attempt to source with controlled error handling
-    set +e  # Temporarily disable errexit
-    source "$REDIS_FUNCTIONS" 2>/dev/null
-    SOURCE_STATUS=$?
-    set -e  # Re-enable errexit
-
-    if [ $SOURCE_STATUS -ne 0 ]; then
-        echo "⚠️  WARNING: Failed to source redis-functions.sh (exit code: $SOURCE_STATUS)" >&2
-        echo "   Operating in Task mode-only (no Redis coordination)" >&2
-        # Define minimal fallback stubs
-        redis-cli() {
-            echo "⚠️  Redis unavailable - no-op" >&2
-            return 0
-        }
-        export -f redis-cli
-    fi
-fi
-
-# Initialize variables
-TASK_ID=""
-KEY=""
-NAMESPACE="swarm"
-FORMAT="json"  # json or raw
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --task-id)
-      TASK_ID="$2"
-      shift 2
-      ;;
-    --key)
-      KEY="$2"
-      shift 2
-      ;;
-    --namespace)
-      NAMESPACE="$2"
-      shift 2
-      ;;
-    --format)
-      FORMAT="$2"
-      shift 2
-      ;;
-    *)
-      # Legacy mode: positional argument
-      if [ -z "$TASK_ID" ]; then
-        TASK_ID="$1"
-      fi
-      shift
-      ;;
-  esac
-done
-
-# Validate required arguments
-if [ -z "$TASK_ID" ]; then
-    echo "Error: --task-id or TASK_ID required" >&2
-    echo "Usage: $0 --task-id <id> [--key <key>] [--namespace <ns>] [--format <json|raw>]" >&2
-    echo "   or: $0 <task_id> (legacy)" >&2
-    exit 1
-fi
-
-REDIS_KEY="${NAMESPACE}:${TASK_ID}:context"
-
-# Check if context exists
-if ! redis-cli EXISTS "$REDIS_KEY" >/dev/null 2>&1; then
-    echo "⚠️  No context found for task: $TASK_ID" >&2
-    exit 1
-fi
-
-# Handle specific key retrieval
-if [ -n "$KEY" ]; then
-  VALUE=$(redis-cli HGET "$REDIS_KEY" "$KEY" 2>/dev/null || echo "")
-  if [ -z "$VALUE" ]; then
-    echo "⚠️  Key '$KEY' not found in context for task: $TASK_ID" >&2
-    exit 1
-  fi
-
-  if [ "$FORMAT" = "raw" ]; then
-    echo "$VALUE"
-  else
-    echo "{\"$KEY\":$VALUE}"
-  fi
-  exit 0
-fi
-
-# Handle full context retrieval
-ALL_FIELDS=$(redis-cli HGETALL "$REDIS_KEY" 2>/dev/null || echo "")
-
-if [ -z "$ALL_FIELDS" ]; then
-    echo "⚠️  Empty context for task: $TASK_ID" >&2
-    exit 1
-fi
-
-# Format as JSON
-if [ "$FORMAT" = "json" ]; then
-  echo "{"
-  first=true
-  while IFS= read -r field; do
-    if [ -z "$field" ]; then continue; fi
-    if [ "$first" = true ]; then
-      first=false
-    else
-      echo ","
-    fi
-    # Skip empty lines and properly format JSON values
-    if [[ $field =~ ^[0-9]+$ ]]; then
-      # Numeric value
-      echo -n "  \"$field\": $(redis-cli HGET "$REDIS_KEY" "$field")"
-    else
-      # String value
-      value=$(redis-cli HGET "$REDIS_KEY" "$field" | sed 's/"/\\"/g')
-      echo -n "  \"$field\": \"$value\""
-    fi
-  done <<< "$ALL_FIELDS"
-  echo ""
-  echo "}"
-else
-  # Raw format
-  redis-cli HGETALL "$REDIS_KEY"
-fi

package/claude-assets/skills/cfn-memory-persistence/lib/redis/get-success-criteria.sh.backup

@@ -1,54 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-
-# Retrieve success criteria from Redis
-# Usage: get-success-criteria.sh --task-id TASK_ID
-# Output: JSON string (stdout) or error message (stderr)
-
-TASK_ID=""
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-    case "$1" in
-        --task-id)
-            TASK_ID="$2"
-            shift 2
-            ;;
-        *)
-            echo "❌ Unknown option: $1" >&2
-            echo "Usage: get-success-criteria.sh --task-id TASK_ID" >&2
-            exit 1
-            ;;
-    esac
-done
-
-# Validate input
-if [[ -z "$TASK_ID" ]]; then
-    echo "❌ --task-id required" >&2
-    exit 1
-fi
-
-# SECURITY FIX: Validate TASK_ID format (prevent Redis key injection)
-if ! [[ "$TASK_ID" =~ ^[a-zA-Z0-9_-]+$ ]]; then
-    echo "❌ Invalid TASK_ID format: $TASK_ID (must be alphanumeric, dash, underscore only)" >&2
-    exit 1
-fi
-
-# Retrieve from Redis
-REDIS_KEY="swarm:${TASK_ID}:config:success_criteria"
-CRITERIA=$(redis-cli GET "$REDIS_KEY" 2>/dev/null || echo "")
-
-# Check if criteria exists
-if [[ -z "$CRITERIA" ]] || [[ "$CRITERIA" == "null" ]]; then
-    echo "⚠️  No success criteria found for task $TASK_ID" >&2
-    exit 1
-fi
-
-# Validate JSON before output
-if ! echo "$CRITERIA" | jq empty 2>/dev/null; then
-    echo "❌ Invalid JSON in stored criteria" >&2
-    exit 1
-fi
-
-# Output to stdout (clean output for piping)
-echo "$CRITERIA"