claude-flow-novice 2.18.6 → 2.18.7

package/claude-assets/skills/cfn-memory-persistence/lib/redis/collect-results.sh.backup

@@ -1,75 +0,0 @@
-#!/bin/bash
-
-# Redis Results Collection Primitive
-# Updated interface to match orchestrator expectations
-# Supports both legacy (--key) and new (--task-id --agent-ids --namespace) interfaces
-
-# Initialize variables
-task_id=""
-agent_ids=""
-key=""
-namespace="swarm"
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-    case "$1" in
-        --task-id)
-            task_id="$2"
-            shift 2
-            ;;
-        --agent-ids)
-            agent_ids="$2"
-            shift 2
-            ;;
-        --key)
-            key="$2"
-            shift 2
-            ;;
-        --namespace)
-            namespace="$2"
-            shift 2
-            ;;
-        *)
-            echo "Unknown argument: $1" >&2
-            exit 1
-            ;;
-    esac
-done
-
-# Construct Redis key based on interface mode
-if [[ -n "$task_id" && -n "$agent_ids" ]]; then
-    # New interface: collect from multiple agents
-    # Format: {namespace}:{task_id}:results
-    redis_key="${namespace}:${task_id}:results"
-
-    # Collect results from each agent
-    IFS=',' read -ra AGENTS <<< "$agent_ids"
-    results=""
-    for agent in "${AGENTS[@]}"; do
-        agent_key="${namespace}:${task_id}:${agent}:result"
-        agent_result=$(redis-cli get "$agent_key" 2>/dev/null)
-        if [[ -n "$agent_result" && "$agent_result" != "(nil)" ]]; then
-            results="${results}${agent}:${agent_result}"$'\n'
-        fi
-    done
-
-    # Print collected results
-    echo -n "$results"
-elif [[ -n "$key" ]]; then
-    # Legacy interface: key is used directly (list-based)
-    redis_key="$key"
-
-    # Collect results from Redis list
-    results=$(redis-cli lrange "$redis_key" 0 -1 2>/dev/null)
-
-    # Print the results
-    echo "$results"
-else
-    echo "Error: Either (--task-id and --agent-ids) or --key is required" >&2
-    echo "Usage: $0 --task-id <id> --agent-ids <comma-separated-ids> [--namespace <ns>]" >&2
-    echo "   or: $0 --key <full-key>" >&2
-    exit 1
-fi
-
-# Exit successfully
-exit 0

package/claude-assets/skills/cfn-memory-persistence/lib/redis/complete-swarm.sh.backup

@@ -1,75 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# Complete Swarm - Mark swarm as completed with final metrics
-#
-# Updates swarm metadata status to "completed" and stores final metrics.
-#
-# Usage:
-#   ./complete-swarm.sh --swarm-id <id> \
-#                       [--final-metric <name=value>] \
-#                       [--final-metric <name=value>] ...
-#
-# Example:
-#   ./complete-swarm.sh --swarm-id "swarm-auth-123" \
-#                       --final-metric "consensus=0.92" \
-#                       --final-metric "iterations=3"
-##############################################################################
-
-set -euo pipefail
-
-# Configuration
-SWARM_ID=""
-declare -A FINAL_METRICS
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --swarm-id)
-      SWARM_ID="$2"
-      shift 2
-      ;;
-    --final-metric)
-      # Parse name=value
-      IFS='=' read -r KEY VALUE <<< "$2"
-      FINAL_METRICS["$KEY"]="$VALUE"
-      shift 2
-      ;;
-    *)
-      echo "Unknown option: $1"
-      echo "Usage: $0 --swarm-id <id> [--final-metric <name=value>]"
-      exit 1
-      ;;
-  esac
-done
-
-# Validation
-if [ -z "$SWARM_ID" ]; then
-  echo "Error: --swarm-id required"
-  echo "Usage: $0 --swarm-id <id>"
-  exit 1
-fi
-
-METADATA_KEY="swarm:${SWARM_ID}:metadata"
-
-# Check if swarm exists
-if ! redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" exists "$METADATA_KEY" | grep -q "1"; then
-  echo "Error: Swarm not found: $SWARM_ID"
-  exit 1
-fi
-
-echo "[Swarm] Completing swarm: $SWARM_ID"
-
-# Update status
-redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" hset "$METADATA_KEY" \
-  status "completed" \
-  completed_at "$(date -u +%Y-%m-%dT%H:%M:%SZ)" > /dev/null
-
-# Add final metrics
-for KEY in "${!FINAL_METRICS[@]}"; do
-  VALUE="${FINAL_METRICS[$KEY]}"
-  redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" hset "$METADATA_KEY" "$KEY" "$VALUE" > /dev/null
-  echo "[Swarm] Stored metric: $KEY = $VALUE"
-done
-
-echo "[Swarm] ✅ Completion recorded"

