claude-flow-novice 2.10.5 → 2.10.6

package/claude-assets/skills/cfn-redis-coordination/priority-wake-mechanism.md

@@ -0,0 +1,75 @@
+# Priority Queue Wake-Up Mechanism
+
+## Design Overview
+
+### Motivation
+Replace traditional LPUSH/BLPOP with ZADD/BZPOPMIN to enable priority-ordered wake-ups across distributed agent swarms.
+
+### Priority Scoring Algorithm
+
+#### Score Calculation
+```
+SCORE = TIMESTAMP + (PRIORITY * PRIORITY_MULTIPLIER)
+
+Where:
+- TIMESTAMP: Unix epoch seconds
+- PRIORITY: Assigned agent/task priority level
+- PRIORITY_MULTIPLIER: 1,000,000 (ensures timestamp remains primary sorting factor)
+```
+
+### Priority Levels
+
+| Level    | Range   | Example Agents                      |
+|----------|---------|-------------------------------------|
+| Critical | 0-10    | Product Owner, System Coordinators  |
+| High     | 11-30   | Loop 2 Validators                   |
+| Medium   | 31-60   | Loop 3 Implementers                 |
+| Low      | 61-100  | Background Tasks, Monitoring Agents |
+
+### Redis Command Translations
+
+#### Old Method (FIFO)
+```bash
+# LPUSH: Adds to end of list
+redis-cli lpush "swarm:{task}:{agent}:wake" "$WAKE_MSG"
+# BLPOP: Blocks and removes from start of list
+redis-cli blpop "swarm:{task}:{agent}:wake" 0
+```
+
+#### New Method (Priority Queue)
+```bash
+# ZADD: Adds to sorted set with score
+redis-cli zadd "swarm:{task}:wake-queue" $SCORE "$WAKE_MSG"
+# BZPOPMIN: Blocks and removes lowest-score item
+redis-cli bzpopmin "swarm:{task}:wake-queue" 0
+```
+
+### Configuration Flag
+```json
+{
+  "features": {
+    "enablePriorityWake": {
+      "default": false,
+      "description": "Enable priority-based wake mechanism",
+      "version": "4.0.0"
+    }
+  }
+}
+```
+
+## Migration Strategy
+
+1. Dual Support Phase
+   - Maintain both LPUSH and ZADD mechanisms
+   - Gradual rollout with feature flag
+   - Monitor performance and compatibility
+
+2. Transition Steps
+   - Update Redis Coordination skill
+   - Modify waiting mode invocation scripts
+   - Add compatibility layer
+   - Implement feature flag checks
+
+3. Rollback Capabilities
+   - Preserve original LPUSH mechanism
+   - Configurable fallback options

package/claude-assets/skills/cfn-redis-coordination/priority_wake.py

