claude-flow-novice 2.15.10 → 2.16.0

package/claude-assets/skills/cfn-redis-coordination/src/completion-reporter.ts

@@ -1,396 +0,0 @@
-/**
- * Agent Completion Reporter
- *
- * Handles reporting agent completion, confidence, and test results to Redis.
- *
- * Migrated from:
- * - report-completion.sh (89 lines)
- */
-
-import type {
-  TaskId,
-  AgentId,
-  Logger,
-  CompletionReport,
-  TestResults
-} from './types';
-import {
-  CoordinationError,
-  CoordinationErrorType,
-  validateTaskId,
-  validateAgentId,
-  validateConfidence,
-  isValidTaskId,
-  isValidAgentId,
-  isValidConfidence
-} from './types';
-import { RedisCoordinator } from './redis-client';
-
-export interface CompletionReportOptions {
-  result?: {
-    status: 'complete' | 'failed' | 'blocked';
-    deliverablesCreated?: string[];
-    testsRun?: number;
-    testsPassed?: number;
-    testsFailed?: number;
-    errors?: string[];
-    metadata?: Record<string, unknown>;
-  };
-  iteration?: number;
-  namespace?: string;
-}
-
-export class CompletionReporter {
-  constructor(
-    private redis: RedisCoordinator,
-    private logger: Logger
-  ) {}
-
-  /**
-   * Report agent completion with confidence score
-   *
-   * In Task Mode: Logs and returns gracefully
-   * In CLI Mode: Stores in Redis and signals completion
-   */
-  async reportCompletion(
-    taskId: TaskId,
-    agentId: AgentId,
-    confidence: number,
-    options: CompletionReportOptions = {}
-  ): Promise<void> {
-    // Validate inputs
-    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 (!isValidConfidence(confidence)) {
-      throw new CoordinationError(
-        CoordinationErrorType.VALIDATION_ERROR,
-        `Invalid confidence value: ${confidence}. Must be between 0.0 and 1.0.`
-      );
-    }
-
-    // Graceful no-op in Task Mode
-    if (!this.redis.canUseRedis) {
-      this.logger.info(
-        `Task Mode: Agent completion reported (no Redis storage) - Agent: ${agentId}, Confidence: ${confidence}`
-      );
-      return;
-    }
-
-    // CLI Mode: Report to Redis with optimized pipeline
-    const iteration = options.iteration || 1;
-    const namespace = options.namespace || 'swarm';
-    const timestamp = new Date().toISOString();
-
-    try {
-      // Signal completion (for waiting mode)
-      await this.redis.lpush(`${namespace}:${taskId}:${agentId}:done`, 'complete');
-
-      // Store confidence score
-      await this.redis.set(
-        `${namespace}:${taskId}:${agentId}:confidence`,
-        String(confidence),
-        'EX',
-        3600
-      );
-
-      // Store detailed result
-      const resultData: Record<string, string> = {
-        confidence: String(confidence),
-        iteration: String(iteration),
-        timestamp
-      };
-
-      if (options.result) {
-        resultData.status = options.result.status;
-        if (options.result.deliverablesCreated) {
-          resultData.deliverablesCreated = JSON.stringify(options.result.deliverablesCreated);
-        }
-        if (options.result.testsRun !== undefined) {
-          resultData.testsRun = String(options.result.testsRun);
-        }
-        if (options.result.testsPassed !== undefined) {
-          resultData.testsPassed = String(options.result.testsPassed);
-        }
-        if (options.result.testsFailed !== undefined) {
-          resultData.testsFailed = String(options.result.testsFailed);
-        }
-        if (options.result.errors) {
-          resultData.errors = JSON.stringify(options.result.errors);
-        }
-        if (options.result.metadata) {
-          resultData.metadata = JSON.stringify(options.result.metadata);
-        }
-      }
-
-      await this.redis.hset(
-        `${namespace}:${taskId}:${agentId}:result`,
-        ...Object.entries(resultData).flat()
-      );
-
-      // Track in completed agents list
-      await this.redis.lpush(`${namespace}:${taskId}:completed_agents`, agentId);
-
-      // Set TTLs
-      await this.redis.expire(`${namespace}:${taskId}:${agentId}:result`, 3600);
-      await this.redis.expire(`${namespace}:${taskId}:${agentId}:done`, 3600);
-
-      this.logger.info(
-        `✅ Completion reported: Agent ${agentId}, Confidence: ${confidence}, Iteration: ${iteration}`
-      );
-    } catch (error) {
-      this.logger.error('Failed to report completion', error as Error);
-      throw new CoordinationError(
-        CoordinationErrorType.REDIS_UNAVAILABLE,
-        `Failed to report completion for agent ${agentId}: ${(error as Error).message}`
-      );
-    }
-  }
-
-  /**
-   * Report test results with pass rate
-   *
-   * In Task Mode: Logs and returns gracefully
-   * In CLI Mode: Stores in Redis for gate checking
-   */
-  async reportTestResults(
-    taskId: TaskId,
-    agentId: AgentId,
-    results: TestResults,
-    iteration: number = 1,
-    namespace: string = 'swarm'
-  ): Promise<void> {
-    // Validate inputs
-    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 (!Number.isFinite(results.passRate) || results.passRate < 0 || results.passRate > 1) {
-      throw new CoordinationError(
-        CoordinationErrorType.VALIDATION_ERROR,
-        `Invalid pass rate: ${results.passRate}. Must be between 0.0 and 1.0.`
-      );
-    }
-
-    // Graceful no-op in Task Mode
-    if (!this.redis.canUseRedis) {
-      this.logger.info(
-        `Task Mode: Test results reported (no Redis storage) - Pass Rate: ${(results.passRate * 100).toFixed(1)}%`
-      );
-      return;
-    }
-
-    // CLI Mode: Store in Redis
-    const timestamp = new Date().toISOString();
-
-    try {
-      const testResultsKey = `${namespace}:${taskId}:${agentId}:test-results`;
-
-      await this.redis.hset(
-        testResultsKey,
-        'pass', String(results.pass),
-        'fail', String(results.fail),
-        'skip', String(results.skip || 0),
-        'total', String(results.total),
-        'passRate', String(results.passRate),
-        'iteration', String(iteration),
-        'timestamp', timestamp
-      );
-
-      // Set TTL (24 hours)
-      await this.redis.expire(testResultsKey, 86400);
-
-      this.logger.info(
-        `✅ Test results reported: Pass Rate ${(results.passRate * 100).toFixed(1)}% (${results.pass}/${results.total})`
-      );
-    } catch (error) {
-      this.logger.error('Failed to report test results', error as Error);
-      throw new CoordinationError(
-        CoordinationErrorType.REDIS_UNAVAILABLE,
-        `Failed to report test results for agent ${agentId}: ${(error as Error).message}`
-      );
-    }
-  }
-
-  /**
-   * Signal agent done for waiting mode
-   *
-   * In Task Mode: Logs and returns gracefully
-   * In CLI Mode: Signals via Redis list
-   */
-  async signalDone(
-    taskId: TaskId,
-    agentId: AgentId,
-    namespace: string = 'swarm'
-  ): Promise<void> {
-    // Validate inputs
-    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}`
-      );
-    }
-
-    // Graceful no-op in Task Mode
-    if (!this.redis.canUseRedis) {
-      this.logger.info(`Task Mode: Agent done signal ignored (no Redis) - Agent: ${agentId}`);
-      return;
-    }
-
-    // CLI Mode: Push to done list
-    try {
-      const doneKey = `${namespace}:${taskId}:${agentId}:done`;
-      await this.redis.lpush(doneKey, 'done');
-      await this.redis.expire(doneKey, 3600);
-
-      this.logger.info(`✅ Done signal sent for agent: ${agentId}`);
-    } catch (error) {
-      this.logger.error('Failed to signal done', error as Error);
-      throw new CoordinationError(
-        CoordinationErrorType.REDIS_UNAVAILABLE,
-        `Failed to signal done for agent ${agentId}: ${(error as Error).message}`
-      );
-    }
-  }
-
-  /**
-   * Get completion report for an agent
-   */
-  async getCompletionReport(
-    taskId: TaskId,
-    agentId: AgentId,
-    namespace: string = 'swarm'
-  ): Promise<CompletionReport | null> {
-    // Validate inputs
-    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}`
-      );
-    }
-
-    // Graceful no-op in Task Mode
-    if (!this.redis.canUseRedis) {
-      this.logger.info('Task Mode: No completion reports available in Redis');
-      return null;
-    }
-
-    // CLI Mode: Retrieve from Redis
-    try {
-      const resultKey = `${namespace}:${taskId}:${agentId}:result`;
-      const data = await this.redis.hgetall(resultKey);
-
-      if (!data || Object.keys(data).length === 0) {
-        this.logger.warn(`No completion report found for agent: ${agentId}`);
-        return null;
-      }
-
-      const confidence = parseFloat(data.confidence || '0');
-      const report: CompletionReport = {
-        agentId,
-        taskId,
-        confidence,
-        iteration: parseInt(data.iteration || '1', 10),
-        result: {
-          status: (data.status as 'complete' | 'failed' | 'blocked') || 'complete',
-          deliverablesCreated: data.deliverablesCreated ? JSON.parse(data.deliverablesCreated) : undefined,
-          testsRun: data.testsRun ? parseInt(data.testsRun, 10) : undefined,
-          testsPassed: data.testsPassed ? parseInt(data.testsPassed, 10) : undefined,
-          testsFailed: data.testsFailed ? parseInt(data.testsFailed, 10) : undefined,
-          errors: data.errors ? JSON.parse(data.errors) : undefined,
-          metadata: data.metadata ? JSON.parse(data.metadata) : undefined
-        },
-        timestamp: data.timestamp || new Date().toISOString()
-      };
-
-      return report;
-    } catch (error) {
-      this.logger.error('Failed to get completion report', error as Error);
-      throw new CoordinationError(
-        CoordinationErrorType.REDIS_UNAVAILABLE,
-        `Failed to retrieve completion report for agent ${agentId}: ${(error as Error).message}`
-      );
-    }
-  }
-
-  /**
-   * Clear completion data for an agent
-   */
-  async clearCompletion(
-    taskId: TaskId,
-    agentId: AgentId,
-    namespace: string = 'swarm'
-  ): Promise<void> {
-    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 (!this.redis.canUseRedis) {
-      this.logger.info('Task Mode: Completion data cleanup skipped');
-      return;
-    }
-
-    try {
-      const keys = [
-        `${namespace}:${taskId}:${agentId}:done`,
-        `${namespace}:${taskId}:${agentId}:confidence`,
-        `${namespace}:${taskId}:${agentId}:result`,
-        `${namespace}:${taskId}:${agentId}:test-results`
-      ];
-
-      await this.redis.del(...keys);
-      this.logger.info(`✅ Completion data cleared for agent: ${agentId}`);
-    } catch (error) {
-      this.logger.error('Failed to clear completion data', error as Error);
-      throw new CoordinationError(
-        CoordinationErrorType.REDIS_UNAVAILABLE,
-        `Failed to clear completion data for agent ${agentId}: ${(error as Error).message}`
-      );
-    }
-  }
-}