package/claude-assets/skills/cfn-memory-persistence/lib/redis/dist/agent-logger.d.ts

@@ -1,92 +0,0 @@
-/**
- * Agent Logger
- *
- * Handles agent logging with dual output (terminal + Redis).
- *
- * Migrated from:
- * - agent-log.sh (128 lines)
- */
-import type { TaskId, AgentId, Logger } from './types';
-import { RedisCoordinator } from './redis-client';
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-export interface LogEntry {
-    level: LogLevel;
-    message: string;
-    agentId: AgentId;
-    taskId: TaskId;
-    timestamp: string;
-    repository?: string;
-}
-export declare class AgentLogger implements Logger {
-    private taskId;
-    private agentId;
-    private redis;
-    private baseLogger?;
-    private repository;
-    constructor(taskId: TaskId, agentId: AgentId, redis: RedisCoordinator, baseLogger?: Logger | undefined, repository?: string);
-    /**
-     * Detect repository name from current working directory
-     */
-    private detectRepository;
-    /**
-     * Get ANSI color code for log level
-     */
-    private getColorCode;
-    /**
-     * Format log entry for terminal output
-     */
-    private formatForTerminal;
-    /**
-     * Store log entry in Redis
-     *
-     * Logs are stored in both:
-     * 1. Pub/Sub for real-time delivery
-     * 2. Sorted set for history
-     */
-    private storeInRedis;
-    /**
-     * Internal logging method
-     */
-    private logInternal;
-    /**
-     * Log debug message
-     */
-    debug(message: string, context?: Record<string, unknown>): void;
-    /**
-     * Log info message
-     */
-    info(message: string, context?: Record<string, unknown>): void;
-    /**
-     * Log warning message
-     */
-    warn(message: string, context?: Record<string, unknown>): void;
-    /**
-     * Log error message
-     */
-    error(message: string, error?: Error, context?: Record<string, unknown>): void;
-    /**
-     * Get logs for this agent from Redis
-     */
-    getAgentLogs(limit?: number, namespace?: string): Promise<LogEntry[]>;
-    /**
-     * Get logger property for compatibility
-     */
-    private get logger();
-}
-/**
- * Store agent log entry directly (non-Logger interface)
- */
-export declare function storeAgentLog(taskId: TaskId, agentId: AgentId, level: LogLevel, message: string, redis: RedisCoordinator, repository?: string): Promise<void>;
-/**
- * Get agent logs directly (non-Logger interface)
- */
-export declare function getAgentLogs(taskId: TaskId, agentId: AgentId, redis: RedisCoordinator, limit?: number, namespace?: string): Promise<LogEntry[]>;
-/**
- * Get logs for all agents in a task
- */
-export declare function getTaskLogs(taskId: TaskId, redis: RedisCoordinator, limit?: number, namespace?: string): Promise<LogEntry[]>;
-/**
- * Clear logs for a task or agent
- */
-export declare function clearLogs(taskId: TaskId, agentId?: AgentId, redis?: RedisCoordinator, namespace?: string): Promise<void>;
-//# sourceMappingURL=agent-logger.d.ts.map

package/claude-assets/skills/cfn-memory-persistence/lib/redis/dist/agent-logger.js

