claude-flow-novice 2.18.6 → 2.18.7

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

@@ -1,191 +0,0 @@
-/**
- * Mode-Aware Redis Client
- *
- * Redis client that automatically stubs operations in Task Mode
- * and executes normally in CLI Mode.
- *
- * CRITICAL ANTI-PATTERN PREVENTION (per audit):
- * - Task Mode: All Redis operations gracefully no-op with warnings
- * - CLI Mode: Full Redis coordination available
- *
- * This prevents the audit finding: "22 agent profiles with unconditional redis-cli"
- */
-import type { RedisConfig, Logger, ModeDetection, ExecutionMode } from './types';
-/**
- * Mode-aware Redis coordinator
- *
- * Automatically detects Task Mode vs CLI Mode and stubs Redis operations
- * when appropriate. Prevents failures from undefined TASK_ID/AGENT_ID.
- */
-export declare class RedisCoordinator {
-    private config;
-    private client;
-    private modeDetection;
-    private logger;
-    constructor(config?: Partial<RedisConfig>, logger?: Logger);
-    /**
-     * Initialize the Redis client with mode detection
-     *
-     * MUST be called before any Redis operations.
-     * Detects mode and creates client or stubs accordingly.
-     */
-    initialize(): Promise<void>;
-    /**
-     * Check if Redis operations are safe to execute
-     *
-     * Agent profiles should check this before attempting Redis operations:
-     * ```typescript
-     * if (coordinator.canUseRedis) {
-     *   await coordinator.lpush(...);
-     * } else {
-     *   // Return results directly to Main Chat
-     * }
-     * ```
-     */
-    get canUseRedis(): boolean;
-    /**
-     * Get current execution mode
-     */
-    get mode(): ExecutionMode;
-    /**
-     * Get mode detection details
-     */
-    getModeDetection(): ModeDetection | null;
-    /**
-     * Graceful stub for Task Mode
-     *
-     * Logs warning and returns immediately without error.
-     * Prevents agent failures from undefined variables.
-     */
-    private gracefulStub;
-    /**
-     * Check if client is ready
-     */
-    private ensureClient;
-    /**
-     * LPUSH: Push to list (left/head)
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    lpush(key: string, ...values: string[]): Promise<number>;
-    /**
-     * RPUSH: Push to list (right/tail)
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    rpush(key: string, ...values: string[]): Promise<number>;
-    /**
-     * BLPOP: Blocking pop from list (left/head)
-     *
-     * CRITICAL: This is the coordination primitive for agent waiting.
-     * Gracefully stubs in Task Mode to prevent indefinite blocking.
-     *
-     * @param key Key(s) to pop from
-     * @param timeout Timeout in seconds
-     * @returns [key, value] or null if timeout
-     */
-    blpop(...args: Array<string | number>): Promise<[string, string] | null>;
-    /**
-     * HSET: Set hash field
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    hset(key: string, ...fieldValues: string[]): Promise<number>;
-    /**
-     * HGET: Get hash field
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    hget(key: string, field: string): Promise<string | null>;
-    /**
-     * HGETALL: Get all hash fields
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    hgetall(key: string): Promise<Record<string, string>>;
-    /**
-     * SET: Set string value
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    set(key: string, value: string, expiryMode?: 'EX' | 'PX', time?: number): Promise<string | null>;
-    /**
-     * GET: Get string value
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    get(key: string): Promise<string | null>;
-    /**
-     * DEL: Delete key(s)
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    del(...keys: string[]): Promise<number>;
-    /**
-     * EXPIRE: Set key expiry
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    expire(key: string, seconds: number): Promise<number>;
-    /**
-     * PING: Test connection
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    ping(): Promise<string>;
-    /**
-     * EXISTS: Check if key exists
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    exists(key: string): Promise<number>;
-    /**
-     * ZADD: Add to sorted set
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    zadd(key: string, ...args: string[]): Promise<number>;
-    /**
-     * ZREVRANGE: Get sorted set in reverse order
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    zrevrange(key: string, start: number, stop: number): Promise<string[]>;
-    /**
-     * ZRANGE: Get sorted set
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    zrange(key: string, start: number, stop: number): Promise<string[]>;
-    /**
-     * ZREM: Remove from sorted set
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    zrem(key: string, member: string): Promise<number>;
-    /**
-     * SADD: Add to set
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    sadd(key: string, ...members: string[]): Promise<number>;
-    /**
-     * SMEMBERS: Get all set members
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    smembers(key: string): Promise<string[]>;
-    /**
-     * PUBLISH: Publish to channel
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    publish(channel: string, message: string): Promise<number>;
-    /**
-     * Disconnect from Redis
-     *
-     * Safe to call in Task Mode (no-op).
-     */
-    disconnect(): Promise<void>;
-}
-//# sourceMappingURL=redis-client.d.ts.map

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

