claude-flow-novice 2.15.5 → 2.15.6

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

@@ -0,0 +1,396 @@
+/**
+ * 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

@@ -0,0 +1,327 @@
+/**
+ * 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}`
+      );
+    }
+  }
+}