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

package/src/time-crystal/types.ts

@@ -1,421 +0,0 @@
-/**
- * Agentic QE v3 - Time Crystal Scheduling Types
- * ADR-032: Kuramoto CPG oscillators for self-sustaining scheduling
- *
- * Based on RuVector MinCut Analysis (time_crystal.rs):
- * Time crystals exhibit periodic self-sustaining patterns. The SNN equivalent
- * is a Central Pattern Generator - coupled oscillators that produce rhythmic
- * output without external timing.
- */
-
-// ============================================================================
-// Test Execution Phase Types
-// ============================================================================
-
-/**
- * Types of tests that can be executed
- */
-export type TestType =
-  | 'unit'
-  | 'integration'
-  | 'e2e'
-  | 'performance'
-  | 'security'
-  | 'visual'
-  | 'accessibility'
-  | 'contract';
-
-/**
- * Quality thresholds for phase completion
- */
-export interface PhaseThresholds {
-  /** Minimum pass rate to proceed (0-1) */
-  readonly minPassRate: number;
-
-  /** Maximum flaky test tolerance (0-1) */
-  readonly maxFlakyRatio: number;
-
-  /** Minimum coverage requirement (0-1) */
-  readonly minCoverage: number;
-}
-
-/**
- * Agent configuration for a phase
- */
-export interface PhaseAgentConfig {
-  /** Agent types to use in this phase */
-  readonly agents: string[];
-
-  /** Parallelism level */
-  readonly parallelism: number;
-}
-
-/**
- * Test execution phase definition
- */
-export interface TestPhase {
-  /** Phase identifier (0 to n-1) */
-  readonly id: number;
-
-  /** Phase name */
-  readonly name: string;
-
-  /** Test types executed in this phase */
-  readonly testTypes: TestType[];
-
-  /** Expected duration (ms) */
-  readonly expectedDuration: number;
-
-  /** Quality thresholds for phase completion */
-  readonly qualityThresholds: PhaseThresholds;
-
-  /** Phase-specific agent configuration */
-  readonly agentConfig: PhaseAgentConfig;
-}
-
-// ============================================================================
-// CPG Configuration Types
-// ============================================================================
-
-/**
- * Central Pattern Generator configuration
- */
-export interface CPGConfig {
-  /** Number of phases in the crystal */
-  readonly numPhases: number;
-
-  /** Oscillation frequency (Hz) - how fast phases cycle */
-  readonly frequency: number;
-
-  /** Coupling strength between adjacent phases (Kuramoto K parameter) */
-  readonly coupling: number;
-
-  /** Stability threshold for phase transitions */
-  readonly stabilityThreshold: number;
-
-  /** Time step for simulation (ms) */
-  readonly dt: number;
-
-  /** Phase transition threshold (activity level to trigger transition) */
-  readonly transitionThreshold: number;
-}
-
-/**
- * Default CPG configuration for demo/testing
- */
-export const DEFAULT_CPG_CONFIG: CPGConfig = {
-  numPhases: 4,
-  frequency: 0.1,           // 0.1 Hz = 10s per cycle in demo mode
-  coupling: 0.3,            // Moderate coupling strength
-  stabilityThreshold: 0.1,
-  dt: 100,                  // 100ms time steps
-  transitionThreshold: 0.8,
-};
-
-/**
- * Production CPG configuration for real workloads
- */
-export const PRODUCTION_CPG_CONFIG: CPGConfig = {
-  numPhases: 4,
-  frequency: 0.001,         // 0.001 Hz = ~17 min per full cycle
-  coupling: 0.3,
-  stabilityThreshold: 0.1,
-  dt: 1000,                 // 1s time steps
-  transitionThreshold: 0.8,
-};
-
-/**
- * Fast CPG configuration for testing
- */
-export const FAST_CPG_CONFIG: CPGConfig = {
-  numPhases: 4,
-  frequency: 1.0,           // 1 Hz = 1s per cycle
-  coupling: 0.3,
-  stabilityThreshold: 0.1,
-  dt: 10,                   // 10ms time steps
-  transitionThreshold: 0.8,
-};
-
-// ============================================================================
-// Phase Transition Types
-// ============================================================================
-
-/**
- * Represents a transition between test execution phases
- */
-export interface PhaseTransition {
-  /** Source phase index */
-  readonly from: number;
-
-  /** Target phase index */
-  readonly to: number;
-
-  /** Timestamp when transition occurred (simulation time in ms) */
-  readonly timestamp: number;
-
-  /** Source phase definition */
-  readonly fromPhase: TestPhase;
-
-  /** Target phase definition */
-  readonly toPhase: TestPhase;
-}
-
-/**
- * Result of executing a test phase
- */
-export interface PhaseResult {
-  /** Phase identifier */
-  readonly phaseId: number;
-
-  /** Phase name */
-  readonly phaseName: string;
-
-  /** Test pass rate (0-1) */
-  readonly passRate: number;
-
-  /** Flaky test ratio (0-1) */
-  readonly flakyRatio: number;
-
-  /** Code coverage achieved (0-1) */
-  readonly coverage: number;
-
-  /** Actual duration in ms */
-  readonly duration: number;
-
-  /** Total tests executed */
-  readonly testsRun: number;
-
-  /** Tests that passed */
-  readonly testsPassed: number;
-
-  /** Tests that failed */
-  readonly testsFailed: number;
-
-  /** Tests that were skipped */
-  readonly testsSkipped: number;
-
-  /** Whether quality thresholds were met */
-  readonly qualityMet: boolean;
-}
-
-// ============================================================================
-// Oscillator Types
-// ============================================================================
-
-/**
- * State of an oscillator neuron
- */
-export interface OscillatorState {
-  /** Oscillator identifier */
-  readonly id: number;
-
-  /** Current phase angle (0 to 2*PI radians) */
-  readonly phase: number;
-
-  /** Natural angular frequency (rad/ms) */
-  readonly omega: number;
-
-  /** Oscillation amplitude */
-  readonly amplitude: number;
-
-  /** Current activity level (-1 to 1) */
-  readonly activity: number;
-}
-
-/**
- * Coupling matrix entry
- */
-export interface CouplingEntry {
-  /** Source oscillator index */
-  readonly from: number;
-
-  /** Target oscillator index */
-  readonly to: number;
-
-  /** Coupling strength */
-  readonly strength: number;
-}
-
-// ============================================================================
-// Scheduler Types
-// ============================================================================
-
-/**
- * Time Crystal Scheduler state
- */
-export interface SchedulerState {
-  /** Whether the scheduler is running */
-  readonly running: boolean;
-
-  /** Current simulation time (ms) */
-  readonly time: number;
-
-  /** Current active phase index */
-  readonly currentPhase: number;
-
-  /** Phase transition history */
-  readonly phaseHistory: number[];
-
-  /** Oscillator states */
-  readonly oscillatorStates: OscillatorState[];
-
-  /** Whether crystal is exhibiting stable periodic behavior */
-  readonly isStable: boolean;
-}
-
-/**
- * Test runner interface for real test execution
- * Full implementation in phase-executor.ts
- */
-export interface TestRunnerRef {
-  run(
-    testTypes: string[],
-    options: {
-      parallelism: number;
-      timeout: number;
-      collectCoverage: boolean;
-      retryFailed: boolean;
-      maxRetries: number;
-      filter?: string;
-    }
-  ): Promise<{
-    total: number;
-    passed: number;
-    failed: number;
-    skipped: number;
-    flaky: number;
-    coverage: number;
-    duration: number;
-  }>;
-}
-
-/**
- * Scheduler configuration options
- */
-export interface SchedulerOptions {
-  /** CPG configuration */
-  readonly cpgConfig: CPGConfig;
-
-  /** Whether to auto-start on creation */
-  readonly autoStart: boolean;
-
-  /** Maximum phase history to retain */
-  readonly maxHistoryLength: number;
-
-  /**
-   * Test runner for REAL test execution.
-   * Use VitestTestRunner or JestTestRunner from test-runner.ts.
-   * If not provided, scheduler uses MOCK MODE with deterministic fake data.
-   */
-  readonly testRunner?: TestRunnerRef;
-
-  /** Callback for phase transitions */
-  readonly onPhaseTransition?: (transition: PhaseTransition) => void | Promise<void>;
-
-  /** Callback for phase execution */
-  readonly onPhaseExecute?: (phase: TestPhase) => Promise<PhaseResult>;
-
-  /** Callback for quality gate failures */
-  readonly onQualityFailure?: (phase: TestPhase, result: PhaseResult) => void | Promise<void>;
-}
-
-/**
- * Default scheduler options
- */
-export const DEFAULT_SCHEDULER_OPTIONS: Omit<SchedulerOptions, 'onPhaseTransition' | 'onPhaseExecute' | 'onQualityFailure'> = {
-  cpgConfig: DEFAULT_CPG_CONFIG,
-  autoStart: false,
-  maxHistoryLength: 1000,
-};
-
-// ============================================================================
-// Crystal Health Types
-// ============================================================================
-
-/**
- * Crystal health status
- */
-export type CrystalHealthStatus = 'healthy' | 'degraded' | 'unstable' | 'broken';
-
-/**
- * Crystal health metrics
- */
-export interface CrystalHealth {
-  /** Overall health status */
-  readonly status: CrystalHealthStatus;
-
-  /** Whether oscillators are synchronized */
-  readonly synchronized: boolean;
-
-  /** Order parameter (0-1, higher = more synchronized) */
-  readonly orderParameter: number;
-
-  /** Phase coherence measure */
-  readonly coherence: number;
-
-  /** Number of completed cycles */
-  readonly completedCycles: number;
-
-  /** Average cycle duration (ms) */
-  readonly averageCycleDuration: number;
-
-  /** Phase execution success rate */
-  readonly phaseSuccessRate: number;
-
-  /** Issues detected */
-  readonly issues: CrystalIssue[];
-}
-
-/**
- * Crystal issue
- */
-export interface CrystalIssue {
-  /** Issue type */
-  readonly type: 'desynchronization' | 'quality_failure' | 'stall' | 'oscillation_decay';
-
-  /** Issue severity */
-  readonly severity: 'low' | 'medium' | 'high' | 'critical';
-
-  /** Human-readable description */
-  readonly message: string;
-
-  /** Timestamp when detected */
-  readonly timestamp: number;
-
-  /** Affected phase (if applicable) */
-  readonly affectedPhase?: number;
-}
-
-// ============================================================================
-// Event Types
-// ============================================================================
-
-/**
- * Time Crystal event types
- */
-export type TimeCrystalEventType =
-  | 'crystal:started'
-  | 'crystal:stopped'
-  | 'crystal:tick'
-  | 'phase:transition'
-  | 'phase:started'
-  | 'phase:completed'
-  | 'phase:failed'
-  | 'quality:failure'
-  | 'crystal:repair'
-  | 'crystal:stable'
-  | 'crystal:unstable';
-
-/**
- * Base Time Crystal event
- */
-export interface TimeCrystalEvent {
-  /** Event type */
-  readonly type: TimeCrystalEventType;
-
-  /** Timestamp (simulation time in ms) */
-  readonly timestamp: number;
-
-  /** Event payload */
-  readonly payload: Record<string, unknown>;
-}