@@ -1,509 +0,0 @@
-"use strict";
-/**
- * Mode-Aware Redis Client
- *
- * Redis client that automatically stubs operations in Task Mode
- * and executes normally in CLI Mode.
- *
- * CRITICAL ANTI-PATTERN PREVENTION (per audit):
- * - Task Mode: All Redis operations gracefully no-op with warnings
- * - CLI Mode: Full Redis coordination available
- *
- * This prevents the audit finding: "22 agent profiles with unconditional redis-cli"
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisCoordinator = void 0;
-const ioredis_1 = __importDefault(require("ioredis"));
-const types_1 = require("./types");
-const mode_detector_1 = require("./mode-detector");
-/**
- * Mode-aware Redis coordinator
- *
- * Automatically detects Task Mode vs CLI Mode and stubs Redis operations
- * when appropriate. Prevents failures from undefined TASK_ID/AGENT_ID.
- */
-class RedisCoordinator {
-    config;
-    client = null;
-    modeDetection = null;
-    logger;
-    constructor(config = {}, logger) {
-        this.config = config;
-        this.logger = logger || new mode_detector_1.ConsoleLogger('[CFN-Redis]');
-    }
-    /**
-     * Initialize the Redis client with mode detection
-     *
-     * MUST be called before any Redis operations.
-     * Detects mode and creates client or stubs accordingly.
-     */
-    async initialize() {
-        // Detect mode first
-        this.modeDetection = await (0, mode_detector_1.detectMode)(this.logger);
-        // If Task Mode, don't create Redis client at all
-        if (this.modeDetection.mode === 'task') {
-            this.logger.info('Task Mode: Redis client will be stubbed');
-            this.client = null;
-            return;
-        }
-        // If CLI Mode but Redis unavailable, stub
-        if (!this.modeDetection.redisAvailable) {
-            this.logger.warn('CLI Mode but Redis unavailable: Operations will soft-fail');
-            this.client = null;
-            return;
-        }
-        // CLI Mode with Redis available: Create real client
-        const host = this.config.host || process.env.REDIS_HOST || 'localhost';
-        const port = this.config.port || parseInt(process.env.REDIS_PORT || '6379', 10);
-        const password = this.config.password || process.env.REDIS_PASSWORD || process.env.CFN_REDIS_PASSWORD;
-        this.client = new ioredis_1.default({
-            host,
-            port,
-            password: password || undefined,
-            db: this.config.db || 0,
-            connectTimeout: this.config.connectTimeout || 5000,
-            commandTimeout: this.config.commandTimeout || 5000,
-            retryStrategy: this.config.retryStrategy || ((times) => {
-                if (times > 3)
-                    return null; // Stop retrying after 3 attempts
-                return Math.min(times * 100, 2000); // Exponential backoff
-            }),
-            lazyConnect: false
-        });
-        // Attach error handlers
-        this.client.on('error', (err) => {
-            this.logger.error('Redis connection error', err);
-        });
-        this.client.on('connect', () => {
-            this.logger.debug('Redis connected');
-        });
-        this.logger.info('✅ CLI Mode: Redis client initialized');
-    }
-    /**
-     * Check if Redis operations are safe to execute
-     *
-     * Agent profiles should check this before attempting Redis operations:
-     * ```typescript
-     * if (coordinator.canUseRedis) {
-     *   await coordinator.lpush(...);
-     * } else {
-     *   // Return results directly to Main Chat
-     * }
-     * ```
-     */
-    get canUseRedis() {
-        return this.modeDetection?.canUseRedis ?? false;
-    }
-    /**
-     * Get current execution mode
-     */
-    get mode() {
-        return this.modeDetection?.mode ?? 'unknown';
-    }
-    /**
-     * Get mode detection details
-     */
-    getModeDetection() {
-        return this.modeDetection;
-    }
-    /**
-     * Graceful stub for Task Mode
-     *
-     * Logs warning and returns immediately without error.
-     * Prevents agent failures from undefined variables.
-     */
-    gracefulStub(operation, defaultValue) {
-        if (!this.modeDetection) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.INVALID_STATE, 'Redis coordinator not initialized. Call initialize() first.');
-        }
-        this.logger.warn(`⚠️ Redis operation skipped: ${operation}`);
-        this.logger.info(`💡 Reason: ${this.modeDetection.reason}`);
-        this.logger.info('🔧 Task Mode agents return results directly to Main Chat');
-        return defaultValue;
-    }
-    /**
-     * Check if client is ready
-     */
-    ensureClient() {
-        if (!this.client) {
-            if (this.modeDetection?.mode === 'task') {
-                throw new types_1.CoordinationError(types_1.CoordinationErrorType.MODE_MISMATCH, 'Cannot execute Redis operations in Task Mode', 'task', false);
-            }
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, 'Redis client not available. Check initialization and Redis connectivity.', this.modeDetection?.mode, true);
-        }
-        return this.client;
-    }
-    // ==================== Redis Operations with Graceful Fallback ====================
-    /**
-     * LPUSH: Push to list (left/head)
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    async lpush(key, ...values) {
-        if (!this.canUseRedis) {
-            return this.gracefulStub(`LPUSH ${key}`, 0);
-        }
-        try {
-            const client = this.ensureClient();
-            return await client.lpush(key, ...values);
-        }
-        catch (error) {
-            this.logger.error(`LPUSH failed for key: ${key}`, error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `LPUSH operation failed: ${error.message}`, this.mode, true);
-        }
-    }
-    /**
-     * RPUSH: Push to list (right/tail)
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    async rpush(key, ...values) {
-        if (!this.canUseRedis) {
-            return this.gracefulStub(`RPUSH ${key}`, 0);
-        }
-        try {
-            const client = this.ensureClient();
-            return await client.rpush(key, ...values);
-        }
-        catch (error) {
-            this.logger.error(`RPUSH failed for key: ${key}`, error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `RPUSH operation failed: ${error.message}`, this.mode, true);
-        }
-    }
-    /**
-     * BLPOP: Blocking pop from list (left/head)
-     *
-     * CRITICAL: This is the coordination primitive for agent waiting.
-     * Gracefully stubs in Task Mode to prevent indefinite blocking.
-     *
-     * @param key Key(s) to pop from
-     * @param timeout Timeout in seconds
-     * @returns [key, value] or null if timeout
-     */
-    async blpop(...args) {
-        if (!this.canUseRedis) {
-            const keys = args.slice(0, -1).join(',');
-            return this.gracefulStub(`BLPOP ${keys}`, null);
-        }
-        try {
-            const client = this.ensureClient();
-            // Handle both forms: blpop(key, timeout) and blpop(key1, key2, ..., timeout)
-            const result = await client.blpop(...args);
-            return result;
-        }
-        catch (error) {
-            this.logger.error(`BLPOP failed`, error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `BLPOP operation failed: ${error.message}`, this.mode, true);
-        }
-    }
-    /**
-     * HSET: Set hash field
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    async hset(key, ...fieldValues) {
-        if (!this.canUseRedis) {
-            return this.gracefulStub(`HSET ${key}`, 0);
-        }
-        try {
-            const client = this.ensureClient();
-            return await client.hset(key, ...fieldValues);
-        }
-        catch (error) {
-            this.logger.error(`HSET failed for key: ${key}`, error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `HSET operation failed: ${error.message}`, this.mode, true);
-        }
-    }
-    /**
-     * HGET: Get hash field
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    async hget(key, field) {
-        if (!this.canUseRedis) {
-            return this.gracefulStub(`HGET ${key} ${field}`, null);
-        }
-        try {
-            const client = this.ensureClient();
-            return await client.hget(key, field);
-        }
-        catch (error) {
-            this.logger.error(`HGET failed for key: ${key}, field: ${field}`, error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `HGET operation failed: ${error.message}`, this.mode, true);
-        }
-    }
-    /**
-     * HGETALL: Get all hash fields
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    async hgetall(key) {
-        if (!this.canUseRedis) {
-            return this.gracefulStub(`HGETALL ${key}`, {});
-        }
-        try {
-            const client = this.ensureClient();
-            return await client.hgetall(key);
-        }
-        catch (error) {
-            this.logger.error(`HGETALL failed for key: ${key}`, error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `HGETALL operation failed: ${error.message}`, this.mode, true);
-        }
-    }
-    /**
-     * SET: Set string value
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    async set(key, value, expiryMode, time) {
-        if (!this.canUseRedis) {
-            return this.gracefulStub(`SET ${key}`, null);
-        }
-        try {
-            const client = this.ensureClient();
-            if (expiryMode && time) {
-                const result = await client.set(key, value, expiryMode, time);
-                return result;
-            }
-            const result = await client.set(key, value);
-            return result;
-        }
-        catch (error) {
-            this.logger.error(`SET failed for key: ${key}`, error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `SET operation failed: ${error.message}`, this.mode, true);
-        }
-    }
-    /**
-     * GET: Get string value
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    async get(key) {
-        if (!this.canUseRedis) {
-            return this.gracefulStub(`GET ${key}`, null);
-        }
-        try {
-            const client = this.ensureClient();
-            return await client.get(key);
-        }
-        catch (error) {
-            this.logger.error(`GET failed for key: ${key}`, error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `GET operation failed: ${error.message}`, this.mode, true);
-        }
-    }
-    /**
-     * DEL: Delete key(s)
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    async del(...keys) {
-        if (!this.canUseRedis) {
-            return this.gracefulStub(`DEL ${keys.join(',')}`, 0);
-        }
-        try {
-            const client = this.ensureClient();
-            return await client.del(...keys);
-        }
-        catch (error) {
-            this.logger.error(`DEL failed for keys: ${keys.join(',')}`, error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `DEL operation failed: ${error.message}`, this.mode, true);
-        }
-    }
-    /**
-     * EXPIRE: Set key expiry
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    async expire(key, seconds) {
-        if (!this.canUseRedis) {
-            return this.gracefulStub(`EXPIRE ${key} ${seconds}`, 0);
-        }
-        try {
-            const client = this.ensureClient();
-            return await client.expire(key, seconds);
-        }
-        catch (error) {
-            this.logger.error(`EXPIRE failed for key: ${key}`, error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `EXPIRE operation failed: ${error.message}`, this.mode, true);
-        }
-    }
-    /**
-     * PING: Test connection
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    async ping() {
-        if (!this.canUseRedis) {
-            return this.gracefulStub('PING', 'PONG (stubbed)');
-        }
-        try {
-            const client = this.ensureClient();
-            return await client.ping();
-        }
-        catch (error) {
-            this.logger.error('PING failed', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `PING operation failed: ${error.message}`, this.mode, true);
-        }
-    }
-    /**
-     * EXISTS: Check if key exists
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    async exists(key) {
-        if (!this.canUseRedis) {
-            return this.gracefulStub(`EXISTS ${key}`, 0);
-        }
-        try {
-            const client = this.ensureClient();
-            return await client.exists(key);
-        }
-        catch (error) {
-            this.logger.error(`EXISTS failed for key: ${key}`, error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `EXISTS operation failed: ${error.message}`, this.mode, true);
-        }
-    }
-    /**
-     * ZADD: Add to sorted set
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    async zadd(key, ...args) {
-        if (!this.canUseRedis) {
-            return this.gracefulStub(`ZADD ${key}`, 0);
-        }
-        try {
-            const client = this.ensureClient();
-            return await client.zadd(key, ...args);
-        }
-        catch (error) {
-            this.logger.error(`ZADD failed for key: ${key}`, error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `ZADD operation failed: ${error.message}`, this.mode, true);
-        }
-    }
-    /**
-     * ZREVRANGE: Get sorted set in reverse order
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    async zrevrange(key, start, stop) {
-        if (!this.canUseRedis) {
-            return this.gracefulStub(`ZREVRANGE ${key}`, []);
-        }
-        try {
-            const client = this.ensureClient();
-            return await client.zrevrange(key, start, stop);
-        }
-        catch (error) {
-            this.logger.error(`ZREVRANGE failed for key: ${key}`, error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `ZREVRANGE operation failed: ${error.message}`, this.mode, true);
-        }
-    }
-    /**
-     * ZRANGE: Get sorted set
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    async zrange(key, start, stop) {
-        if (!this.canUseRedis) {
-            return this.gracefulStub(`ZRANGE ${key}`, []);
-        }
-        try {
-            const client = this.ensureClient();
-            return await client.zrange(key, start, stop);
-        }
-        catch (error) {
-            this.logger.error(`ZRANGE failed for key: ${key}`, error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `ZRANGE operation failed: ${error.message}`, this.mode, true);
-        }
-    }
-    /**
-     * ZREM: Remove from sorted set
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    async zrem(key, member) {
-        if (!this.canUseRedis) {
-            return this.gracefulStub(`ZREM ${key}`, 0);
-        }
-        try {
-            const client = this.ensureClient();
-            return await client.zrem(key, member);
-        }
-        catch (error) {
-            this.logger.error(`ZREM failed for key: ${key}`, error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `ZREM operation failed: ${error.message}`, this.mode, true);
-        }
-    }
-    /**
-     * SADD: Add to set
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    async sadd(key, ...members) {
-        if (!this.canUseRedis) {
-            return this.gracefulStub(`SADD ${key}`, 0);
-        }
-        try {
-            const client = this.ensureClient();
-            return await client.sadd(key, ...members);
-        }
-        catch (error) {
-            this.logger.error(`SADD failed for key: ${key}`, error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `SADD operation failed: ${error.message}`, this.mode, true);
-        }
-    }
-    /**
-     * SMEMBERS: Get all set members
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    async smembers(key) {
-        if (!this.canUseRedis) {
-            return this.gracefulStub(`SMEMBERS ${key}`, []);
-        }
-        try {
-            const client = this.ensureClient();
-            return await client.smembers(key);
-        }
-        catch (error) {
-            this.logger.error(`SMEMBERS failed for key: ${key}`, error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `SMEMBERS operation failed: ${error.message}`, this.mode, true);
-        }
-    }
-    /**
-     * PUBLISH: Publish to channel
-     *
-     * Gracefully stubs in Task Mode.
-     */
-    async publish(channel, message) {
-        if (!this.canUseRedis) {
-            return this.gracefulStub(`PUBLISH ${channel}`, 0);
-        }
-        try {
-            const client = this.ensureClient();
-            return await client.publish(channel, message);
-        }
-        catch (error) {
-            this.logger.error(`PUBLISH failed for channel: ${channel}`, error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `PUBLISH operation failed: ${error.message}`, this.mode, true);
-        }
-    }
-    /**
-     * Disconnect from Redis
-     *
-     * Safe to call in Task Mode (no-op).
-     */
-    async disconnect() {
-        if (this.client) {
-            await this.client.quit();
-            this.client = null;
-            this.logger.debug('Redis client disconnected');
-        }
-    }
-}
-exports.RedisCoordinator = RedisCoordinator;
-//# sourceMappingURL=redis-client.js.map