@@ -1,329 +0,0 @@
-"use strict";
-/**
- * Agent Logger
- *
- * Handles agent logging with dual output (terminal + Redis).
- *
- * Migrated from:
- * - agent-log.sh (128 lines)
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentLogger = void 0;
-exports.storeAgentLog = storeAgentLog;
-exports.getAgentLogs = getAgentLogs;
-exports.getTaskLogs = getTaskLogs;
-exports.clearLogs = clearLogs;
-const types_1 = require("./types");
-class AgentLogger {
-    taskId;
-    agentId;
-    redis;
-    baseLogger;
-    repository;
-    constructor(taskId, agentId, redis, baseLogger, repository) {
-        this.taskId = taskId;
-        this.agentId = agentId;
-        this.redis = redis;
-        this.baseLogger = baseLogger;
-        // Validate IDs
-        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}`);
-        }
-        this.repository = repository || this.detectRepository();
-    }
-    /**
-     * Detect repository name from current working directory
-     */
-    detectRepository() {
-        try {
-            const cwd = process.cwd();
-            return cwd.split('/').pop() || 'unknown';
-        }
-        catch {
-            return 'unknown';
-        }
-    }
-    /**
-     * Get ANSI color code for log level
-     */
-    getColorCode(level) {
-        const colors = {
-            debug: '\x1b[0;36m', // Cyan
-            info: '\x1b[0;32m', // Green
-            warn: '\x1b[0;33m', // Yellow
-            error: '\x1b[0;31m' // Red
-        };
-        return colors[level];
-    }
-    /**
-     * Format log entry for terminal output
-     */
-    formatForTerminal(entry) {
-        const color = this.getColorCode(entry.level);
-        const reset = '\x1b[0m';
-        const agentColor = '\x1b[0;35m'; // Magenta
-        return (`${color}[${entry.level.toUpperCase()}]${reset} ` +
-            `${agentColor}[${entry.agentId}]${reset} ` +
-            entry.message);
-    }
-    /**
-     * Store log entry in Redis
-     *
-     * Logs are stored in both:
-     * 1. Pub/Sub for real-time delivery
-     * 2. Sorted set for history
-     */
-    async storeInRedis(entry) {
-        if (!this.redis.canUseRedis) {
-            return;
-        }
-        try {
-            const payload = JSON.stringify(entry);
-            const channelKey = `swarm:${entry.taskId}:logs`;
-            const historyKey = `swarm:${entry.taskId}:logs:history`;
-            // Publish to channel for real-time consumption
-            await this.redis.publish(channelKey, payload);
-            // Add to sorted set for persistence (timestamp as score)
-            const score = new Date(entry.timestamp).getTime();
-            await this.redis.zadd(historyKey, score.toString(), payload);
-            // Set TTL on history (7 days = 604800 seconds)
-            await this.redis.expire(historyKey, 604800);
-        }
-        catch (error) {
-            // Non-fatal: logging failure shouldn't crash agent
-            console.error('Failed to store log in Redis', error);
-        }
-    }
-    /**
-     * Internal logging method
-     */
-    async logInternal(level, message, noTerminal, noRedis) {
-        const entry = {
-            level,
-            message,
-            agentId: this.agentId,
-            taskId: this.taskId,
-            timestamp: new Date().toISOString(),
-            repository: this.repository
-        };
-        // Terminal output
-        if (!noTerminal) {
-            const formatted = this.formatForTerminal(entry);
-            if (this.baseLogger) {
-                switch (level) {
-                    case 'debug':
-                        this.baseLogger.debug(formatted);
-                        break;
-                    case 'info':
-                        this.baseLogger.info(formatted);
-                        break;
-                    case 'warn':
-                        this.baseLogger.warn(formatted);
-                        break;
-                    case 'error':
-                        this.baseLogger.error(formatted);
-                        break;
-                }
-            }
-            else {
-                console.log(formatted);
-            }
-        }
-        // Redis storage
-        if (!noRedis) {
-            await this.storeInRedis(entry);
-        }
-    }
-    /**
-     * Log debug message
-     */
-    debug(message, context) {
-        const msg = context ? `${message} ${JSON.stringify(context)}` : message;
-        this.logInternal('debug', msg).catch(err => console.error('Error in debug log', err));
-    }
-    /**
-     * Log info message
-     */
-    info(message, context) {
-        const msg = context ? `${message} ${JSON.stringify(context)}` : message;
-        this.logInternal('info', msg).catch(err => console.error('Error in info log', err));
-    }
-    /**
-     * Log warning message
-     */
-    warn(message, context) {
-        const msg = context ? `${message} ${JSON.stringify(context)}` : message;
-        this.logInternal('warn', msg).catch(err => console.error('Error in warn log', err));
-    }
-    /**
-     * Log error message
-     */
-    error(message, error, context) {
-        const errorMsg = error
-            ? `${message} - ${error.message}${context ? ` ${JSON.stringify(context)}` : ''}`
-            : message;
-        this.logInternal('error', errorMsg).catch(err => console.error('Error in error log', err));
-    }
-    /**
-     * Get logs for this agent from Redis
-     */
-    async getAgentLogs(limit, namespace = 'swarm') {
-        if (!this.redis.canUseRedis) {
-            return [];
-        }
-        try {
-            const historyKey = `${namespace}:${this.taskId}:logs:history`;
-            // Get all logs for task (reverse order, newest first)
-            const count = limit || 100;
-            const logs = await this.redis.zrevrange(historyKey, 0, count - 1);
-            const entries = [];
-            for (const logJson of logs) {
-                try {
-                    const entry = JSON.parse(logJson);
-                    // Filter to only this agent
-                    if (entry.agentId === this.agentId) {
-                        entries.push(entry);
-                    }
-                }
-                catch {
-                    // Skip malformed entries
-                }
-            }
-            return entries;
-        }
-        catch (error) {
-            this.logger.error('Failed to get agent logs', error);
-            return [];
-        }
-    }
-    /**
-     * Get logger property for compatibility
-     */
-    get logger() {
-        return this.baseLogger || {
-            debug: (msg) => console.log(msg),
-            info: (msg) => console.log(msg),
-            warn: (msg) => console.warn(msg),
-            error: (msg) => console.error(msg)
-        };
-    }
-}
-exports.AgentLogger = AgentLogger;
-/**
- * Store agent log entry directly (non-Logger interface)
- */
-async function storeAgentLog(taskId, agentId, level, message, redis, repository) {
-    const logger = new AgentLogger(taskId, agentId, redis, undefined, repository);
-    logger[level](message);
-}
-/**
- * Get agent logs directly (non-Logger interface)
- */
-async function getAgentLogs(taskId, agentId, redis, limit, namespace = 'swarm') {
-    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}`);
-    }
-    if (!redis.canUseRedis) {
-        return [];
-    }
-    try {
-        const historyKey = `${namespace}:${taskId}:logs:history`;
-        // Get logs (reverse order, newest first)
-        const count = limit || 100;
-        const logs = await redis.zrevrange(historyKey, 0, count - 1);
-        const entries = [];
-        for (const logJson of logs) {
-            try {
-                const entry = JSON.parse(logJson);
-                // Filter to only this agent
-                if (entry.agentId === agentId) {
-                    entries.push(entry);
-                }
-            }
-            catch {
-                // Skip malformed entries
-            }
-        }
-        return entries;
-    }
-    catch (error) {
-        throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to retrieve agent logs: ${error.message}`);
-    }
-}
-/**
- * Get logs for all agents in a task
- */
-async function getTaskLogs(taskId, redis, limit, namespace = 'swarm') {
-    if (!(0, types_1.isValidTaskId)(taskId)) {
-        throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-    }
-    if (!redis.canUseRedis) {
-        return [];
-    }
-    try {
-        const historyKey = `${namespace}:${taskId}:logs:history`;
-        // Get all logs (reverse order, newest first)
-        const count = limit || 1000;
-        const logs = await redis.zrevrange(historyKey, 0, count - 1);
-        const entries = [];
-        for (const logJson of logs) {
-            try {
-                entries.push(JSON.parse(logJson));
-            }
-            catch {
-                // Skip malformed entries
-            }
-        }
-        return entries;
-    }
-    catch (error) {
-        throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to retrieve task logs: ${error.message}`);
-    }
-}
-/**
- * Clear logs for a task or agent
- */
-async function clearLogs(taskId, agentId, redis, namespace = 'swarm') {
-    if (!(0, types_1.isValidTaskId)(taskId)) {
-        throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-    }
-    if (!redis || !redis.canUseRedis) {
-        return;
-    }
-    try {
-        const historyKey = `${namespace}:${taskId}:logs:history`;
-        if (agentId && (0, types_1.isValidAgentId)(agentId)) {
-            // Delete specific agent's logs
-            const allLogs = await redis.zrange(historyKey, 0, -1);
-            const logsToDelete = [];
-            for (const logJson of allLogs) {
-                try {
-                    const entry = JSON.parse(logJson);
-                    if (entry.agentId === agentId) {
-                        logsToDelete.push(logJson);
-                    }
-                }
-                catch {
-                    // Skip malformed entries
-                }
-            }
-            for (const logJson of logsToDelete) {
-                await redis.zrem(historyKey, logJson);
-            }
-        }
-        else {
-            // Delete all logs for task
-            await redis.del(historyKey);
-        }
-    }
-    catch (error) {
-        throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to clear logs: ${error.message}`);
-    }
-}
-//# sourceMappingURL=agent-logger.js.map