@@ -0,0 +1,134 @@
+import redis
+import time
+import json
+from typing import Optional, Union, Dict
+
+class PriorityWakeMechanism:
+    """
+    Implements priority-based wake-up mechanism using Redis Sorted Sets
+    Supports both legacy and new wake-up strategies
+    """
+
+    PRIORITY_MULTIPLIER = 1_000_000
+    PRIORITY_LEVELS = {
+        "critical": (0, 10),
+        "high": (11, 30),
+        "medium": (31, 60),
+        "low": (61, 100)
+    }
+
+    def __init__(self,
+                 redis_client: redis.Redis,
+                 config_path: str = '/mnt/c/Users/masha/Documents/claude-flow-novice/.claude/skills/redis-coordination/config.json'):
+        self.redis = redis_client
+        self.config = self._load_config(config_path)
+
+    def _load_config(self, config_path: str) -> Dict:
+        try:
+            with open(config_path, 'r') as f:
+                return json.load(f)
+        except FileNotFoundError:
+            return {"features": {"enablePriorityWake": {"default": False}}}
+
+    def calculate_score(self, priority_level: str) -> float:
+        """
+        Calculate wake-up score based on timestamp and priority
+
+        Args:
+            priority_level (str): Priority of the wake-up message
+
+        Returns:
+            float: Calculated score for sorted set insertion
+        """
+        now = time.time()
+        priority_range = self.PRIORITY_LEVELS.get(priority_level, (50, 70))
+        priority_midpoint = sum(priority_range) / 2
+
+        return now + (priority_midpoint * self.PRIORITY_MULTIPLIER)
+
+    def enqueue_wake_message(
+        self,
+        task_id: str,
+        agent_id: str,
+        wake_message: str,
+        priority_level: str = "medium"
+    ) -> bool:
+        """
+        Enqueue a wake message with priority
+
+        Args:
+            task_id (str): Unique task identifier
+            agent_id (str): Agent identifier
+            wake_message (str): Message to be processed
+            priority_level (str, optional): Priority of message. Defaults to "medium".
+
+        Returns:
+            bool: Whether message was successfully enqueued
+        """
+        if not self._is_priority_wake_enabled():
+            # Fallback to traditional LPUSH
+            self.redis.lpush(f"swarm:{task_id}:{agent_id}:wake", wake_message)
+            return True
+
+        score = self.calculate_score(priority_level)
+        key = f"swarm:{task_id}:wake-queue"
+
+        try:
+            self.redis.zadd(key, {wake_message: score})
+            return True
+        except Exception as e:
+            print(f"Wake message enqueue failed: {e}")
+            return False
+
+    def dequeue_wake_message(
+        self,
+        task_id: str,
+        timeout: int = 0
+    ) -> Optional[Union[str, tuple]]:
+        """
+        Dequeue highest priority wake message
+
+        Args:
+            task_id (str): Unique task identifier
+            timeout (int, optional): Blocking timeout. Defaults to 0 (indefinite wait).
+
+        Returns:
+            Optional message or None if no message available
+        """
+        if not self._is_priority_wake_enabled():
+            # Fallback to traditional BLPOP
+            return self.redis.blpop(f"swarm:{task_id}:*:wake", timeout)
+
+        key = f"swarm:{task_id}:wake-queue"
+
+        try:
+            result = self.redis.bzpopmin(key, timeout)
+            return result[1] if result else None
+        except Exception as e:
+            print(f"Wake message dequeue failed: {e}")
+            return None
+
+    def _is_priority_wake_enabled(self) -> bool:
+        """
+        Check if priority wake mechanism is enabled in configuration
+
+        Returns:
+            bool: Whether priority wake is enabled
+        """
+        return self.config.get('features', {}).get('enablePriorityWake', {}).get('default', False)
+
+def main():
+    # Example usage
+    redis_client = redis.Redis(host='localhost', port=6379, db=0)
+    pwm = PriorityWakeMechanism(redis_client)
+
+    # Enqueue messages with different priorities
+    pwm.enqueue_wake_message("task123", "agent-1", "Critical update", "critical")
+    pwm.enqueue_wake_message("task123", "agent-2", "Standard update", "medium")
+
+    # Dequeue messages (will return critical message first)
+    message = pwm.dequeue_wake_message("task123")
+    print(f"Received message: {message}")
+
+if __name__ == "__main__":
+    main()

package/claude-assets/skills/cfn-redis-coordination/query-dlq.sh