package/src/workers/base-worker.ts

@@ -1,304 +0,0 @@
-/**
- * Agentic QE v3 - Base Worker Implementation
- * ADR-014: Background Workers for QE Monitoring
- *
- * Abstract base class for all QE background workers.
- * Provides common functionality for scheduling, retries, and health tracking.
- */
-
-import {
-  Worker,
-  WorkerConfig,
-  WorkerStatus,
-  WorkerResult,
-  WorkerContext,
-  WorkerHealth,
-  WorkerMetrics,
-  WorkerFinding,
-  WorkerRecommendation,
-} from './interfaces';
-
-/**
- * Abstract base class for QE background workers
- */
-export abstract class BaseWorker implements Worker {
-  protected _status: WorkerStatus = 'idle';
-  protected _lastResult?: WorkerResult;
-  protected _lastRunAt?: Date;
-  protected _nextRunAt?: Date;
-
-  // Health tracking
-  protected _totalExecutions = 0;
-  protected _successfulExecutions = 0;
-  protected _failedExecutions = 0;
-  protected _executionDurations: number[] = [];
-  protected _recentResults: Array<{
-    timestamp: Date;
-    success: boolean;
-    durationMs: number;
-  }> = [];
-
-  constructor(public readonly config: WorkerConfig) {}
-
-  get status(): WorkerStatus {
-    return this._status;
-  }
-
-  get lastResult(): WorkerResult | undefined {
-    return this._lastResult;
-  }
-
-  get lastRunAt(): Date | undefined {
-    return this._lastRunAt;
-  }
-
-  get nextRunAt(): Date | undefined {
-    return this._nextRunAt;
-  }
-
-  /**
-   * Initialize the worker
-   * Override in subclasses for custom initialization
-   */
-  async initialize(): Promise<void> {
-    this._status = 'idle';
-    this._nextRunAt = new Date(Date.now() + this.config.intervalMs);
-  }
-
-  /**
-   * Execute the worker's main task with retry logic
-   */
-  async execute(context: WorkerContext): Promise<WorkerResult> {
-    const startTime = Date.now();
-    this._status = 'running';
-    this._lastRunAt = new Date();
-    this._totalExecutions++;
-
-    let lastError: Error | undefined;
-    let result: WorkerResult | undefined;
-
-    // Retry loop
-    for (let attempt = 0; attempt <= this.config.retryCount; attempt++) {
-      try {
-        // Check for abort
-        if (context.signal.aborted) {
-          throw new Error('Worker execution aborted');
-        }
-
-        // Execute with timeout
-        result = await this.executeWithTimeout(
-          () => this.doExecute(context),
-          this.config.timeoutMs,
-          context.signal
-        );
-
-        break; // Success, exit retry loop
-      } catch (error) {
-        lastError = error instanceof Error ? error : new Error(String(error));
-        context.logger.warn(
-          `Worker ${this.config.id} attempt ${attempt + 1} failed: ${lastError.message}`
-        );
-
-        if (attempt < this.config.retryCount) {
-          await this.delay(this.config.retryDelayMs);
-        }
-      }
-    }
-
-    const durationMs = Date.now() - startTime;
-
-    if (result) {
-      this._successfulExecutions++;
-      this._lastResult = result;
-    } else {
-      this._failedExecutions++;
-      result = this.createErrorResult(lastError!, durationMs);
-      this._lastResult = result;
-    }
-
-    // Track execution metrics
-    this._executionDurations.push(durationMs);
-    if (this._executionDurations.length > 100) {
-      this._executionDurations.shift();
-    }
-
-    this._recentResults.push({
-      timestamp: new Date(),
-      success: result.success,
-      durationMs,
-    });
-    if (this._recentResults.length > 5) {
-      this._recentResults.shift();
-    }
-
-    // Schedule next run
-    this._nextRunAt = new Date(Date.now() + this.config.intervalMs);
-    this._status = result.success ? 'idle' : 'error';
-
-    // Publish result event
-    await context.eventBus.publish({
-      type: 'worker.executed',
-      workerId: this.config.id,
-      timestamp: new Date(),
-      payload: {
-        success: result.success,
-        durationMs,
-        findingsCount: result.findings.length,
-        healthScore: result.metrics.healthScore,
-      },
-    });
-
-    return result;
-  }
-
-  /**
-   * Abstract method - implement in subclasses
-   * Contains the actual worker logic
-   */
-  protected abstract doExecute(context: WorkerContext): Promise<WorkerResult>;
-
-  /**
-   * Pause the worker
-   */
-  pause(): void {
-    if (this._status !== 'stopped') {
-      this._status = 'paused';
-    }
-  }
-
-  /**
-   * Resume the worker
-   */
-  resume(): void {
-    if (this._status === 'paused') {
-      this._status = 'idle';
-    }
-  }
-
-  /**
-   * Stop the worker
-   */
-  async stop(): Promise<void> {
-    this._status = 'stopped';
-  }
-
-  /**
-   * Get worker health status
-   */
-  getHealth(): WorkerHealth {
-    const avgDurationMs =
-      this._executionDurations.length > 0
-        ? this._executionDurations.reduce((a, b) => a + b, 0) /
-          this._executionDurations.length
-        : 0;
-
-    const successRate =
-      this._totalExecutions > 0
-        ? this._successfulExecutions / this._totalExecutions
-        : 1;
-
-    return {
-      status: this._status,
-      healthScore: Math.round(successRate * 100),
-      totalExecutions: this._totalExecutions,
-      successfulExecutions: this._successfulExecutions,
-      failedExecutions: this._failedExecutions,
-      avgDurationMs: Math.round(avgDurationMs),
-      recentResults: [...this._recentResults],
-    };
-  }
-
-  // ============================================================================
-  // Helper Methods
-  // ============================================================================
-
-  /**
-   * Execute a function with timeout
-   */
-  protected async executeWithTimeout<T>(
-    fn: () => Promise<T>,
-    timeoutMs: number,
-    signal: AbortSignal
-  ): Promise<T> {
-    return new Promise((resolve, reject) => {
-      const timeoutId = setTimeout(() => {
-        reject(new Error(`Worker execution timed out after ${timeoutMs}ms`));
-      }, timeoutMs);
-
-      const abortHandler = () => {
-        clearTimeout(timeoutId);
-        reject(new Error('Worker execution aborted'));
-      };
-
-      signal.addEventListener('abort', abortHandler, { once: true });
-
-      fn()
-        .then((result) => {
-          clearTimeout(timeoutId);
-          signal.removeEventListener('abort', abortHandler);
-          resolve(result);
-        })
-        .catch((error) => {
-          clearTimeout(timeoutId);
-          signal.removeEventListener('abort', abortHandler);
-          reject(error);
-        });
-    });
-  }
-
-  /**
-   * Create an error result
-   */
-  protected createErrorResult(error: Error, durationMs: number): WorkerResult {
-    return {
-      workerId: this.config.id,
-      timestamp: new Date(),
-      durationMs,
-      success: false,
-      error: error.message,
-      metrics: {
-        itemsAnalyzed: 0,
-        issuesFound: 0,
-        healthScore: 0,
-        trend: 'degrading',
-        domainMetrics: {},
-      },
-      findings: [],
-      recommendations: [],
-    };
-  }
-
-  /**
-   * Create a successful result
-   */
-  protected createResult(
-    durationMs: number,
-    metrics: WorkerMetrics,
-    findings: WorkerFinding[],
-    recommendations: WorkerRecommendation[]
-  ): WorkerResult {
-    return {
-      workerId: this.config.id,
-      timestamp: new Date(),
-      durationMs,
-      success: true,
-      metrics,
-      findings,
-      recommendations,
-    };
-  }
-
-  /**
-   * Delay helper
-   */
-  protected delay(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-
-  /**
-   * Generate a unique ID
-   */
-  protected generateId(): string {
-    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-  }
-}