claude-flow-novice 2.18.6 → 2.18.8

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

@@ -1,176 +0,0 @@
-/**
- * CFN Redis Coordination Types
- *
- * Core type definitions for Redis coordination layer with strict mode awareness.
- * All Redis operations must respect Task Mode vs CLI Mode distinction.
- */
-export type TaskId = string & {
-    readonly __brand: 'TaskId';
-};
-export type AgentId = string & {
-    readonly __brand: 'AgentId';
-};
-export type CorrelationId = string & {
-    readonly __brand: 'CorrelationId';
-};
-export type ExecutionMode = 'task' | 'cli' | 'unknown';
-/**
- * Mode Detection Result
- *
- * Provides clear indication of which mode the agent is running in
- * and whether Redis operations are safe.
- */
-export interface ModeDetection {
-    mode: ExecutionMode;
-    redisAvailable: boolean;
-    taskIdPresent: boolean;
-    agentIdPresent: boolean;
-    canUseRedis: boolean;
-    reason: string;
-}
-/**
- * Redis Configuration
- *
- * Connection parameters with optional authentication.
- */
-export interface RedisConfig {
-    host: string;
-    port: number;
-    password?: string;
-    db?: number;
-    connectTimeout?: number;
-    commandTimeout?: number;
-    retryStrategy?: (times: number) => number | null;
-}
-/**
- * Task Context
- *
- * Structured context passed to agents via Redis in CLI Mode.
- * In Task Mode, this is passed directly via Task() tool parameters.
- */
-export interface TaskContext {
-    taskId: TaskId;
-    epic?: string;
-    scope?: {
-        inScope: string[];
-        outOfScope: string[];
-    };
-    deliverables?: string[];
-    successCriteria?: string[];
-    iteration?: number;
-    mode?: 'mvp' | 'standard' | 'enterprise';
-    timestamp?: string;
-}
-/**
- * Agent Completion Report
- *
- * Structured data agents report when completing work.
- */
-export interface CompletionReport {
-    agentId: AgentId;
-    taskId: TaskId;
-    confidence: number;
-    iteration: number;
-    result: {
-        status: 'complete' | 'failed' | 'blocked';
-        deliverablesCreated?: string[];
-        testsRun?: number;
-        testsPassed?: number;
-        testsFailed?: number;
-        errors?: string[];
-        metadata?: Record<string, unknown>;
-    };
-    timestamp: string;
-}
-/**
- * Test Results
- *
- * Structured test execution results for gate checking.
- */
-export interface TestResults {
-    pass: number;
-    fail: number;
-    skip?: number;
-    total: number;
-    passRate: number;
-    timestamp: string;
-}
-/**
- * Consensus Score
- *
- * Validator feedback with confidence scoring.
- */
-export interface ConsensusScore {
-    agentId: AgentId;
-    score: number;
-    feedback: string;
-    iteration: number;
-    timestamp: string;
-}
-/**
- * Coordination Error Types
- */
-export declare enum CoordinationErrorType {
-    MODE_MISMATCH = "MODE_MISMATCH",// Attempting Redis ops in Task Mode
-    REDIS_UNAVAILABLE = "REDIS_UNAVAILABLE",// Redis connection failed
-    TIMEOUT = "TIMEOUT",// Operation timed out
-    VALIDATION_ERROR = "VALIDATION_ERROR",// Invalid input parameters
-    MISSING_CONTEXT = "MISSING_CONTEXT",// Required context not found
-    INVALID_STATE = "INVALID_STATE"
-}
-/**
- * Coordination Error
- *
- * Typed error for coordination failures with mode awareness.
- */
-export declare class CoordinationError extends Error {
-    readonly type: CoordinationErrorType;
-    readonly mode?: ExecutionMode | undefined;
-    readonly canRetry: boolean;
-    constructor(type: CoordinationErrorType, message: string, mode?: ExecutionMode | undefined, canRetry?: boolean);
-}
-/**
- * Logger Interface
- *
- * Abstraction for logging to allow dependency injection.
- */
-export interface Logger {
-    debug(message: string, context?: Record<string, unknown>): void;
-    info(message: string, context?: Record<string, unknown>): void;
-    warn(message: string, context?: Record<string, unknown>): void;
-    error(message: string, error?: Error, context?: Record<string, unknown>): void;
-}
-/**
- * Redis Operation Options
- *
- * Options for individual Redis operations.
- */
-export interface RedisOperationOptions {
-    /** Skip mode validation (for internal use only) */
-    skipModeCheck?: boolean;
-    /** Operation timeout in milliseconds */
-    timeout?: number;
-    /** Retry on failure */
-    retry?: boolean;
-    /** Max retry attempts */
-    maxRetries?: number;
-}
-/**
- * Validation Result
- *
- * Result of input validation with specific errors.
- */
-export interface ValidationResult {
-    valid: boolean;
-    errors: string[];
-}
-/**
- * Type guards and validators
- */
-export declare function isValidTaskId(value: unknown): value is TaskId;
-export declare function isValidAgentId(value: unknown): value is AgentId;
-export declare function isValidConfidence(value: unknown): value is number;
-export declare function validateTaskId(value: string): TaskId;
-export declare function validateAgentId(value: string): AgentId;
-export declare function validateConfidence(value: number): number;
-//# sourceMappingURL=types.d.ts.map

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