@@ -0,0 +1,162 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Query Dead Letter Queue (DLQ)
+# Retrieves and displays failed agent signals from DLQ
+#
+# Usage:
+#   ./query-dlq.sh --task-id <id> [--agent-id <id>]
+#
+# Examples:
+#   # List all DLQ entries for a task
+#   ./query-dlq.sh --task-id redis-phase1-1760875302
+#
+#   # List DLQ entries for specific agent
+#   ./query-dlq.sh --task-id redis-phase1-1760875302 --agent-id backend-dev-2
+##############################################################################
+
+set -euo pipefail
+
+# Configuration
+TASK_ID=""
+AGENT_ID=""
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --task-id)
+      TASK_ID="$2"
+      shift 2
+      ;;
+    --agent-id)
+      AGENT_ID="$2"
+      shift 2
+      ;;
+    *)
+      echo "Unknown option: $1"
+      exit 1
+      ;;
+  esac
+done
+
+# Validation
+if [ -z "$TASK_ID" ]; then
+  echo "Error: --task-id is required"
+  echo "Usage: $0 --task-id <id> [--agent-id <id>]"
+  exit 1
+fi
+
+##############################################################################
+# Query DLQ Entries
+##############################################################################
+
+if [ -n "$AGENT_ID" ]; then
+  # Query specific agent's DLQ
+  DLQ_KEY="swarm:${TASK_ID}:dlq:${AGENT_ID}"
+
+  echo "=== DLQ Entries for Agent: $AGENT_ID ==="
+  echo "Task ID: $TASK_ID"
+  echo ""
+
+  # Check if DLQ exists
+  EXISTS=$(redis-cli EXISTS "$DLQ_KEY")
+
+  if [ "$EXISTS" = "0" ]; then
+    echo "No DLQ entries found for agent: $AGENT_ID"
+    exit 0
+  fi
+
+  # Get entry count
+  ENTRY_COUNT=$(redis-cli LLEN "$DLQ_KEY")
+
+  if [ "$ENTRY_COUNT" = "0" ]; then
+    echo "No DLQ entries found for agent: $AGENT_ID"
+    exit 0
+  fi
+
+  # Parse and display entries
+  for i in $(seq 0 $((ENTRY_COUNT - 1))); do
+    ENTRY=$(redis-cli LINDEX "$DLQ_KEY" "$i")
+
+    if [ -n "$ENTRY" ]; then
+      REASON=$(echo "$ENTRY" | jq -r '.reason')
+      RETRIES=$(echo "$ENTRY" | jq -r '.retry_count')
+      TIMESTAMP=$(echo "$ENTRY" | jq -r '.timestamp')
+      HUMAN_TIME=$(date -d "@$TIMESTAMP" -u +"%Y-%m-%d %H:%M:%S UTC" 2>/dev/null || date -r "$TIMESTAMP" -u +"%Y-%m-%d %H:%M:%S UTC")
+
+      echo "Entry #$((i + 1)):"
+      echo "  Agent: $AGENT_ID"
+      echo "  Reason: $REASON"
+      echo "  Retries: $RETRIES"
+      echo "  Timestamp: $HUMAN_TIME ($TIMESTAMP)"
+      echo ""
+    fi
+  done
+
+else
+  # Query all agents' DLQs for this task
+  echo "=== DLQ Entries for Task: $TASK_ID ==="
+  echo ""
+
+  # Find all DLQ keys for this task
+  DLQ_PATTERN="swarm:${TASK_ID}:dlq:*"
+  DLQ_KEYS=$(redis-cli KEYS "$DLQ_PATTERN")
+
+  if [ -z "$DLQ_KEYS" ]; then
+    echo "No DLQ entries found for task: $TASK_ID"
+    exit 0
+  fi
+
+  # Process each DLQ key
+  echo "$DLQ_KEYS" | while IFS= read -r DLQ_KEY; do
+    if [ -n "$DLQ_KEY" ]; then
+      # Extract agent ID from key (format: swarm:task-id:dlq:agent-id)
+      AGENT=$(echo "$DLQ_KEY" | awk -F':' '{print $NF}')
+
+      # Get entry count for this agent
+      ENTRY_COUNT=$(redis-cli LLEN "$DLQ_KEY")
+
+      if [ "$ENTRY_COUNT" -gt 0 ]; then
+        for i in $(seq 0 $((ENTRY_COUNT - 1))); do
+          ENTRY=$(redis-cli LINDEX "$DLQ_KEY" "$i")
+
+          if [ -n "$ENTRY" ]; then
+            REASON=$(echo "$ENTRY" | jq -r '.reason')
+            RETRIES=$(echo "$ENTRY" | jq -r '.retry_count')
+            TIMESTAMP=$(echo "$ENTRY" | jq -r '.timestamp')
+            HUMAN_TIME=$(date -d "@$TIMESTAMP" -u +"%Y-%m-%d %H:%M:%S UTC" 2>/dev/null || date -r "$TIMESTAMP" -u +"%Y-%m-%d %H:%M:%S UTC")
+
+            echo "Agent: $AGENT (Entry #$((i + 1))/$ENTRY_COUNT)"
+            echo "  Reason: $REASON"
+            echo "  Retries: $RETRIES"
+            echo "  Timestamp: $HUMAN_TIME ($TIMESTAMP)"
+            echo ""
+          fi
+        done
+      fi
+    fi
+  done
+fi
+
+# Display summary
+echo "=== Summary ==="
+if [ -n "$AGENT_ID" ]; then
+  DLQ_KEY="swarm:${TASK_ID}:dlq:${AGENT_ID}"
+  TOTAL=$(redis-cli LLEN "$DLQ_KEY")
+  echo "Total DLQ entries for $AGENT_ID: $TOTAL"
+else
+  DLQ_PATTERN="swarm:${TASK_ID}:dlq:*"
+  TOTAL_KEYS=$(redis-cli KEYS "$DLQ_PATTERN" | wc -l)
+  echo "Total agents with DLQ entries: $TOTAL_KEYS"
+fi
+
+# Check TTL
+if [ -n "$AGENT_ID" ]; then
+  DLQ_KEY="swarm:${TASK_ID}:dlq:${AGENT_ID}"
+  TTL=$(redis-cli TTL "$DLQ_KEY")
+  if [ "$TTL" -gt 0 ]; then
+    DAYS=$((TTL / 86400))
+    HOURS=$(((TTL % 86400) / 3600))
+    echo "TTL remaining: ${DAYS}d ${HOURS}h"
+  fi
+fi