package/claude-assets/skills/cfn-redis-coordination/src/context-manager.ts

@@ -1,327 +0,0 @@
-/**
- * Task Context Manager
- *
- * Handles storing and retrieving task context in Redis (CLI Mode)
- * or gracefully stubbing in Task Mode.
- *
- * Migrated from:
- * - store-context.sh (93 lines)
- * - get-context.sh (145 lines)
- * - store-success-criteria.sh (85 lines)
- * - get-success-criteria.sh (54 lines)
- */
-
-import type {
-  TaskId,
-  Logger,
-  TaskContext,
-  ValidationResult
-} from './types';
-import {
-  CoordinationError,
-  CoordinationErrorType,
-  validateTaskId,
-  isValidTaskId
-} from './types';
-import { RedisCoordinator } from './redis-client';
-
-export interface SuccessCriteria {
-  taskId: TaskId;
-  criteria: string[];
-  testSuites?: string[];
-  passThreshold?: number;
-  timestamp?: string;
-}
-
-export class ContextManager {
-  constructor(
-    private redis: RedisCoordinator,
-    private logger: Logger
-  ) {}
-
-  /**
-   * Store task context in Redis
-   *
-   * In Task Mode: Logs and returns gracefully
-   * In CLI Mode: Stores in Redis with 24h TTL
-   */
-  async storeContext(taskId: TaskId, context: TaskContext): Promise<void> {
-    // Validate input
-    if (!isValidTaskId(taskId)) {
-      throw new CoordinationError(
-        CoordinationErrorType.VALIDATION_ERROR,
-        `Invalid task ID: ${taskId}`
-      );
-    }
-
-    // Graceful no-op in Task Mode
-    if (!this.redis.canUseRedis) {
-      this.logger.info('Task Mode: Context passed via Task() parameters (no Redis storage)');
-      return;
-    }
-
-    // CLI Mode: Store in Redis
-    const key = `swarm:${taskId}:context`;
-    const epic = context.epic || '';
-    const scope = JSON.stringify(context.scope || {});
-    const deliverables = JSON.stringify(context.deliverables || []);
-    const successCriteria = JSON.stringify(context.successCriteria || []);
-    const mode = context.mode || 'standard';
-    const timestamp = context.timestamp || new Date().toISOString();
-
-    try {
-      await this.redis.hset(
-        key,
-        'epic', epic,
-        'scope', scope,
-        'deliverables', deliverables,
-        'successCriteria', successCriteria,
-        'mode', mode,
-        'updated_at', timestamp
-      );
-
-      // Set TTL (24 hours)
-      await this.redis.expire(key, 86400);
-
-      this.logger.info(`✅ Context stored for task: ${taskId}`);
-    } catch (error) {
-      this.logger.error('Failed to store context', error as Error);
-      throw new CoordinationError(
-        CoordinationErrorType.REDIS_UNAVAILABLE,
-        `Failed to store context for task ${taskId}: ${(error as Error).message}`
-      );
-    }
-  }
-
-  /**
-   * Retrieve task context from Redis
-   *
-   * In Task Mode: Returns empty context
-   * In CLI Mode: Retrieves from Redis
-   */
-  async getContext(taskId: TaskId): Promise<TaskContext | null> {
-    // Validate input
-    if (!isValidTaskId(taskId)) {
-      throw new CoordinationError(
-        CoordinationErrorType.VALIDATION_ERROR,
-        `Invalid task ID: ${taskId}`
-      );
-    }
-
-    // Graceful no-op in Task Mode
-    if (!this.redis.canUseRedis) {
-      this.logger.info('Task Mode: No context available in Redis');
-      return null;
-    }
-
-    // CLI Mode: Retrieve from Redis
-    const key = `swarm:${taskId}:context`;
-
-    try {
-      const data = await this.redis.hgetall(key);
-
-      if (!data || Object.keys(data).length === 0) {
-        this.logger.warn(`No context found for task: ${taskId}`);
-        return null;
-      }
-
-      // Parse JSON fields
-      const scope = data.scope ? JSON.parse(data.scope) : {};
-      const deliverables = data.deliverables ? JSON.parse(data.deliverables) : [];
-      const successCriteria = data.successCriteria ? JSON.parse(data.successCriteria) : [];
-
-      const context: TaskContext = {
-        taskId,
-        epic: data.epic || undefined,
-        scope: Object.keys(scope).length > 0 ? scope : undefined,
-        deliverables: deliverables.length > 0 ? deliverables : undefined,
-        successCriteria: successCriteria.length > 0 ? successCriteria : undefined,
-        mode: (data.mode as 'mvp' | 'standard' | 'enterprise') || 'standard',
-        timestamp: data.updated_at
-      };
-
-      this.logger.info(`✅ Context retrieved for task: ${taskId}`);
-      return context;
-    } catch (error) {
-      this.logger.error('Failed to get context', error as Error);
-      throw new CoordinationError(
-        CoordinationErrorType.REDIS_UNAVAILABLE,
-        `Failed to retrieve context for task ${taskId}: ${(error as Error).message}`
-      );
-    }
-  }
-
-  /**
-   * Store success criteria for a task
-   *
-   * In Task Mode: Logs and returns gracefully
-   * In CLI Mode: Stores in Redis with 24h TTL
-   */
-  async storeSuccessCriteria(taskId: TaskId, criteria: SuccessCriteria): Promise<void> {
-    // Validate input
-    if (!isValidTaskId(taskId)) {
-      throw new CoordinationError(
-        CoordinationErrorType.VALIDATION_ERROR,
-        `Invalid task ID: ${taskId}`
-      );
-    }
-
-    if (!criteria.criteria || criteria.criteria.length === 0) {
-      throw new CoordinationError(
-        CoordinationErrorType.VALIDATION_ERROR,
-        'Success criteria must contain at least one criterion'
-      );
-    }
-
-    // Graceful no-op in Task Mode
-    if (!this.redis.canUseRedis) {
-      this.logger.info('Task Mode: Success criteria passed via Task() parameters');
-      return;
-    }
-
-    // CLI Mode: Store in Redis
-    const key = `swarm:${taskId}:success_criteria`;
-
-    try {
-      const criteriaJson = JSON.stringify(criteria.criteria);
-      const testSuitesJson = JSON.stringify(criteria.testSuites || []);
-      const timestamp = criteria.timestamp || new Date().toISOString();
-
-      await this.redis.hset(
-        key,
-        'criteria', criteriaJson,
-        'testSuites', testSuitesJson,
-        'passThreshold', String(criteria.passThreshold || 0.95),
-        'stored_at', timestamp
-      );
-
-      // Set TTL (24 hours)
-      await this.redis.expire(key, 86400);
-
-      this.logger.info(`✅ Success criteria stored for task: ${taskId}`);
-    } catch (error) {
-      this.logger.error('Failed to store success criteria', error as Error);
-      throw new CoordinationError(
-        CoordinationErrorType.REDIS_UNAVAILABLE,
-        `Failed to store success criteria for task ${taskId}: ${(error as Error).message}`
-      );
-    }
-  }
-
-  /**
-   * Retrieve success criteria from Redis
-   *
-   * In Task Mode: Returns null
-   * In CLI Mode: Retrieves from Redis
-   */
-  async getSuccessCriteria(taskId: TaskId): Promise<SuccessCriteria | null> {
-    // Validate input
-    if (!isValidTaskId(taskId)) {
-      throw new CoordinationError(
-        CoordinationErrorType.VALIDATION_ERROR,
-        `Invalid task ID: ${taskId}`
-      );
-    }
-
-    // Graceful no-op in Task Mode
-    if (!this.redis.canUseRedis) {
-      this.logger.info('Task Mode: No success criteria available in Redis');
-      return null;
-    }
-
-    // CLI Mode: Retrieve from Redis
-    const key = `swarm:${taskId}:success_criteria`;
-
-    try {
-      const data = await this.redis.hgetall(key);
-
-      if (!data || Object.keys(data).length === 0) {
-        this.logger.warn(`No success criteria found for task: ${taskId}`);
-        return null;
-      }
-
-      // Parse JSON fields
-      const criteria = data.criteria ? JSON.parse(data.criteria) : [];
-      const testSuites = data.testSuites ? JSON.parse(data.testSuites) : [];
-      const passThreshold = data.passThreshold ? parseFloat(data.passThreshold) : 0.95;
-
-      const result: SuccessCriteria = {
-        taskId,
-        criteria,
-        testSuites: testSuites.length > 0 ? testSuites : undefined,
-        passThreshold,
-        timestamp: data.stored_at
-      };
-
-      this.logger.info(`✅ Success criteria retrieved for task: ${taskId}`);
-      return result;
-    } catch (error) {
-      this.logger.error('Failed to get success criteria', error as Error);
-      throw new CoordinationError(
-        CoordinationErrorType.REDIS_UNAVAILABLE,
-        `Failed to retrieve success criteria for task ${taskId}: ${(error as Error).message}`
-      );
-    }
-  }
-
-  /**
-   * Validate context structure
-   */
-  validateContext(context: TaskContext): ValidationResult {
-    const errors: string[] = [];
-
-    if (!isValidTaskId(context.taskId)) {
-      errors.push(`Invalid task ID: ${context.taskId}`);
-    }
-
-    if (context.deliverables && !Array.isArray(context.deliverables)) {
-      errors.push('Deliverables must be an array');
-    }
-
-    if (context.successCriteria && !Array.isArray(context.successCriteria)) {
-      errors.push('Success criteria must be an array');
-    }
-
-    if (context.mode && !['mvp', 'standard', 'enterprise'].includes(context.mode)) {
-      errors.push(`Invalid mode: ${context.mode}`);
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-
-  /**
-   * Clear context for a task
-   */
-  async clearContext(taskId: TaskId): Promise<void> {
-    if (!isValidTaskId(taskId)) {
-      throw new CoordinationError(
-        CoordinationErrorType.VALIDATION_ERROR,
-        `Invalid task ID: ${taskId}`
-      );
-    }
-
-    if (!this.redis.canUseRedis) {
-      this.logger.info('Task Mode: Context cleanup skipped');
-      return;
-    }
-
-    try {
-      const keys = [
-        `swarm:${taskId}:context`,
-        `swarm:${taskId}:success_criteria`
-      ];
-
-      await this.redis.del(...keys);
-      this.logger.info(`✅ Context cleared for task: ${taskId}`);
-    } catch (error) {
-      this.logger.error('Failed to clear context', error as Error);
-      throw new CoordinationError(
-        CoordinationErrorType.REDIS_UNAVAILABLE,
-        `Failed to clear context for task ${taskId}: ${(error as Error).message}`
-      );
-    }
-  }
-}