@@ -1,81 +0,0 @@
-"use strict";
-/**
- * CFN Redis Coordination Types
- *
- * Core type definitions for Redis coordination layer with strict mode awareness.
- * All Redis operations must respect Task Mode vs CLI Mode distinction.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CoordinationError = exports.CoordinationErrorType = void 0;
-exports.isValidTaskId = isValidTaskId;
-exports.isValidAgentId = isValidAgentId;
-exports.isValidConfidence = isValidConfidence;
-exports.validateTaskId = validateTaskId;
-exports.validateAgentId = validateAgentId;
-exports.validateConfidence = validateConfidence;
-/**
- * Coordination Error Types
- */
-var CoordinationErrorType;
-(function (CoordinationErrorType) {
-    CoordinationErrorType["MODE_MISMATCH"] = "MODE_MISMATCH";
-    CoordinationErrorType["REDIS_UNAVAILABLE"] = "REDIS_UNAVAILABLE";
-    CoordinationErrorType["TIMEOUT"] = "TIMEOUT";
-    CoordinationErrorType["VALIDATION_ERROR"] = "VALIDATION_ERROR";
-    CoordinationErrorType["MISSING_CONTEXT"] = "MISSING_CONTEXT";
-    CoordinationErrorType["INVALID_STATE"] = "INVALID_STATE";
-})(CoordinationErrorType || (exports.CoordinationErrorType = CoordinationErrorType = {}));
-/**
- * Coordination Error
- *
- * Typed error for coordination failures with mode awareness.
- */
-class CoordinationError extends Error {
-    type;
-    mode;
-    canRetry;
-    constructor(type, message, mode, canRetry = false) {
-        super(message);
-        this.type = type;
-        this.mode = mode;
-        this.canRetry = canRetry;
-        this.name = 'CoordinationError';
-        Object.setPrototypeOf(this, CoordinationError.prototype);
-    }
-}
-exports.CoordinationError = CoordinationError;
-/**
- * Type guards and validators
- */
-function isValidTaskId(value) {
-    return (typeof value === 'string' &&
-        /^[a-zA-Z0-9_-]{1,256}$/.test(value) &&
-        value.length > 0);
-}
-function isValidAgentId(value) {
-    return (typeof value === 'string' &&
-        /^[a-zA-Z0-9_-]{1,256}$/.test(value) &&
-        value.length > 0);
-}
-function isValidConfidence(value) {
-    return typeof value === 'number' && value >= 0.0 && value <= 1.0;
-}
-function validateTaskId(value) {
-    if (!isValidTaskId(value)) {
-        throw new CoordinationError(CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID format: ${value}. Must be 1-256 alphanumeric, underscore, or hyphen characters.`);
-    }
-    return value;
-}
-function validateAgentId(value) {
-    if (!isValidAgentId(value)) {
-        throw new CoordinationError(CoordinationErrorType.VALIDATION_ERROR, `Invalid agent ID format: ${value}. Must be 1-256 alphanumeric, underscore, or hyphen characters.`);
-    }
-    return value;
-}
-function validateConfidence(value) {
-    if (!isValidConfidence(value)) {
-        throw new CoordinationError(CoordinationErrorType.VALIDATION_ERROR, `Invalid confidence value: ${value}. Must be between 0.0 and 1.0.`);
-    }
-    return value;
-}
-//# sourceMappingURL=types.js.map

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

@@ -1,86 +0,0 @@
-/**
- * Waiting Coordinator
- *
- * Handles blocking coordination using Redis BLPOP for agents to wait
- * for specific conditions (gate passed, consensus reached, etc).
- *
- * Migrated from:
- * - invoke-waiting-mode.sh (223 lines)
- */
-import type { TaskId, AgentId, Logger } from './types';
-import { RedisCoordinator } from './redis-client';
-export interface WaitResult {
-    condition: string;
-    met: boolean;
-    timedOut: boolean;
-    waitedMs: number;
-    metadata?: Record<string, unknown>;
-}
-export interface SignalResult {
-    agentId: AgentId;
-    signalType: string;
-    status: string;
-    timestamp: string;
-}
-export declare class WaitingCoordinator {
-    private redis;
-    private logger;
-    constructor(redis: RedisCoordinator, logger: Logger);
-    /**
-     * Wait for a specific condition with BLPOP (blocking)
-     *
-     * Blocks until condition is signaled or timeout occurs.
-     * In Task Mode: Returns immediately with false
-     * In CLI Mode: Blocks on Redis list
-     */
-    waitForCompletion(taskId: TaskId, agentId: AgentId, timeoutSeconds?: number, namespace?: string): Promise<WaitResult>;
-    /**
-     * Wait for gate to pass (test pass rate threshold)
-     *
-     * Blocks until gate-passed signal is received.
-     * In Task Mode: Returns immediately with true
-     * In CLI Mode: Blocks on Redis list
-     */
-    waitForGate(taskId: TaskId, timeoutSeconds?: number, namespace?: string): Promise<WaitResult>;
-    /**
-     * Wait for consensus to be reached from validators
-     *
-     * Blocks until consensus signal is received.
-     * In Task Mode: Returns immediately with true
-     * In CLI Mode: Blocks on Redis list
-     */
-    waitForConsensus(taskId: TaskId, timeoutSeconds?: number, namespace?: string): Promise<WaitResult>;
-    /**
-     * Wait for custom condition by key name
-     *
-     * Generic wait mechanism for any condition.
-     * In Task Mode: Returns immediately with true
-     * In CLI Mode: Blocks on Redis list
-     */
-    waitForCondition(taskId: TaskId, conditionName: string, timeoutSeconds?: number, namespace?: string): Promise<WaitResult>;
-    /**
-     * Signal a condition to wake waiting agents
-     *
-     * In Task Mode: Logs and returns gracefully
-     * In CLI Mode: Pushes signal to Redis list
-     */
-    signalCondition(taskId: TaskId, conditionName: string, metadata?: Record<string, unknown>, namespace?: string): Promise<SignalResult>;
-    /**
-     * Wait for multiple agents to complete with parallel blocking
-     *
-     * In Task Mode: Returns immediately
-     * In CLI Mode: Blocks on multiple agent done keys
-     */
-    waitForMultipleAgents(taskId: TaskId, agentIds: AgentId[], timeoutSeconds?: number, namespace?: string): Promise<{
-        completed: AgentId[];
-        timedOut: boolean;
-        waitedMs: number;
-    }>;
-    /**
-     * Poll for condition (non-blocking alternative to BLPOP)
-     *
-     * Useful when you can't use BLPOP (Task Mode stubbing issues).
-     */
-    pollForCondition(taskId: TaskId, conditionName: string, timeoutSeconds?: number, pollIntervalMs?: number, namespace?: string): Promise<WaitResult>;
-}
-//# sourceMappingURL=waiting-coordinator.d.ts.map