package/claude-assets/skills/cfn-redis-coordination/query-logs.sh

@@ -0,0 +1,103 @@
+#!/bin/bash
+##############################################################################
+# CFN Loop Log Query Tool
+#
+# Usage:
+#   ./query-logs.sh --task-id <id> [options]
+#
+# Parameters:
+#   --task-id       Task/swarm identifier (required)
+#   --event-type    Filter by event type (optional)
+#   --level         Filter by log level: DEBUG, INFO, WARN, ERROR (optional)
+#   --loop          Filter by loop: loop3, loop2, product_owner, coordinator (optional)
+#   --agent-id      Filter by agent ID (optional)
+#   --iteration     Filter by iteration number (optional)
+#   --limit         Maximum number of results (default: 100)
+#   --format        Output format: json, csv, table (default: json)
+#
+# Examples:
+#   # Get all logs for a task
+#   ./query-logs.sh --task-id "cfn-task-123"
+#
+#   # Get errors only
+#   ./query-logs.sh --task-id "cfn-task-123" --level ERROR
+#
+#   # Get Loop 3 agent spawns
+#   ./query-logs.sh --task-id "cfn-task-123" --event-type agent_spawn --loop loop3
+#
+#   # Get latest 10 events in table format
+#   ./query-logs.sh --task-id "cfn-task-123" --limit 10 --format table
+##############################################################################
+
+set -euo pipefail
+
+# Configuration
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+DB_PATH="${DB_PATH:-${SCRIPT_DIR}/.claude/skills/cfn-cfn-.claude/skills/cfn-cfn-data/cfn-loop.db}"
+
+# Parameters
+TASK_ID=""
+EVENT_TYPE=""
+LEVEL=""
+LOOP=""
+AGENT_ID=""
+ITERATION=""
+LIMIT=100
+FORMAT="json"
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --task-id) TASK_ID="$2"; shift 2 ;;
+    --event-type) EVENT_TYPE="$2"; shift 2 ;;
+    --level) LEVEL="$2"; shift 2 ;;
+    --loop) LOOP="$2"; shift 2 ;;
+    --agent-id) AGENT_ID="$2"; shift 2 ;;
+    --iteration) ITERATION="$2"; shift 2 ;;
+    --limit) LIMIT="$2"; shift 2 ;;
+    --format) FORMAT="$2"; shift 2 ;;
+    *) echo "Unknown option: $1" >&2; exit 1 ;;
+  esac
+done
+
+# Validate required parameters
+if [ -z "$TASK_ID" ]; then
+  echo "Error: --task-id is required" >&2
+  echo "Usage: $0 --task-id <id> [--event-type <type>] [--level <level>] [--limit <n>] [--format json|csv|table]" >&2
+  exit 1
+fi
+
+# Check if database exists
+if [ ! -f "$DB_PATH" ]; then
+  echo "Error: Database not found at $DB_PATH" >&2
+  echo "No logs have been written yet." >&2
+  exit 1
+fi
+
+# Build query
+QUERY="SELECT * FROM cfn_loop_logs WHERE task_id = '$TASK_ID'"
+
+[ -n "$EVENT_TYPE" ] && QUERY="$QUERY AND event_type = '$EVENT_TYPE'"
+[ -n "$LEVEL" ] && QUERY="$QUERY AND level = '$LEVEL'"
+[ -n "$LOOP" ] && QUERY="$QUERY AND loop = '$LOOP'"
+[ -n "$AGENT_ID" ] && QUERY="$QUERY AND agent_id = '$AGENT_ID'"
+[ -n "$ITERATION" ] && QUERY="$QUERY AND iteration = $ITERATION"
+
+QUERY="$QUERY ORDER BY timestamp DESC LIMIT $LIMIT"
+
+# Execute query with selected format
+case "$FORMAT" in
+  json)
+    sqlite3 -json "$DB_PATH" "$QUERY"
+    ;;
+  csv)
+    sqlite3 -csv "$DB_PATH" "$QUERY"
+    ;;
+  table)
+    sqlite3 -column -header "$DB_PATH" "$QUERY"
+    ;;
+  *)
+    echo "Error: Invalid format '$FORMAT'. Use: json, csv, or table" >&2
+    exit 1
+    ;;
+esac