claude-flow-novice 2.15.10 → 2.16.0

package/claude-assets/skills/cfn-redis-coordination/src/task-executor.ts

@@ -1,423 +0,0 @@
-/**
- * Task Executor
- *
- * Main entry point for CFN Loop task execution and orchestration.
- *
- * Migrated from:
- * - cfn-loop-exec.sh (468 lines)
- * - cfn-loop-relaunch.sh (29 lines)
- */
-
-import type {
-  TaskId,
-  TaskContext,
-  Logger
-} from './types';
-import {
-  CoordinationError,
-  CoordinationErrorType,
-  isValidTaskId,
-  validateTaskId
-} from './types';
-import { RedisCoordinator } from './redis-client';
-import { ContextManager } from './context-manager';
-import { ComplexityAnalysis, TaskAnalyzer, DifficultyLevel } from './task-analyzer';
-
-export interface ExecutionConfig {
-  taskId: TaskId;
-  taskDescription: string;
-  context?: TaskContext;
-  mode?: 'mvp' | 'standard' | 'enterprise';
-  maxIterations?: number;
-  timeoutMinutes?: number;
-  difficulty?: DifficultyLevel;
-}
-
-export interface ExecutionResult {
-  taskId: TaskId;
-  status: 'success' | 'failed' | 'timeout' | 'cancelled';
-  iterations: number;
-  finalConfidence: number;
-  deliverables: string[];
-  errors: string[];
-  startTime: string;
-  endTime: string;
-  durationMinutes: number;
-}
-
-export interface ExecutionProgress {
-  taskId: TaskId;
-  currentIteration: number;
-  status: 'running' | 'paused' | 'completed' | 'failed';
-  progress: number;
-  estimatedTimeRemaining: number;
-  agentsActive: number;
-  lastUpdate: string;
-}
-
-export class TaskExecutor {
-  private contextManager: ContextManager;
-  private analyzer: TaskAnalyzer;
-  private startTime?: Date;
-  private currentIteration = 0;
-
-  constructor(
-    private redis: RedisCoordinator,
-    private logger: Logger
-  ) {
-    this.contextManager = new ContextManager(redis, logger);
-    this.analyzer = new TaskAnalyzer(redis, logger);
-  }
-
-  /**
-   * Execute a CFN Loop task
-   *
-   * Coordinates task analysis, context setup, and orchestration.
-   */
-  async executeTask(config: ExecutionConfig): Promise<ExecutionResult> {
-    // Validate input
-    if (!isValidTaskId(config.taskId)) {
-      throw new CoordinationError(
-        CoordinationErrorType.VALIDATION_ERROR,
-        `Invalid task ID: ${config.taskId}`
-      );
-    }
-
-    if (!config.taskDescription || config.taskDescription.trim().length === 0) {
-      throw new CoordinationError(
-        CoordinationErrorType.VALIDATION_ERROR,
-        'Task description cannot be empty'
-      );
-    }
-
-    this.startTime = new Date();
-    this.currentIteration = 0;
-
-    const startTime = this.startTime.toISOString();
-    const result: ExecutionResult = {
-      taskId: config.taskId,
-      status: 'success',
-      iterations: 0,
-      finalConfidence: 0,
-      deliverables: [],
-      errors: [],
-      startTime,
-      endTime: '',
-      durationMinutes: 0
-    };
-
-    try {
-      this.logger.info(`🚀 Starting CFN Loop execution: ${config.taskId}`);
-      this.logger.info(`   Task: ${config.taskDescription}`);
-
-      // Step 1: Analyze task complexity
-      const analysis = await this.analyzeTaskComplexity(
-        config.taskDescription,
-        config.difficulty
-      );
-
-      // Step 2: Determine execution mode
-      const mode = config.mode || this.analyzer.suggestMode(analysis);
-      this.logger.info(`📋 Execution mode: ${mode}`);
-
-      // Step 3: Store context
-      const context = config.context || {
-        taskId: config.taskId,
-        epic: config.taskDescription,
-        mode
-      };
-
-      await this.contextManager.storeContext(config.taskId, context);
-
-      // Step 4: Initialize execution
-      const maxIterations = config.maxIterations || this.getMaxIterations(mode);
-      const timeoutMinutes = config.timeoutMinutes || this.getTimeoutMinutes(mode);
-
-      this.logger.info(`⚙️ Configuration: Max Iterations=${maxIterations}, Timeout=${timeoutMinutes}m`);
-
-      // Step 5: Run orchestration loop
-      // Note: In actual implementation, this would spawn orchestrator via CLI
-      this.logger.info(`📡 Would spawn orchestrator for task: ${config.taskId}`);
-      this.logger.info(`   Analysis: ${analysis.difficulty} complexity (${analysis.complexityScore}/20)`);
-      this.logger.info(`   Domains: ${analysis.domains.join(', ') || 'none'}`);
-      this.logger.info(`   Suggested: ${analysis.suggestedAgents.loop3Count} Loop3 + ${analysis.suggestedAgents.loop2Count} Loop2 agents`);
-
-      // Simulate successful execution for foundation validation
-      result.status = 'success';
-      result.iterations = 1;
-      result.finalConfidence = 0.95;
-      result.deliverables = ['task_completed', 'context_stored', 'analysis_completed'];
-
-      return result;
-    } catch (error) {
-      result.status = 'failed';
-      result.errors.push((error as Error).message);
-
-      this.logger.error('Task execution failed', error as Error);
-      throw error;
-    } finally {
-      // Finalize result
-      const endTime = new Date();
-      result.endTime = endTime.toISOString();
-      result.durationMinutes = Math.round(
-        (endTime.getTime() - this.startTime!.getTime()) / 60000
-      );
-
-      this.logger.info(`📊 Execution Summary:`);
-      this.logger.info(`   Status: ${result.status}`);
-      this.logger.info(`   Duration: ${result.durationMinutes}m`);
-      this.logger.info(`   Iterations: ${result.iterations}`);
-      this.logger.info(`   Final Confidence: ${(result.finalConfidence * 100).toFixed(1)}%`);
-    }
-  }
-
-  /**
-   * Relaunch a task for the next iteration
-   *
-   * Used by orchestrator to continue loop iterations.
-   */
-  async relaunchtask(
-    taskId: TaskId,
-    iteration: number,
-    agentChanges?: {
-      addAgents?: string[];
-      removeAgents?: string[];
-    }
-  ): Promise<void> {
-    // Validate input
-    if (!isValidTaskId(taskId)) {
-      throw new CoordinationError(
-        CoordinationErrorType.VALIDATION_ERROR,
-        `Invalid task ID: ${taskId}`
-      );
-    }
-
-    if (iteration < 1 || iteration > 50) {
-      throw new CoordinationError(
-        CoordinationErrorType.VALIDATION_ERROR,
-        `Invalid iteration number: ${iteration}. Must be between 1 and 50.`
-      );
-    }
-
-    try {
-      this.logger.info(`🔄 Relaunching task for iteration ${iteration}: ${taskId}`);
-
-      // Retrieve current context
-      const context = await this.contextManager.getContext(taskId);
-      if (!context) {
-        throw new CoordinationError(
-          CoordinationErrorType.MISSING_CONTEXT,
-          `No context found for task: ${taskId}`
-        );
-      }
-
-      // Update iteration in context
-      context.iteration = iteration;
-
-      // Store updated context
-      await this.contextManager.storeContext(taskId, context);
-
-      // Log agent changes if provided
-      if (agentChanges?.addAgents && agentChanges.addAgents.length > 0) {
-        this.logger.info(`   Adding agents: ${agentChanges.addAgents.join(', ')}`);
-      }
-
-      if (agentChanges?.removeAgents && agentChanges.removeAgents.length > 0) {
-        this.logger.info(`   Removing agents: ${agentChanges.removeAgents.join(', ')}`);
-      }
-
-      this.logger.info(`✅ Task relaunched for iteration ${iteration}`);
-    } catch (error) {
-      this.logger.error('Task relaunch failed', error as Error);
-      throw new CoordinationError(
-        CoordinationErrorType.REDIS_UNAVAILABLE,
-        `Failed to relaunch task: ${(error as Error).message}`
-      );
-    }
-  }
-
-  /**
-   * Get execution progress
-   */
-  async getProgress(taskId: TaskId): Promise<ExecutionProgress> {
-    // Validate input
-    if (!isValidTaskId(taskId)) {
-      throw new CoordinationError(
-        CoordinationErrorType.VALIDATION_ERROR,
-        `Invalid task ID: ${taskId}`
-      );
-    }
-
-    // In a real implementation, this would retrieve from Redis
-    // For now, return base progress
-    return {
-      taskId,
-      currentIteration: this.currentIteration,
-      status: 'running',
-      progress: 0,
-      estimatedTimeRemaining: 0,
-      agentsActive: 0,
-      lastUpdate: new Date().toISOString()
-    };
-  }
-
-  /**
-   * Cancel task execution
-   */
-  async cancelTask(
-    taskId: TaskId,
-    reason: string = 'user_requested'
-  ): Promise<void> {
-    // Validate input
-    if (!isValidTaskId(taskId)) {
-      throw new CoordinationError(
-        CoordinationErrorType.VALIDATION_ERROR,
-        `Invalid task ID: ${taskId}`
-      );
-    }
-
-    try {
-      this.logger.info(`🛑 Cancelling task execution: ${taskId}`);
-      this.logger.info(`   Reason: ${reason}`);
-
-      // In a real implementation, this would signal all agents
-      // via Redis to stop and exit gracefully
-
-      this.logger.info(`✅ Task cancellation signal sent`);
-    } catch (error) {
-      this.logger.error('Task cancellation failed', error as Error);
-      throw new CoordinationError(
-        CoordinationErrorType.REDIS_UNAVAILABLE,
-        `Failed to cancel task: ${(error as Error).message}`
-      );
-    }
-  }
-
-  /**
-   * Analyze task complexity and store analysis
-   */
-  private async analyzeTaskComplexity(
-    taskDescription: string,
-    difficulty?: DifficultyLevel
-  ): Promise<ComplexityAnalysis> {
-    try {
-      this.logger.info('🔍 Analyzing task complexity...');
-
-      const analysis = this.analyzer.analyzeComplexity(taskDescription, difficulty);
-
-      this.logger.info(`   Complexity Score: ${analysis.complexityScore}/20`);
-      this.logger.info(`   Difficulty: ${analysis.difficulty}`);
-      this.logger.info(`   Domains: ${analysis.domains.join(', ') || 'none'}`);
-      this.logger.info(`   Agents: ${analysis.suggestedAgents.loop3Count} Loop3 + ${analysis.suggestedAgents.loop2Count} Loop2`);
-      this.logger.info(`   Est. Duration: ${analysis.suggestedAgents.estimatedDurationMinutes}m`);
-
-      return analysis;
-    } catch (error) {
-      this.logger.error('Task complexity analysis failed', error as Error);
-      throw new CoordinationError(
-        CoordinationErrorType.VALIDATION_ERROR,
-        `Failed to analyze task complexity: ${(error as Error).message}`
-      );
-    }
-  }
-
-  /**
-   * Get max iterations for execution mode
-   */
-  private getMaxIterations(mode: 'mvp' | 'standard' | 'enterprise'): number {
-    const maxByMode: Record<'mvp' | 'standard' | 'enterprise', number> = {
-      mvp: 3,
-      standard: 10,
-      enterprise: 15
-    };
-
-    return maxByMode[mode];
-  }
-
-  /**
-   * Get timeout in minutes for execution mode
-   */
-  private getTimeoutMinutes(mode: 'mvp' | 'standard' | 'enterprise'): number {
-    const timeoutByMode: Record<'mvp' | 'standard' | 'enterprise', number> = {
-      mvp: 30,
-      standard: 120,
-      enterprise: 300
-    };
-
-    return timeoutByMode[mode];
-  }
-
-  /**
-   * Validate execution configuration
-   */
-  validateConfig(config: ExecutionConfig): { valid: boolean; errors: string[] } {
-    const errors: string[] = [];
-
-    if (!isValidTaskId(config.taskId)) {
-      errors.push(`Invalid task ID: ${config.taskId}`);
-    }
-
-    if (!config.taskDescription || config.taskDescription.trim().length === 0) {
-      errors.push('Task description cannot be empty');
-    }
-
-    if (config.maxIterations !== undefined) {
-      if (config.maxIterations < 1 || config.maxIterations > 50) {
-        errors.push('Max iterations must be between 1 and 50');
-      }
-    }
-
-    if (config.timeoutMinutes !== undefined) {
-      if (config.timeoutMinutes < 1 || config.timeoutMinutes > 1440) {
-        errors.push('Timeout must be between 1 and 1440 minutes');
-      }
-    }
-
-    if (config.mode && !['mvp', 'standard', 'enterprise'].includes(config.mode)) {
-      errors.push(`Invalid execution mode: ${config.mode}`);
-    }
-
-    if (config.difficulty && !['simple', 'standard', 'complex', 'enterprise'].includes(config.difficulty)) {
-      errors.push(`Invalid difficulty level: ${config.difficulty}`);
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-
-  /**
-   * Clean up task resources
-   */
-  async cleanupTask(taskId: TaskId): Promise<void> {
-    // Validate input
-    if (!isValidTaskId(taskId)) {
-      throw new CoordinationError(
-        CoordinationErrorType.VALIDATION_ERROR,
-        `Invalid task ID: ${taskId}`
-      );
-    }
-
-    try {
-      this.logger.info(`🧹 Cleaning up task resources: ${taskId}`);
-
-      // Clear context
-      await this.contextManager.clearContext(taskId);
-
-      // In a real implementation, would also clean up:
-      // - Agent results
-      // - Swarm metadata
-      // - Logs
-      // etc.
-
-      this.logger.info(`✅ Task cleanup complete`);
-    } catch (error) {
-      this.logger.error('Task cleanup failed', error as Error);
-      throw new CoordinationError(
-        CoordinationErrorType.REDIS_UNAVAILABLE,
-        `Failed to cleanup task: ${(error as Error).message}`
-      );
-    }
-  }
-}

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

@@ -1,235 +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.
- */
-
-// Branded types for type safety
-export type TaskId = string & { readonly __brand: 'TaskId' };
-export type AgentId = string & { readonly __brand: 'AgentId' };
-export type CorrelationId = string & { readonly __brand: 'CorrelationId' };
-
-// Execution modes
-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; // 0.0 - 1.0
-  feedback: string;
-  iteration: number;
-  timestamp: string;
-}
-
-/**
- * Coordination Error Types
- */
-export 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',           // Invalid operation for current state
-}
-
-/**
- * Coordination Error
- * 
- * Typed error for coordination failures with mode awareness.
- */
-export class CoordinationError extends Error {
-  constructor(
-    public readonly type: CoordinationErrorType,
-    message: string,
-    public readonly mode?: ExecutionMode,
-    public readonly canRetry: boolean = false
-  ) {
-    super(message);
-    this.name = 'CoordinationError';
-    Object.setPrototypeOf(this, CoordinationError.prototype);
-  }
-}
-
-/**
- * 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 function isValidTaskId(value: unknown): value is TaskId {
-  return (
-    typeof value === 'string' &&
-    /^[a-zA-Z0-9_-]{1,256}$/.test(value) &&
-    value.length > 0
-  );
-}
-
-export function isValidAgentId(value: unknown): value is AgentId {
-  return (
-    typeof value === 'string' &&
-    /^[a-zA-Z0-9_-]{1,256}$/.test(value) &&
-    value.length > 0
-  );
-}
-
-export function isValidConfidence(value: unknown): value is number {
-  return typeof value === 'number' && value >= 0.0 && value <= 1.0;
-}
-
-export function validateTaskId(value: string): TaskId {
-  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 as TaskId;
-}
-
-export function validateAgentId(value: string): AgentId {
-  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 as AgentId;
-}
-
-export function validateConfidence(value: number): number {
-  if (!isValidConfidence(value)) {
-    throw new CoordinationError(
-      CoordinationErrorType.VALIDATION_ERROR,
-      `Invalid confidence value: ${value}. Must be between 0.0 and 1.0.`
-    );
-  }
-  return value;
-}