claude-flow-novice 2.15.4 → 2.15.6

package/claude-assets/skills/cfn-redis-coordination/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@cfn/redis-coordination",
+  "version": "3.0.1",
+  "description": "TypeScript Redis coordination layer for CFN Loop with graceful Task Mode fallback",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "type-check": "tsc --noEmit",
+    "lint": "eslint src tests --ext .ts",
+    "lint:fix": "eslint src tests --ext .ts --fix",
+    "clean": "rm -rf dist coverage"
+  },
+  "keywords": [
+    "cfn-loop",
+    "redis",
+    "coordination",
+    "typescript",
+    "task-mode",
+    "cli-mode"
+  ],
+  "author": "CFN Loop Team",
+  "license": "MIT",
+  "dependencies": {
+    "ioredis": "^5.3.2",
+    "dotenv": "^16.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@types/jest": "^29.5.10",
+    "@typescript-eslint/eslint-plugin": "^6.13.0",
+    "@typescript-eslint/parser": "^6.13.0",
+    "eslint": "^8.54.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/claude-assets/skills/cfn-redis-coordination/redis-cli-wrapper.sh

@@ -11,20 +11,33 @@ REDIS_HOST="${REDIS_HOST:-localhost}"
 REDIS_PORT="${REDIS_PORT:-6379}"
 REDIS_PASSWORD="${REDIS_PASSWORD:-${CFN_REDIS_PASSWORD:-}}"  # Support both env vars
 
-# Build auth arguments for redis-cli
+# Smart AUTH detection - test Redis connectivity and auth requirements
 AUTH_ARGS=()
-if [ -n "$REDIS_PASSWORD" ]; then
-    AUTH_ARGS=("-a" "$REDIS_PASSWORD")
-fi
 
-# Graceful Redis availability check (1 second timeout, with auth if provided)
-if ! timeout 1 redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" "${AUTH_ARGS[@]}" ping &>/dev/null; then
-    # Redis unavailable - likely Task mode or Redis service down
+# First, test if Redis is reachable at all (no auth)
+if timeout 1 redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" ping &>/dev/null; then
+    # Redis accepts no-auth connections - use it directly
+    AUTH_ARGS=()
+elif [ -n "$REDIS_PASSWORD" ]; then
+    # Redis rejected no-auth, try with password
+    AUTH_ARGS=("-a" "$REDIS_PASSWORD")
+    if ! timeout 1 redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" "${AUTH_ARGS[@]}" ping &>/dev/null; then
+        # Password provided but AUTH failed - likely wrong password or Redis down
+        # Treat as unavailable (soft fail for Task mode compatibility)
+        echo "⚠️ Redis unavailable - command skipped (soft fail)" >&2
+        echo "💡 This is expected in Task mode (Main Chat coordination)" >&2
+        echo "🔧 Agents should output JSON directly instead of Redis coordination" >&2
+        exit 0  # Soft fail - don't break agent execution
+    fi
+    # Auth successful with password
+else
+    # Redis requires auth but no password provided, OR Redis is completely down
+    # Treat as unavailable (soft fail for Task mode compatibility)
     echo "⚠️ Redis unavailable - command skipped (soft fail)" >&2
     echo "💡 This is expected in Task mode (Main Chat coordination)" >&2
     echo "🔧 Agents should output JSON directly instead of Redis coordination" >&2
     exit 0  # Soft fail - don't break agent execution
 fi
 
-# Redis available - execute command normally (CLI/Docker mode, with auth if provided)
+# Redis available and auth validated (if needed) - execute command normally
 exec redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" "${AUTH_ARGS[@]}" "$@"

package/claude-assets/skills/cfn-redis-coordination/redis-functions.sh

@@ -21,8 +21,9 @@ redis-cli() {
 export -f redis-cli
 
 # Optional: Set Redis connection defaults
-export REDIS_HOST="${REDIS_HOST:-localhost}"
-export REDIS_PORT="${REDIS_PORT:-6379}"
+# Support both REDIS_HOST and CFN_REDIS_HOST (TypeScript uses CFN_REDIS_HOST)
+export REDIS_HOST="${CFN_REDIS_HOST:-${REDIS_HOST:-localhost}}"
+export REDIS_PORT="${CFN_REDIS_PORT:-${REDIS_PORT:-6379}}"
 
 # Helper: Check if Redis is available (useful for conditional logic)
 is_redis_available() {

package/claude-assets/skills/cfn-redis-coordination/src/agent-logger.ts

@@ -0,0 +1,446 @@
+/**
+ * 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 {
+  CoordinationError,
+  CoordinationErrorType,
+  isValidTaskId,
+  isValidAgentId
+} 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 class AgentLogger implements Logger {
+  private repository: string;
+
+  constructor(
+    private taskId: TaskId,
+    private agentId: AgentId,
+    private redis: RedisCoordinator,
+    private baseLogger?: Logger,
+    repository?: string
+  ) {
+    // Validate IDs
+    if (!isValidTaskId(taskId)) {
+      throw new CoordinationError(
+        CoordinationErrorType.VALIDATION_ERROR,
+        `Invalid task ID: ${taskId}`
+      );
+    }
+
+    if (!isValidAgentId(agentId)) {
+      throw new CoordinationError(
+        CoordinationErrorType.VALIDATION_ERROR,
+        `Invalid agent ID: ${agentId}`
+      );
+    }
+
+    this.repository = repository || this.detectRepository();
+  }
+
+  /**
+   * Detect repository name from current working directory
+   */
+  private detectRepository(): string {
+    try {
+      const cwd = process.cwd();
+      return cwd.split('/').pop() || 'unknown';
+    } catch {
+      return 'unknown';
+    }
+  }
+
+  /**
+   * Get ANSI color code for log level
+   */
+  private getColorCode(level: LogLevel): string {
+    const colors: Record<LogLevel, string> = {
+      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
+   */
+  private formatForTerminal(entry: LogEntry): string {
+    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
+   */
+  private async storeInRedis(entry: LogEntry): Promise<void> {
+    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
+   */
+  private async logInternal(
+    level: LogLevel,
+    message: string,
+    noTerminal?: boolean,
+    noRedis?: boolean
+  ): Promise<void> {
+    const entry: LogEntry = {
+      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: string, context?: Record<string, unknown>): void {
+    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: string, context?: Record<string, unknown>): void {
+    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: string, context?: Record<string, unknown>): void {
+    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: string, error?: Error, context?: Record<string, unknown>): void {
+    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?: number,
+    namespace: string = 'swarm'
+  ): Promise<LogEntry[]> {
+    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: LogEntry[] = [];
+
+      for (const logJson of logs) {
+        try {
+          const entry = JSON.parse(logJson) as LogEntry;
+          // 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 as Error);
+      return [];
+    }
+  }
+
+  /**
+   * Get logger property for compatibility
+   */
+  private get logger(): Logger {
+    return this.baseLogger || {
+      debug: (msg: string) => console.log(msg),
+      info: (msg: string) => console.log(msg),
+      warn: (msg: string) => console.warn(msg),
+      error: (msg: string) => console.error(msg)
+    };
+  }
+}
+
+/**
+ * Store agent log entry directly (non-Logger interface)
+ */
+export async function storeAgentLog(
+  taskId: TaskId,
+  agentId: AgentId,
+  level: LogLevel,
+  message: string,
+  redis: RedisCoordinator,
+  repository?: string
+): Promise<void> {
+  const logger = new AgentLogger(taskId, agentId, redis, undefined, repository);
+  logger[level](message);
+}
+
+/**
+ * Get agent logs directly (non-Logger interface)
+ */
+export async function getAgentLogs(
+  taskId: TaskId,
+  agentId: AgentId,
+  redis: RedisCoordinator,
+  limit?: number,
+  namespace: string = 'swarm'
+): Promise<LogEntry[]> {
+  if (!isValidTaskId(taskId)) {
+    throw new CoordinationError(
+      CoordinationErrorType.VALIDATION_ERROR,
+      `Invalid task ID: ${taskId}`
+    );
+  }
+
+  if (!isValidAgentId(agentId)) {
+    throw new CoordinationError(
+      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: LogEntry[] = [];
+
+    for (const logJson of logs) {
+      try {
+        const entry = JSON.parse(logJson) as LogEntry;
+        // Filter to only this agent
+        if (entry.agentId === agentId) {
+          entries.push(entry);
+        }
+      } catch {
+        // Skip malformed entries
+      }
+    }
+
+    return entries;
+  } catch (error) {
+    throw new CoordinationError(
+      CoordinationErrorType.REDIS_UNAVAILABLE,
+      `Failed to retrieve agent logs: ${(error as Error).message}`
+    );
+  }
+}
+
+/**
+ * Get logs for all agents in a task
+ */
+export async function getTaskLogs(
+  taskId: TaskId,
+  redis: RedisCoordinator,
+  limit?: number,
+  namespace: string = 'swarm'
+): Promise<LogEntry[]> {
+  if (!isValidTaskId(taskId)) {
+    throw new CoordinationError(
+      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: LogEntry[] = [];
+
+    for (const logJson of logs) {
+      try {
+        entries.push(JSON.parse(logJson) as LogEntry);
+      } catch {
+        // Skip malformed entries
+      }
+    }
+
+    return entries;
+  } catch (error) {
+    throw new CoordinationError(
+      CoordinationErrorType.REDIS_UNAVAILABLE,
+      `Failed to retrieve task logs: ${(error as Error).message}`
+    );
+  }
+}
+
+/**
+ * Clear logs for a task or agent
+ */
+export async function clearLogs(
+  taskId: TaskId,
+  agentId?: AgentId,
+  redis?: RedisCoordinator,
+  namespace: string = 'swarm'
+): Promise<void> {
+  if (!isValidTaskId(taskId)) {
+    throw new CoordinationError(
+      CoordinationErrorType.VALIDATION_ERROR,
+      `Invalid task ID: ${taskId}`
+    );
+  }
+
+  if (!redis || !redis.canUseRedis) {
+    return;
+  }
+
+  try {
+    const historyKey = `${namespace}:${taskId}:logs:history`;
+
+    if (agentId && isValidAgentId(agentId)) {
+      // Delete specific agent's logs
+      const allLogs = await redis.zrange(historyKey, 0, -1);
+      const logsToDelete: string[] = [];
+
+      for (const logJson of allLogs) {
+        try {
+          const entry = JSON.parse(logJson) as LogEntry;
+          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 CoordinationError(
+      CoordinationErrorType.REDIS_UNAVAILABLE,
+      `Failed to clear logs: ${(error as Error).message}`
+    );
+  }
+}