claude-flow-novice 2.0.0 → 2.0.1

package/.claude-flow-novice/dist/cfn-loop/redis-health-monitor.d.ts

@@ -0,0 +1,164 @@
+/**
+ * Redis Health Monitor - Sprint 1.3: Redis Health Check
+ *
+ * Monitors Redis connection health with periodic PING validation.
+ * Detects disconnection within 5 seconds, reconnect within 30 seconds.
+ *
+ * Features:
+ * - Periodic health check every 10 iterations (~50s based on 5s intervals)
+ * - Redis PING validation with 5-second timeout
+ * - Connection state tracking (connected, disconnected, reconnecting)
+ * - Event emission for connection state changes
+ * - Graceful degradation when Redis unavailable
+ * - Exponential backoff reconnection (1s, 2s, 4s)
+ *
+ * Epic: production-blocking-coordination
+ * Sprint: 1.3 - Redis Health Check
+ * Target: Detect disconnection within 5s, reconnect within 30s
+ *
+ * @module cfn-loop/redis-health-monitor
+ */
+import { EventEmitter } from 'events';
+import type { Redis } from 'ioredis';
+/**
+ * Redis connection state
+ */
+export declare enum RedisConnectionState {
+    CONNECTED = "connected",
+    DISCONNECTED = "disconnected",
+    RECONNECTING = "reconnecting"
+}
+/**
+ * Health check result
+ */
+export interface HealthCheckResult {
+    healthy: boolean;
+    state: RedisConnectionState;
+    latencyMs?: number;
+    error?: string;
+    timestamp: number;
+}
+/**
+ * Connection state change event
+ */
+export interface ConnectionStateChange {
+    previousState: RedisConnectionState;
+    newState: RedisConnectionState;
+    timestamp: number;
+    reason?: string;
+    error?: string;
+}
+/**
+ * Configuration for Redis health monitor
+ */
+export interface RedisHealthMonitorConfig {
+    /** Redis client instance (ioredis) */
+    redisClient: Redis;
+    /** Health check interval in milliseconds (default: 50000 = 50s for 10 iterations) */
+    healthCheckInterval?: number;
+    /** PING timeout in milliseconds (default: 5000 = 5s) */
+    pingTimeout?: number;
+    /** Enable automatic reconnection attempts (default: true) */
+    autoReconnect?: boolean;
+    /** Maximum reconnection attempts (default: 5) */
+    maxReconnectAttempts?: number;
+    /** Delay between reconnection attempts in ms (default: 5000) */
+    reconnectDelayMs?: number;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * Manages Redis connection health monitoring and state tracking
+ */
+export declare class RedisHealthMonitor extends EventEmitter {
+    private logger;
+    private redis;
+    private healthCheckInterval;
+    private pingTimeout;
+    private autoReconnect;
+    private maxReconnectAttempts;
+    private reconnectDelayMs;
+    private debug;
+    private checkTimer;
+    private isMonitoring;
+    private connectionState;
+    private reconnectAttempts;
+    private stats;
+    private lastCheckResult;
+    constructor(config: RedisHealthMonitorConfig);
+    /**
+     * Start health monitoring
+     */
+    startMonitoring(): void;
+    /**
+     * Stop health monitoring
+     */
+    stopMonitoring(): void;
+    /**
+     * Perform health check with PING validation
+     *
+     * @returns Health check result with state and latency
+     */
+    performHealthCheck(): Promise<HealthCheckResult>;
+    /**
+     * Attempt to reconnect to Redis
+     */
+    private attemptReconnection;
+    /**
+     * Update connection state and emit event if changed
+     */
+    private updateConnectionState;
+    /**
+     * Set up Redis native event listeners
+     */
+    private setupRedisEventListeners;
+    /**
+     * Get current connection state
+     */
+    getConnectionState(): RedisConnectionState;
+    /**
+     * Get last health check result
+     */
+    getLastCheckResult(): HealthCheckResult | null;
+    /**
+     * Get statistics
+     */
+    getStatistics(): {
+        currentState: RedisConnectionState;
+        successRate: number;
+        reconnectSuccessRate: number;
+        totalHealthChecks: number;
+        successfulChecks: number;
+        failedChecks: number;
+        reconnectAttempts: number;
+        successfulReconnects: number;
+        stateChanges: number;
+        averageLatencyMs: number;
+        totalLatencyMs: number;
+        latencySamples: number;
+    };
+    /**
+     * Reset statistics
+     */
+    resetStatistics(): void;
+    /**
+     * Check if Redis is healthy
+     */
+    isHealthy(): boolean;
+    /**
+     * Cleanup and disconnect
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Sleep utility for delays
+     */
+    private sleep;
+}
+/**
+ * Create a RedisHealthMonitor instance
+ *
+ * @param config - Configuration for Redis health monitor
+ * @returns Configured RedisHealthMonitor
+ */
+export declare function createRedisHealthMonitor(config: RedisHealthMonitorConfig): RedisHealthMonitor;
+export default RedisHealthMonitor;

package/.claude-flow-novice/dist/cfn-loop/redis-pubsub-helpers.d.ts

@@ -0,0 +1,230 @@
+/**
+ * Redis Pub/Sub Helper Functions for Coordinator Communication
+ *
+ * Provides standardized Redis pub/sub patterns for coordinator communication
+ * as defined in COORDINATOR_COMMUNICATION_REQUIREMENTS.md
+ *
+ * Features:
+ * - Sprint lifecycle event publishing
+ * - Agent lifecycle tracking
+ * - Interface signal publishing/subscription
+ * - Claim/confirmation protocol
+ * - Test coordination lock protocol
+ * - Dependency waiting patterns
+ *
+ * @module cfn-loop/redis-pubsub-helpers
+ */
+import type { Redis } from 'ioredis';
+import type { LoggingConfig } from '../utils/types.js';
+/**
+ * Security error for pub/sub payload validation failures
+ */
+export declare class SecurityError extends Error {
+    details: {
+        channel?: string;
+        size?: number;
+        limit?: number;
+        pattern?: string;
+        current?: number;
+    };
+    constructor(message: string, details: {
+        channel?: string;
+        size?: number;
+        limit?: number;
+        pattern?: string;
+        current?: number;
+    });
+}
+/**
+ * Sprint lifecycle event types
+ */
+export type SprintLifecycleEventType = 'sprint:start' | 'sprint:complete' | 'sprint:failed';
+/**
+ * Agent lifecycle event types
+ */
+export type AgentLifecycleEventType = 'agent:spawned' | 'agent:completed' | 'agent:failed';
+/**
+ * Interface event types
+ */
+export type InterfaceEventType = 'interface:published' | 'interface:consumed';
+/**
+ * Sprint lifecycle event
+ */
+export interface SprintLifecycleEvent {
+    type: SprintLifecycleEventType;
+    sprintId: string;
+    coordinatorId: string;
+    dependencies?: string[];
+    consensus?: number;
+    decision?: 'PROCEED' | 'DEFER' | 'ESCALATE';
+    timestamp: number;
+}
+/**
+ * Agent lifecycle event
+ */
+export interface AgentLifecycleEvent {
+    type: AgentLifecycleEventType;
+    agentId: string;
+    coordinatorId: string;
+    sprintId: string;
+    role?: string;
+    confidence?: number;
+    deliverables?: string[];
+    error?: string;
+    timestamp: number;
+}
+/**
+ * Interface signal event
+ */
+export interface InterfaceEvent {
+    type: InterfaceEventType;
+    sprintId: string;
+    interfaceId: string;
+    interface: {
+        exports: string[];
+        redisKeys?: string[];
+        types?: any;
+    };
+    timestamp: number;
+}
+/**
+ * Claim/confirmation event
+ */
+export interface ClaimEvent {
+    coordinator: string;
+    combo: string;
+    action: 'claim' | 'confirmed' | 'conflict';
+    timestamp: number;
+}
+/**
+ * Redis pub/sub channels
+ */
+export declare const REDIS_CHANNELS: {
+    readonly SPRINT_COORDINATION: "sprint:coordination";
+    readonly AGENT_LIFECYCLE: "agent:lifecycle";
+    readonly INTERFACE_READY: "interface:ready";
+    readonly COORDINATION_CLAIMS: "coordination:claims:channel";
+    readonly TEST_COORDINATION: "test:coordination";
+    readonly CONFLICT_DETECTED: "conflict:detected";
+};
+/**
+ * Redis key prefixes
+ */
+export declare const REDIS_KEY_PREFIXES: {
+    readonly DEPENDENCY: "cfn:dependency";
+    readonly TEST_LOCK: "cfn:test:execution:lock";
+    readonly TEST_QUEUE: "cfn:test:queue";
+    readonly SPRINT_STATE: "cfn:sprint:state";
+    readonly INTERFACE: "cfn:interface";
+    readonly CLAIM: "coordination:claims:confirmed";
+    readonly CONFLICT_LOG: "coordination:conflicts:log";
+};
+/**
+ * Redis Pub/Sub Helper for coordinator communication
+ */
+export declare class RedisPubSubHelper {
+    private redis;
+    private logger;
+    private subscriptions;
+    constructor(redis: Redis, loggerConfig?: LoggingConfig);
+    /**
+     * Publish sprint start event
+     */
+    publishSprintStart(sprintId: string, coordinatorId: string, dependencies?: string[]): Promise<void>;
+    /**
+     * Publish sprint complete event
+     */
+    publishSprintComplete(sprintId: string, consensus: number, decision: 'PROCEED' | 'DEFER' | 'ESCALATE'): Promise<void>;
+    /**
+     * Publish sprint failed event
+     */
+    publishSprintFailed(sprintId: string, error: string): Promise<void>;
+    /**
+     * Publish agent spawned event
+     */
+    publishAgentSpawned(agentId: string, coordinatorId: string, sprintId: string, role: string): Promise<void>;
+    /**
+     * Publish agent completed event
+     */
+    publishAgentCompleted(agentId: string, confidence: number, deliverables: string[]): Promise<void>;
+    /**
+     * Publish agent failed event
+     */
+    publishAgentFailed(agentId: string, error: string): Promise<void>;
+    /**
+     * Publish interface ready event
+     */
+    publishInterfaceReady(sprintId: string, interfaceId: string, interfaceDefinition: {
+        exports: string[];
+        redisKeys?: string[];
+        types?: any;
+    }): Promise<void>;
+    /**
+     * Subscribe to sprint coordination events
+     */
+    subscribeToSprintCoordination(handler: (event: SprintLifecycleEvent) => void | Promise<void>): Promise<void>;
+    /**
+     * Subscribe to agent lifecycle events
+     */
+    subscribeToAgentLifecycle(handler: (event: AgentLifecycleEvent) => void | Promise<void>): Promise<void>;
+    /**
+     * Subscribe to interface ready events
+     */
+    subscribeToInterfaceReady(handler: (event: InterfaceEvent) => void | Promise<void>): Promise<void>;
+    /**
+     * Wait for dependencies with timeout
+     *
+     * Returns immediately when all dependencies are satisfied or throws on timeout.
+     *
+     * @param dependencies - Array of sprint IDs to wait for
+     * @param timeoutMs - Timeout in milliseconds (default: 300000 = 5 minutes)
+     * @returns Promise that resolves when all dependencies are satisfied
+     */
+    waitForDependencies(dependencies: string[], timeoutMs?: number): Promise<void>;
+    /**
+     * Check for existing interfaces in Redis
+     */
+    private checkExistingInterfaces;
+    /**
+     * Acquire test execution lock
+     *
+     * @param coordinatorId - Coordinator requesting the lock
+     * @param ttlMs - Lock TTL in milliseconds (default: 900000 = 15 minutes)
+     * @returns True if lock acquired, false otherwise
+     */
+    acquireTestLock(coordinatorId: string, ttlMs?: number): Promise<boolean>;
+    /**
+     * Release test execution lock
+     */
+    releaseTestLock(): Promise<void>;
+    /**
+     * Join test execution queue
+     *
+     * @param coordinatorId - Coordinator joining the queue
+     * @returns Queue position (0-based)
+     */
+    joinTestQueue(coordinatorId: string): Promise<number>;
+    /**
+     * Publish event to Redis channel with P0 security validation
+     *
+     * Security validations (HIGH severity P0 requirements):
+     * 1. Payload size validation (max 1MB)
+     * 2. Script injection pattern detection
+     * 3. Rate limiting (100 events/sec per channel)
+     * 4. Security event logging
+     */
+    private publishEvent;
+    /**
+     * Subscribe to Redis channel
+     */
+    private subscribe;
+    /**
+     * Unsubscribe from all channels
+     */
+    unsubscribeAll(): Promise<void>;
+}
+/**
+ * Create Redis Pub/Sub Helper instance
+ */
+export declare function createRedisPubSubHelper(redis: Redis, loggerConfig?: LoggingConfig): RedisPubSubHelper;
+export default RedisPubSubHelper;

package/.claude-flow-novice/dist/cfn-loop/sprint-coordinator-enhanced.d.ts

@@ -0,0 +1,199 @@
+/**
+ * Sprint Coordinator Enhanced - Sprint 4.2: Dependency Waiting with Productive Work
+ *
+ * Enhances sprint coordination with:
+ * - Dependency waiting while working on independent files
+ * - Interface signal publishing when ready
+ * - Parallel Loop 2 validation
+ * - Integration with blocking-coordination signal ACK protocol
+ *
+ * Key Pattern: Don't block waiting for dependencies - work on independent files
+ * while monitoring for dependency completion signals via Redis pub/sub.
+ *
+ * @module cfn-loop/sprint-coordinator-enhanced
+ */
+import { EventEmitter } from 'events';
+import type { Redis } from 'ioredis';
+import { BlockingCoordinationManager } from './blocking-coordination.js';
+/**
+ * File dependency analysis result
+ */
+export interface FileDependencyAnalysis {
+    /** Files that depend on external interfaces */
+    dependentFiles: string[];
+    /** Files that are independent (can work on immediately) */
+    independentFiles: string[];
+    /** Dependency map: file -> required interface IDs */
+    dependencyMap: Map<string, string[]>;
+}
+/**
+ * Interface signal for cross-sprint coordination
+ */
+export interface InterfaceSignal {
+    /** Unique signal ID */
+    signalId: string;
+    /** Sprint ID that produced the interface */
+    sprintId: string;
+    /** Interface identifier (e.g., "api/users", "types/User") */
+    interfaceId: string;
+    /** Interface definition (type, API spec, etc.) */
+    definition: any;
+    /** Timestamp when interface was published */
+    timestamp: number;
+}
+/**
+ * Sprint coordinator configuration
+ */
+export interface SprintCoordinatorConfig {
+    /** Sprint identifier */
+    sprintId: string;
+    /** Phase identifier */
+    phaseId: string;
+    /** Files to work on */
+    files: string[];
+    /** External interface dependencies (interface IDs) */
+    interfaceDependencies: string[];
+    /** Redis client for pub/sub */
+    redisClient: Redis;
+    /** Blocking coordination manager */
+    blockingCoordination: BlockingCoordinationManager;
+    /** Maximum wait time for dependencies (ms, default: 300000 = 5min) */
+    maxDependencyWait?: number;
+    /** Enable parallel Loop 2 validation (default: true) */
+    enableParallelValidation?: boolean;
+}
+/**
+ * Sprint execution result
+ */
+export interface SprintExecutionResult {
+    /** Success status */
+    success: boolean;
+    /** Sprint ID */
+    sprintId: string;
+    /** Completed files */
+    completedFiles: string[];
+    /** Failed files */
+    failedFiles: string[];
+    /** Published interfaces */
+    publishedInterfaces: InterfaceSignal[];
+    /** Confidence score */
+    confidence: number;
+    /** Validation result */
+    validationPassed: boolean;
+    /** Duration (ms) */
+    duration: number;
+    /** Timestamp */
+    timestamp: number;
+}
+/**
+ * Work progress update
+ */
+export interface WorkProgress {
+    /** Sprint ID */
+    sprintId: string;
+    /** Type of update */
+    type: 'file_started' | 'file_completed' | 'file_failed' | 'dependency_wait' | 'dependency_resolved';
+    /** File being worked on */
+    file?: string;
+    /** Dependency interface ID */
+    interfaceId?: string;
+    /** Timestamp */
+    timestamp: number;
+}
+/**
+ * Enhanced Sprint Coordinator with dependency waiting and productive work
+ */
+export declare class SprintCoordinatorEnhanced extends EventEmitter {
+    private logger;
+    private config;
+    private redis;
+    private blockingCoordination;
+    private completedFiles;
+    private failedFiles;
+    private inProgressFiles;
+    private receivedInterfaces;
+    private pendingInterfaceDependencies;
+    private publishedInterfaces;
+    private readonly INTERFACE_CHANNEL;
+    private readonly COORDINATION_CHANNEL;
+    private startTime;
+    constructor(config: SprintCoordinatorConfig);
+    /**
+     * Initialize coordinator and subscribe to interface signals
+     */
+    initialize(): Promise<void>;
+    /**
+     * Execute sprint with dependency waiting and productive work
+     */
+    execute(): Promise<SprintExecutionResult>;
+    /**
+     * Analyze file dependencies to identify independent vs. dependent files
+     */
+    private analyzeFileDependencies;
+    /**
+     * Get required interfaces for a file (simplified heuristic)
+     */
+    private getRequiredInterfaces;
+    /**
+     * Work on independent files (no dependencies)
+     */
+    private workOnIndependentFiles;
+    /**
+     * Wait for dependencies while working on what we can
+     */
+    private waitForDependenciesWithWork;
+    /**
+     * Work on dependent files (requires interfaces)
+     */
+    private workOnDependentFiles;
+    /**
+     * Process a single file (stub - real implementation would spawn agent)
+     */
+    private processFile;
+    /**
+     * Publish interfaces for downstream sprints
+     */
+    private publishInterfaces;
+    /**
+     * Run parallel Loop 2 validation
+     */
+    private runParallelValidation;
+    /**
+     * Subscribe to interface signals from other sprints
+     */
+    private subscribeToInterfaceSignals;
+    /**
+     * Check if existing interfaces satisfy dependencies
+     */
+    private checkExistingInterfaces;
+    /**
+     * Check if pending dependencies are satisfied
+     */
+    private checkDependencySatisfaction;
+    /**
+     * Get coordination statistics
+     */
+    getStatistics(): {
+        sprintId: string;
+        totalFiles: number;
+        completedFiles: number;
+        failedFiles: number;
+        inProgressFiles: number;
+        publishedInterfaces: number;
+        pendingDependencies: number;
+        duration: number;
+    };
+    /**
+     * Shutdown coordinator
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Sleep utility
+     */
+    private sleep;
+}
+/**
+ * Create Sprint Coordinator Enhanced instance
+ */
+export declare function createSprintCoordinatorEnhanced(config: SprintCoordinatorConfig): SprintCoordinatorEnhanced;
+export default SprintCoordinatorEnhanced;