package/claude-assets/skills/cfn-memory-persistence/lib/redis/dist/agent-recovery.d.ts

@@ -1,75 +0,0 @@
-/**
- * Agent Recovery Manager
- *
- * Handles agent health checks, stuck agent detection, and recovery mechanisms.
- *
- * Migrated from:
- * - agent-recovery.sh (74 lines)
- */
-import type { TaskId, AgentId, Logger } from './types';
-import { RedisCoordinator } from './redis-client';
-export interface AgentHealth {
-    agentId: AgentId;
-    taskId: TaskId;
-    status: 'healthy' | 'stuck' | 'dead' | 'unknown';
-    lastHeartbeat?: string;
-    processPid?: number;
-    stuckFor?: number;
-    reason?: string;
-}
-export declare class AgentRecoveryManager {
-    private redis;
-    private logger;
-    private readonly HEARTBEAT_TIMEOUT_MS;
-    private readonly STUCK_THRESHOLD_MS;
-    private readonly HEARTBEAT_TTL_SECONDS;
-    constructor(redis: RedisCoordinator, logger: Logger);
-    /**
-     * Record agent heartbeat to indicate it's still alive
-     *
-     * In Task Mode: Logs and returns gracefully
-     * In CLI Mode: Updates heartbeat timestamp in Redis
-     */
-    recordHeartbeat(taskId: TaskId, agentId: AgentId, processPid?: number, namespace?: string): Promise<void>;
-    /**
-     * Check agent health status
-     *
-     * In Task Mode: Returns 'healthy'
-     * In CLI Mode: Checks heartbeat freshness
-     */
-    checkAgentHealth(taskId: TaskId, agentId: AgentId, namespace?: string): Promise<AgentHealth>;
-    /**
-     * Detect all stuck agents for a task
-     */
-    detectStuckAgents(taskId: TaskId, agentIds: AgentId[], namespace?: string): Promise<AgentHealth[]>;
-    /**
-     * Mark agent for recovery
-     *
-     * In Task Mode: Logs and returns gracefully
-     * In CLI Mode: Records recovery marker in Redis
-     */
-    markForRecovery(taskId: TaskId, agentId: AgentId, mode?: 'soft' | 'hard', namespace?: string): Promise<void>;
-    /**
-     * Get recovery markers for agents
-     */
-    getRecoveryMarkers(taskId: TaskId, agentIds: AgentId[], namespace?: string): Promise<Array<{
-        agentId: AgentId;
-        mode: string;
-        markedAt: string;
-    }>>;
-    /**
-     * Clear recovery marker after recovery is complete
-     */
-    clearRecoveryMarker(taskId: TaskId, agentId: AgentId, namespace?: string): Promise<void>;
-    /**
-     * Get overall swarm health summary
-     */
-    getSwarmHealth(taskId: TaskId, agentIds: AgentId[], namespace?: string): Promise<{
-        healthy: number;
-        stuck: number;
-        dead: number;
-        unknown: number;
-        summary: string;
-    }>;
-}
-//# sourceMappingURL=agent-recovery.d.ts.map