@agentic-qe/v3 3.0.0-alpha.5 → 3.0.0-alpha.7

package/src/mcp/tools/chaos-resilience/inject.ts

@@ -1,699 +0,0 @@
-/**
- * Agentic QE v3 - Chaos Resilience MCP Tool
- *
- * qe/chaos/inject - Chaos engineering fault injection
- *
- * This tool wraps the chaos-resilience domain service:
- * - ChaosEngineerService for fault injection and experiment execution
- */
-
-import { v4 as uuidv4 } from 'uuid';
-import { MCPToolBase, MCPToolConfig, MCPToolContext, MCPToolSchema } from '../base.js';
-import { ToolResult } from '../../types.js';
-import { MemoryBackend, VectorSearchResult } from '../../../kernel/interfaces.js';
-import { ChaosEngineerService } from '../../../domains/chaos-resilience/services/chaos-engineer.js';
-import {
-  ChaosExperiment,
-  FaultInjection,
-  FaultType as DomainFaultType,
-  SteadyStateDefinition,
-  ExperimentResult as DomainExperimentResult,
-  Incident as DomainIncident,
-} from '../../../domains/chaos-resilience/interfaces.js';
-
-// ============================================================================
-// Types
-// ============================================================================
-
-export interface ChaosInjectParams {
-  faultType: FaultType;
-  target: string;
-  duration?: number;
-  intensity?: number;
-  dryRun?: boolean;
-  hypothesis?: string;
-  rollbackOnFailure?: boolean;
-  [key: string]: unknown;
-}
-
-export type FaultType =
-  | 'latency'
-  | 'error'
-  | 'timeout'
-  | 'cpu-stress'
-  | 'memory-stress'
-  | 'network-partition'
-  | 'packet-loss'
-  | 'dns-failure'
-  | 'process-kill';
-
-export interface ChaosInjectResult {
-  experimentId: string;
-  status: ExperimentStatus;
-  faultInjected: boolean;
-  hypothesisValidated?: boolean;
-  steadyStateVerified: boolean;
-  metrics: ExperimentMetrics;
-  incidents: Incident[];
-  recommendations: string[];
-}
-
-export type ExperimentStatus = 'pending' | 'running' | 'completed' | 'failed' | 'rolled-back' | 'aborted';
-
-export interface ExperimentMetrics {
-  faultDuration: number;
-  targetAffected: boolean;
-  recoveryTime?: number;
-  errorRate?: number;
-  latencyP99?: number;
-}
-
-export interface Incident {
-  type: 'alert' | 'error' | 'degradation';
-  severity: 'critical' | 'high' | 'medium' | 'low';
-  message: string;
-  timestamp: string;
-  resolved: boolean;
-}
-
-// ============================================================================
-// Minimal Memory Backend for Standalone Operation
-// ============================================================================
-
-function createMinimalMemoryBackend(): MemoryBackend {
-  const store = new Map<string, { value: unknown; ttl?: number; created: number }>();
-
-  return {
-    async initialize(): Promise<void> {
-      // Minimal implementation - no initialization needed
-    },
-    async dispose(): Promise<void> {
-      store.clear();
-    },
-    async get<T>(key: string): Promise<T | undefined> {
-      const entry = store.get(key);
-      if (!entry) return undefined;
-      if (entry.ttl && Date.now() - entry.created > entry.ttl * 1000) {
-        store.delete(key);
-        return undefined;
-      }
-      return entry.value as T;
-    },
-    async set(key: string, value: unknown, options?: { ttl?: number }): Promise<void> {
-      store.set(key, { value, ttl: options?.ttl, created: Date.now() });
-    },
-    async delete(key: string): Promise<boolean> {
-      return store.delete(key);
-    },
-    async has(key: string): Promise<boolean> {
-      const entry = store.get(key);
-      if (!entry) return false;
-      if (entry.ttl && Date.now() - entry.created > entry.ttl * 1000) {
-        store.delete(key);
-        return false;
-      }
-      return true;
-    },
-    async search(pattern: string, limit = 100): Promise<string[]> {
-      const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
-      const matches: string[] = [];
-      for (const key of store.keys()) {
-        if (regex.test(key)) {
-          matches.push(key);
-          if (matches.length >= limit) break;
-        }
-      }
-      return matches;
-    },
-    async vectorSearch(_embedding: number[], _k = 10): Promise<VectorSearchResult[]> {
-      return [];
-    },
-    async storeVector(_key: string, _embedding: number[], _metadata?: Record<string, unknown>): Promise<void> {
-      // Minimal implementation
-    },
-  };
-}
-
-// ============================================================================
-// Tool Implementation
-// ============================================================================
-
-export class ChaosInjectTool extends MCPToolBase<ChaosInjectParams, ChaosInjectResult> {
-  readonly config: MCPToolConfig = {
-    name: 'qe/chaos/inject',
-    description: 'Inject faults for chaos engineering. Supports latency, errors, CPU/memory stress, network issues, and more.',
-    domain: 'chaos-resilience',
-    schema: CHAOS_INJECT_SCHEMA,
-    streaming: true,
-    timeout: 300000,
-  };
-
-  private chaosEngineer: ChaosEngineerService | null = null;
-
-  private getService(context: MCPToolContext): ChaosEngineerService {
-    if (!this.chaosEngineer) {
-      const memory = (context as unknown as Record<string, unknown>).memory as MemoryBackend || createMinimalMemoryBackend();
-      this.chaosEngineer = new ChaosEngineerService(memory, {
-        enableDryRun: true,
-        autoRollbackOnFailure: true,
-      });
-    }
-    return this.chaosEngineer;
-  }
-
-  async execute(
-    params: ChaosInjectParams,
-    context: MCPToolContext
-  ): Promise<ToolResult<ChaosInjectResult>> {
-    const {
-      faultType,
-      target,
-      duration = 30000,
-      intensity = 50,
-      dryRun = true,
-      hypothesis,
-      rollbackOnFailure = true,
-    } = params;
-
-    const chaosEngineer = this.getService(context);
-
-    try {
-      this.emitStream(context, {
-        status: 'preparing',
-        message: `Preparing ${faultType} fault injection on ${target}`,
-        dryRun,
-      });
-
-      if (this.isAborted(context)) {
-        return { success: false, error: 'Operation aborted' };
-      }
-
-      const experimentId = context.requestId || uuidv4();
-
-      // Build a chaos experiment from the simple parameters
-      const experiment = this.buildExperiment(
-        experimentId,
-        faultType,
-        target,
-        duration,
-        intensity,
-        hypothesis,
-        rollbackOnFailure
-      );
-
-      // Phase 1: Verify steady state
-      this.emitStream(context, {
-        status: 'verifying',
-        message: 'Verifying steady state',
-      });
-
-      const steadyStateResult = await chaosEngineer.verifySteadyState(experiment.steadyState);
-      const steadyStateVerified = steadyStateResult.success && steadyStateResult.value;
-
-      if (!steadyStateVerified && !dryRun) {
-        return {
-          success: false,
-          error: 'Steady state verification failed. System not in healthy state for chaos experiment.',
-        };
-      }
-
-      // Phase 2: Create and store experiment
-      const createResult = await chaosEngineer.createExperiment(experiment);
-      if (!createResult.success) {
-        return {
-          success: false,
-          error: `Failed to create experiment: ${createResult.error.message}`,
-        };
-      }
-
-      // Phase 3: Inject fault (or simulate in dry run)
-      this.emitStream(context, {
-        status: 'injecting',
-        message: dryRun
-          ? `[DRY RUN] Simulating ${faultType} fault`
-          : `Injecting ${faultType} fault`,
-      });
-
-      let faultInjected = false;
-      let hypothesisValidated: boolean | undefined;
-      let status: ExperimentStatus = 'pending';
-      const incidents: Incident[] = [];
-      let metrics: ExperimentMetrics = {
-        faultDuration: duration,
-        targetAffected: !dryRun,
-      };
-
-      if (dryRun) {
-        // Dry run - simulate the fault injection
-        faultInjected = false;
-        status = 'completed';
-
-        // Simulate metrics based on fault type
-        metrics = this.simulateMetrics(faultType, duration, intensity);
-
-        // Validate hypothesis if provided
-        if (hypothesis) {
-          hypothesisValidated = this.validateHypothesisText(hypothesis, metrics, incidents);
-        }
-      } else {
-        // Real execution - run the experiment
-        const runResult = await chaosEngineer.runExperiment(experimentId);
-
-        if (runResult.success) {
-          const result = runResult.value;
-          faultInjected = result.faultResults.some(f => f.injected);
-          hypothesisValidated = result.hypothesisValidated;
-          status = result.status;
-
-          // Convert domain incidents to MCP format
-          for (const incident of result.incidents) {
-            incidents.push(this.convertIncident(incident));
-          }
-
-          // Extract metrics from experiment result
-          metrics = this.extractMetrics(result, faultType, duration);
-        } else {
-          status = 'failed';
-          incidents.push({
-            type: 'error',
-            severity: 'critical',
-            message: runResult.error.message,
-            timestamp: new Date().toISOString(),
-            resolved: false,
-          });
-        }
-      }
-
-      // Phase 4: Monitor
-      this.emitStream(context, {
-        status: 'monitoring',
-        message: 'Monitoring system behavior',
-      });
-
-      // Collect any additional incidents based on intensity
-      const intensityIncidents = this.collectIntensityIncidents(faultType, intensity, dryRun);
-      incidents.push(...intensityIncidents);
-
-      // Determine final status based on incidents
-      if (!dryRun && incidents.some(i => i.severity === 'critical' && !i.resolved)) {
-        status = rollbackOnFailure ? 'rolled-back' : 'failed';
-      }
-
-      // Generate recommendations
-      const recommendations = this.generateRecommendations(
-        faultType,
-        metrics,
-        incidents,
-        hypothesisValidated
-      );
-
-      this.emitStream(context, {
-        status: 'complete',
-        message: `Chaos experiment ${status}`,
-        progress: 100,
-      });
-
-      return {
-        success: true,
-        data: {
-          experimentId,
-          status,
-          faultInjected,
-          hypothesisValidated,
-          steadyStateVerified,
-          metrics,
-          incidents,
-          recommendations,
-        },
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: `Chaos injection failed: ${error instanceof Error ? error.message : String(error)}`,
-      };
-    }
-  }
-
-  private buildExperiment(
-    experimentId: string,
-    faultType: FaultType,
-    target: string,
-    duration: number,
-    intensity: number,
-    hypothesis?: string,
-    rollbackOnFailure: boolean = true
-  ): ChaosExperiment {
-    // Build fault injection
-    const fault: FaultInjection = {
-      id: `fault-${experimentId}`,
-      type: faultType as DomainFaultType,
-      target: {
-        type: 'service',
-        selector: target,
-      },
-      duration,
-      parameters: this.buildFaultParameters(faultType, intensity),
-    };
-
-    // Build steady state definition with basic probe
-    const steadyState: SteadyStateDefinition = {
-      description: `Steady state for ${target}`,
-      probes: [
-        {
-          name: 'target-health',
-          type: target.startsWith('http') ? 'http' : 'command',
-          target: target.startsWith('http') ? target : `echo "checking ${target}"`,
-          expected: target.startsWith('http') ? 200 : 'OK',
-          timeout: 5000,
-        },
-      ],
-    };
-
-    // Build hypothesis
-    const experimentHypothesis = hypothesis || `System should remain stable under ${faultType} fault`;
-
-    return {
-      id: experimentId,
-      name: `${faultType}-experiment-${Date.now()}`,
-      description: `Chaos experiment: ${faultType} on ${target}`,
-      hypothesis: {
-        statement: experimentHypothesis,
-        metrics: [
-          {
-            metric: faultType === 'latency' ? 'response_time' : 'error_rate',
-            operator: 'lt' as const,
-            value: faultType === 'latency' ? 5000 : 50,
-          },
-        ],
-        tolerances: [
-          {
-            metric: 'availability',
-            maxDeviation: 20,
-            unit: 'percent',
-          },
-        ],
-      },
-      steadyState,
-      faults: [fault],
-      blastRadius: {
-        scope: 'single',
-        maxAffected: 1,
-        excludeProduction: true,
-      },
-      rollbackPlan: {
-        automatic: rollbackOnFailure,
-        triggerConditions: [
-          {
-            type: 'error-rate',
-            condition: 'error_rate > 50%',
-          },
-        ],
-        steps: [
-          {
-            order: 1,
-            action: `remove-fault`,
-            target: fault.id,
-            timeout: 10000,
-          },
-        ],
-      },
-      schedule: {
-        type: 'once',
-      },
-    };
-  }
-
-  private buildFaultParameters(faultType: FaultType, intensity: number): Record<string, unknown> {
-    const params: Record<string, unknown> = {};
-
-    switch (faultType) {
-      case 'latency':
-        params.latencyMs = 100 + (intensity * 20); // 100-2100ms based on intensity
-        break;
-      case 'error':
-        params.errorCode = 500;
-        params.errorRate = intensity / 100;
-        break;
-      case 'timeout':
-        params.timeoutMs = 5000 + (intensity * 250); // 5-30s timeout
-        break;
-      case 'cpu-stress':
-        params.cpuPercent = intensity;
-        params.cores = Math.max(1, Math.floor(intensity / 25));
-        break;
-      case 'memory-stress':
-        params.memoryBytes = (intensity / 100) * 512 * 1024 * 1024; // Up to 512MB
-        break;
-      case 'network-partition':
-        params.partitionPercent = intensity;
-        break;
-      case 'packet-loss':
-        params.packetLossPercent = intensity;
-        break;
-      case 'dns-failure':
-        params.failureRate = intensity / 100;
-        break;
-      case 'process-kill':
-        params.signal = 'SIGTERM';
-        break;
-    }
-
-    return params;
-  }
-
-  private simulateMetrics(
-    faultType: FaultType,
-    duration: number,
-    intensity: number
-  ): ExperimentMetrics {
-    const metrics: ExperimentMetrics = {
-      faultDuration: duration,
-      targetAffected: false,
-      recoveryTime: 5000 + (intensity * 100), // Base recovery + intensity factor
-    };
-
-    switch (faultType) {
-      case 'latency':
-        metrics.latencyP99 = 100 + (intensity * 25); // Base + intensity factor
-        break;
-      case 'error':
-      case 'timeout':
-        metrics.errorRate = intensity * 0.5; // Half of intensity as error rate
-        break;
-      case 'cpu-stress':
-      case 'memory-stress':
-        metrics.recoveryTime = 10000 + (intensity * 200);
-        break;
-    }
-
-    return metrics;
-  }
-
-  private extractMetrics(
-    result: DomainExperimentResult,
-    faultType: FaultType,
-    duration: number
-  ): ExperimentMetrics {
-    const metrics: ExperimentMetrics = {
-      faultDuration: duration,
-      targetAffected: result.faultResults.some(f => f.injected && f.affectedTargets > 0),
-    };
-
-    // Extract specific metrics from result
-    const metricSnapshots = result.metrics;
-
-    // Find recovery time
-    if (result.endTime && result.startTime) {
-      metrics.recoveryTime = result.endTime.getTime() - result.startTime.getTime();
-    }
-
-    // Find latency metrics
-    const latencyMetric = metricSnapshots.find(m => m.name.includes('latency') || m.name.includes('response'));
-    if (latencyMetric) {
-      metrics.latencyP99 = latencyMetric.value;
-    }
-
-    // Find error rate metrics
-    const errorMetric = metricSnapshots.find(m => m.name.includes('error') || m.name.includes('failure'));
-    if (errorMetric) {
-      metrics.errorRate = errorMetric.value;
-    }
-
-    return metrics;
-  }
-
-  private convertIncident(incident: DomainIncident): Incident {
-    return {
-      type: incident.type,
-      severity: incident.severity,
-      message: incident.message,
-      timestamp: incident.timestamp instanceof Date
-        ? incident.timestamp.toISOString()
-        : String(incident.timestamp),
-      resolved: incident.resolved,
-    };
-  }
-
-  private collectIntensityIncidents(
-    faultType: FaultType,
-    intensity: number,
-    dryRun: boolean
-  ): Incident[] {
-    const incidents: Incident[] = [];
-
-    if (dryRun) {
-      // In dry run, simulate what incidents might occur
-      if (intensity > 70) {
-        incidents.push({
-          type: 'alert',
-          severity: 'high',
-          message: `[Simulated] High ${faultType} impact would be detected`,
-          timestamp: new Date().toISOString(),
-          resolved: true,
-        });
-      }
-
-      if (intensity > 90) {
-        incidents.push({
-          type: 'degradation',
-          severity: 'critical',
-          message: '[Simulated] Service degradation would occur',
-          timestamp: new Date().toISOString(),
-          resolved: true,
-        });
-      }
-    }
-
-    return incidents;
-  }
-
-  private validateHypothesisText(
-    hypothesis: string,
-    metrics: ExperimentMetrics,
-    incidents: Incident[]
-  ): boolean {
-    const hypothesisLower = hypothesis.toLowerCase();
-
-    // Check recovery time hypothesis
-    if (hypothesisLower.includes('recover') && metrics.recoveryTime) {
-      const timeMatch = hypothesis.match(/(\d+)s/);
-      if (timeMatch) {
-        const expectedTime = parseInt(timeMatch[1]) * 1000;
-        return metrics.recoveryTime <= expectedTime;
-      }
-    }
-
-    // Check no critical incidents hypothesis
-    if (hypothesisLower.includes('no critical')) {
-      return !incidents.some(i => i.severity === 'critical' && !i.resolved);
-    }
-
-    // Check stable hypothesis
-    if (hypothesisLower.includes('stable') || hypothesisLower.includes('remain')) {
-      return !incidents.some(i => i.severity === 'critical' && !i.resolved);
-    }
-
-    // Default: validated if no unresolved critical incidents
-    return !incidents.some(i => i.severity === 'critical' && !i.resolved);
-  }
-
-  private generateRecommendations(
-    faultType: FaultType,
-    metrics: ExperimentMetrics,
-    incidents: Incident[],
-    hypothesisValidated?: boolean
-  ): string[] {
-    const recs: string[] = [];
-
-    if (hypothesisValidated === false) {
-      recs.push('Hypothesis was not validated - review resilience patterns');
-    }
-
-    if (metrics.recoveryTime && metrics.recoveryTime > 30000) {
-      recs.push('Recovery time exceeds 30s - consider adding circuit breakers');
-    }
-
-    if (metrics.errorRate && metrics.errorRate > 20) {
-      recs.push('High error rate observed - implement retry with backoff');
-    }
-
-    if (incidents.some(i => i.severity === 'critical')) {
-      recs.push('Critical incidents occurred - review fault tolerance mechanisms');
-    }
-
-    switch (faultType) {
-      case 'latency':
-        if (metrics.latencyP99 && metrics.latencyP99 > 1000) {
-          recs.push('P99 latency exceeds 1s - consider timeout configurations');
-        }
-        break;
-      case 'network-partition':
-        recs.push('Ensure services can operate in degraded mode during network issues');
-        break;
-      case 'cpu-stress':
-      case 'memory-stress':
-        recs.push('Review resource limits and auto-scaling policies');
-        break;
-      case 'error':
-        recs.push('Implement proper error handling and fallback mechanisms');
-        break;
-      case 'timeout':
-        recs.push('Configure appropriate timeout values and circuit breakers');
-        break;
-    }
-
-    if (recs.length === 0) {
-      recs.push('System showed good resilience - continue regular chaos experiments');
-    }
-
-    return recs;
-  }
-}
-
-// ============================================================================
-// Schema
-// ============================================================================
-
-const CHAOS_INJECT_SCHEMA: MCPToolSchema = {
-  type: 'object',
-  properties: {
-    faultType: {
-      type: 'string',
-      description: 'Type of fault to inject',
-      enum: ['latency', 'error', 'timeout', 'cpu-stress', 'memory-stress', 'network-partition', 'packet-loss', 'dns-failure', 'process-kill'],
-    },
-    target: {
-      type: 'string',
-      description: 'Target service, pod, or endpoint',
-    },
-    duration: {
-      type: 'number',
-      description: 'Fault duration in milliseconds',
-      minimum: 1000,
-      maximum: 300000,
-      default: 30000,
-    },
-    intensity: {
-      type: 'number',
-      description: 'Fault intensity (0-100)',
-      minimum: 0,
-      maximum: 100,
-      default: 50,
-    },
-    dryRun: {
-      type: 'boolean',
-      description: 'Simulate without actual injection',
-      default: true,
-    },
-    hypothesis: {
-      type: 'string',
-      description: 'Hypothesis to validate (e.g., "System should recover within 30s")',
-    },
-    rollbackOnFailure: {
-      type: 'boolean',
-      description: 'Auto-rollback on critical failure',
-      default: true,
-    },
-  },
-  required: ['faultType', 'target'],
-};