agentic-qe 3.8.4 → 3.8.6

package/dist/coordination/mincut/time-crystal-scheduling.js

@@ -0,0 +1,213 @@
+/**
+ * Agentic QE v3 - Time Crystal Scheduling Algorithms
+ * ADR-047: MinCut Self-Organizing QE Integration - Phase 4
+ *
+ * Pure functions for computing optimal execution order, topological sorting,
+ * parallel execution groups, and schedule optimization decisions.
+ */
+/**
+ * Compute optimal execution order based on priority and execution time
+ */
+export function computeOptimalOrder(lattice) {
+    const nodes = Array.from(lattice.nodes.values());
+    // Sort by priority (higher first), then by execution time (shorter first)
+    nodes.sort((a, b) => {
+        if (b.priority !== a.priority) {
+            return b.priority - a.priority;
+        }
+        return a.avgExecutionTime - b.avgExecutionTime;
+    });
+    // Apply topological sort for dependencies
+    return topologicalSort(nodes.map(n => n.id), lattice);
+}
+/**
+ * Topological sort respecting dependencies (Kahn's algorithm)
+ */
+export function topologicalSort(nodeIds, lattice) {
+    const inDegree = new Map();
+    const adjacency = new Map();
+    // Initialize
+    for (const id of nodeIds) {
+        inDegree.set(id, 0);
+        adjacency.set(id, []);
+    }
+    // Build adjacency and in-degree from dependencies
+    for (const dep of lattice.dependencies) {
+        if (dep.type === 'must-precede' || dep.type === 'should-precede') {
+            const targets = adjacency.get(dep.sourceId) || [];
+            targets.push(dep.targetId);
+            adjacency.set(dep.sourceId, targets);
+            const degree = inDegree.get(dep.targetId) || 0;
+            inDegree.set(dep.targetId, degree + 1);
+        }
+    }
+    // Kahn's algorithm
+    const queue = nodeIds.filter(id => (inDegree.get(id) || 0) === 0);
+    const result = [];
+    while (queue.length > 0) {
+        const node = queue.shift();
+        result.push(node);
+        for (const neighbor of adjacency.get(node) || []) {
+            const degree = (inDegree.get(neighbor) || 1) - 1;
+            inDegree.set(neighbor, degree);
+            if (degree === 0) {
+                queue.push(neighbor);
+            }
+        }
+    }
+    // Add any remaining nodes (in case of cycles)
+    for (const id of nodeIds) {
+        if (!result.includes(id)) {
+            result.push(id);
+        }
+    }
+    return result;
+}
+/**
+ * Compute parallel execution groups respecting dependencies and conflicts
+ */
+export function computeParallelGroups(lattice, maxParallelGroups) {
+    const groups = [];
+    const scheduled = new Set();
+    const nodes = Array.from(lattice.nodes.values());
+    while (scheduled.size < nodes.length) {
+        const group = [];
+        for (const node of nodes) {
+            if (scheduled.has(node.id))
+                continue;
+            // Check if all dependencies are satisfied
+            const canSchedule = lattice.dependencies
+                .filter(d => d.targetId === node.id && (d.type === 'must-precede' || d.type === 'should-precede'))
+                .every(d => scheduled.has(d.sourceId));
+            // Check for conflicts with current group
+            const hasConflict = lattice.dependencies
+                .filter(d => d.type === 'conflicts')
+                .some(d => (d.sourceId === node.id && group.includes(d.targetId)) ||
+                (d.targetId === node.id && group.includes(d.sourceId)));
+            if (canSchedule && !hasConflict && group.length < maxParallelGroups) {
+                group.push(node.id);
+            }
+        }
+        if (group.length === 0) {
+            // No progress - break to avoid infinite loop
+            break;
+        }
+        groups.push(group);
+        for (const id of group) {
+            scheduled.add(id);
+        }
+    }
+    return groups;
+}
+/**
+ * Check if two execution orders differ significantly (>20% positions changed)
+ */
+export function ordersDiffer(a, b) {
+    if (a.length !== b.length)
+        return true;
+    let differences = 0;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+            differences++;
+        }
+    }
+    // Consider different if more than 20% of positions changed
+    return differences > a.length * 0.2;
+}
+/**
+ * Determine the optimal schedule optimization action
+ */
+export function determineOptimization(lattice, observations, causalGraph, maxParallelGroups) {
+    // Check if optimization is needed
+    const lastObs = observations[observations.length - 1];
+    if (!lastObs || lastObs.attractor === 'stable' && lastObs.anomalies.length === 0) {
+        return { type: 'no_change', reason: 'System is stable with no anomalies' };
+    }
+    // Analyze execution order for optimization
+    const optimizedOrder = computeOptimalOrder(lattice);
+    if (ordersDiffer(optimizedOrder, lattice.executionOrder)) {
+        return { type: 'reorder', newOrder: optimizedOrder };
+    }
+    // Analyze parallelization opportunities
+    const parallelGroups = computeParallelGroups(lattice, maxParallelGroups);
+    if (parallelGroups.length > lattice.parallelGroups.length) {
+        return { type: 'parallelize', groups: parallelGroups };
+    }
+    // Check for flaky tests to skip
+    if (causalGraph) {
+        const recentFailures = causalGraph.getAllFailures()
+            .filter(f => Date.now() - f.timestamp.getTime() < 3600000); // Last hour
+        const failureCounts = new Map();
+        for (const failure of recentFailures) {
+            const count = failureCounts.get(failure.testId) || 0;
+            failureCounts.set(failure.testId, count + 1);
+        }
+        // Find repeatedly failing tests
+        for (const [testId, count] of Array.from(failureCounts.entries())) {
+            if (count >= 3) {
+                return {
+                    type: 'skip',
+                    nodeId: testId,
+                    reason: `Test has failed ${count} times in the last hour`,
+                };
+            }
+        }
+    }
+    return { type: 'no_change', reason: 'No optimization opportunities found' };
+}
+/**
+ * Rebuild lattice from a causal graph's failure data
+ */
+export function rebuildLatticeFromCausalGraph(lattice, causalGraph, maxParallelGroups) {
+    const failures = causalGraph.getAllFailures();
+    const testIds = new Set();
+    for (const failure of failures) {
+        testIds.add(failure.testId);
+    }
+    const testIdArray = Array.from(testIds);
+    // Create nodes for each test
+    for (const testId of testIdArray) {
+        const testFailures = failures.filter(f => f.testId === testId);
+        const avgDuration = 5000; // Default
+        const failureRate = testFailures.length / Math.max(1, failures.length / testIds.size);
+        lattice.nodes.set(testId, {
+            id: testId,
+            type: 'test',
+            avgExecutionTime: avgDuration,
+            failureProbability: Math.min(1, failureRate),
+            priority: 1 - failureRate, // Lower priority for flaky tests
+            resources: { cpu: 1, memory: 256, io: 1 },
+        });
+    }
+    // Build dependencies from causal links
+    for (const testId of testIdArray) {
+        const testFailures = failures.filter(f => f.testId === testId);
+        for (const failure of testFailures) {
+            const effects = causalGraph.getEffects(failure.id);
+            for (const effect of effects) {
+                if (testId !== effect.testId) {
+                    // Check if dependency already exists
+                    const existing = lattice.dependencies.find(d => d.sourceId === testId && d.targetId === effect.testId);
+                    if (existing) {
+                        existing.observationCount++;
+                    }
+                    else {
+                        lattice.dependencies.push({
+                            sourceId: testId,
+                            targetId: effect.testId,
+                            type: 'should-precede',
+                            strength: 0.5,
+                            latencyMs: effect.timestamp.getTime() - failure.timestamp.getTime(),
+                            observationCount: 1,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    // Recompute execution order and parallel groups
+    lattice.executionOrder = computeOptimalOrder(lattice);
+    lattice.parallelGroups = computeParallelGroups(lattice, maxParallelGroups);
+    lattice.lastOptimized = new Date();
+}
+//# sourceMappingURL=time-crystal-scheduling.js.map

package/dist/coordination/mincut/time-crystal-types.d.ts

@@ -0,0 +1,278 @@
+/**
+ * Agentic QE v3 - Time Crystal Types & Interfaces
+ * ADR-047: MinCut Self-Organizing QE Integration - Phase 4
+ *
+ * All types, interfaces, and configuration constants for the Time Crystal
+ * CI/CD coordination system.
+ */
+import type { CPGConfig, CPGTestPhase, CPGPhaseResult } from './kuramoto-cpg';
+import type { DomainName } from '../../shared/types';
+/** Domain name for time crystal events */
+export declare const TIME_CRYSTAL_SOURCE: DomainName;
+/**
+ * Temporal attractors - states the CI/CD system naturally evolves toward
+ */
+export type TemporalAttractor = 'stable' | 'degraded' | 'chaotic';
+/**
+ * Phase state in the time crystal
+ */
+export type PhaseState = 'dormant' | 'activating' | 'active' | 'completing' | 'cooldown';
+/**
+ * CI/CD execution metrics for a time window
+ */
+export interface ExecutionMetrics {
+    /** Timestamp of the metrics */
+    readonly timestamp: Date;
+    /** Number of builds executed */
+    readonly buildCount: number;
+    /** Number of successful builds */
+    readonly successfulBuilds: number;
+    /** Number of tests executed */
+    readonly testCount: number;
+    /** Number of tests passed */
+    readonly testsPassed: number;
+    /** Number of tests failed */
+    readonly testsFailed: number;
+    /** Average build duration (ms) */
+    readonly avgBuildDuration: number;
+    /** Average test duration (ms) */
+    readonly avgTestDuration: number;
+    /** Resource utilization (0-1) */
+    readonly resourceUtilization: number;
+    /** Queue depth (pending items) */
+    readonly queueDepth: number;
+    /** Throughput (items/minute) */
+    readonly throughput: number;
+}
+/**
+ * Time crystal phase representing a periodic CI/CD pattern
+ */
+export interface TimeCrystalPhase {
+    /** Phase ID */
+    readonly id: string;
+    /** Phase name */
+    readonly name: string;
+    /** Phase state */
+    state: PhaseState;
+    /** Phase period (ms) - how long a complete cycle takes */
+    readonly periodMs: number;
+    /** Phase offset (ms) - when this phase starts within a cycle */
+    readonly offsetMs: number;
+    /** Expected duration (ms) */
+    readonly expectedDuration: number;
+    /** Optimal parallelism for this phase */
+    readonly optimalParallelism: number;
+    /** Test types typically run in this phase */
+    readonly testTypes: string[];
+    /** Historical success rate (0-1) */
+    successRate: number;
+    /** Average actual duration (ms) */
+    avgActualDuration: number;
+    /** Execution count */
+    executionCount: number;
+    /** Last activation timestamp */
+    lastActivation?: Date;
+}
+/**
+ * Temporal dependency between execution units
+ */
+export interface TemporalDependency {
+    /** Source execution unit ID */
+    readonly sourceId: string;
+    /** Target execution unit ID */
+    readonly targetId: string;
+    /** Dependency type */
+    readonly type: 'must-precede' | 'should-precede' | 'independent' | 'conflicts';
+    /** Dependency strength (0-1) */
+    readonly strength: number;
+    /** Historical latency between executions (ms) */
+    readonly latencyMs: number;
+    /** Observation count */
+    observationCount: number;
+}
+/**
+ * Crystal lattice - network of temporal dependencies
+ */
+export interface CrystalLattice {
+    /** All execution units in the lattice */
+    readonly nodes: Map<string, LatticeNode>;
+    /** Dependencies between nodes */
+    readonly dependencies: TemporalDependency[];
+    /** Computed execution order (mutable for optimization) */
+    executionOrder: string[];
+    /** Parallel execution groups (mutable for optimization) */
+    parallelGroups: string[][];
+    /** Last optimization timestamp */
+    lastOptimized: Date;
+}
+/**
+ * Node in the crystal lattice
+ */
+export interface LatticeNode {
+    /** Node ID (test or build unit) */
+    readonly id: string;
+    /** Node type */
+    readonly type: 'test' | 'build' | 'deploy' | 'validate';
+    /** Average execution time (ms) */
+    avgExecutionTime: number;
+    /** Failure probability (0-1) */
+    failureProbability: number;
+    /** Priority (higher = execute earlier) */
+    priority: number;
+    /** Resource requirements */
+    readonly resources: {
+        cpu: number;
+        memory: number;
+        io: number;
+    };
+}
+/**
+ * Observation from CI/CD execution
+ */
+export interface CrystalObservation {
+    /** Observation ID */
+    readonly id: string;
+    /** Timestamp */
+    readonly timestamp: Date;
+    /** Current attractor state */
+    readonly attractor: TemporalAttractor;
+    /** Execution metrics */
+    readonly metrics: ExecutionMetrics;
+    /** Active phases */
+    readonly activePhases: string[];
+    /** Detected anomalies */
+    readonly anomalies: CrystalAnomaly[];
+    /** Predicted next phase */
+    readonly predictedNextPhase?: string;
+    /** Confidence in prediction */
+    readonly predictionConfidence: number;
+}
+/**
+ * Anomaly detected in CI/CD patterns
+ */
+export interface CrystalAnomaly {
+    /** Anomaly type */
+    readonly type: 'phase-drift' | 'cascade-failure' | 'resource-contention' | 'timeout-spike' | 'throughput-drop';
+    /** Severity (0-1) */
+    readonly severity: number;
+    /** Affected phase/node IDs */
+    readonly affected: string[];
+    /** Description */
+    readonly description: string;
+    /** Suggested action */
+    readonly suggestion: string;
+}
+/**
+ * Optimization action for the scheduler
+ */
+export type ScheduleOptimization = {
+    readonly type: 'reorder';
+    readonly newOrder: string[];
+} | {
+    readonly type: 'parallelize';
+    readonly groups: string[][];
+} | {
+    readonly type: 'delay';
+    readonly nodeId: string;
+    readonly delayMs: number;
+} | {
+    readonly type: 'skip';
+    readonly nodeId: string;
+    readonly reason: string;
+} | {
+    readonly type: 'retry';
+    readonly nodeId: string;
+    readonly maxAttempts: number;
+} | {
+    readonly type: 'no_change';
+    readonly reason: string;
+};
+/**
+ * Stabilization action to move toward stable attractor
+ */
+export type StabilizationAction = {
+    readonly type: 'reduce_parallelism';
+    readonly by: number;
+} | {
+    readonly type: 'increase_parallelism';
+    readonly by: number;
+} | {
+    readonly type: 'isolate_flaky';
+    readonly testIds: string[];
+} | {
+    readonly type: 'warm_cache';
+    readonly cacheKeys: string[];
+} | {
+    readonly type: 'clear_queue';
+    readonly reason: string;
+} | {
+    readonly type: 'throttle';
+    readonly durationMs: number;
+} | {
+    readonly type: 'no_action';
+    readonly reason: string;
+};
+/**
+ * Interface for executing test phases
+ * Allows dependency injection of test execution strategy
+ */
+export interface PhaseExecutor {
+    /**
+     * Execute tests for a given phase
+     * @param phase - The CPG test phase to execute
+     * @returns Promise resolving to phase execution result
+     */
+    execute(phase: CPGTestPhase): Promise<CPGPhaseResult>;
+    /**
+     * Check if executor is ready to run tests
+     */
+    isReady(): boolean;
+    /**
+     * Get executor name for logging
+     */
+    getName(): string;
+}
+/**
+ * Time crystal controller configuration
+ */
+export interface TimeCrystalConfig {
+    /** Enable time crystal coordination */
+    enabled: boolean;
+    /** Observation interval (ms) */
+    observationIntervalMs: number;
+    /** Phase detection window (ms) */
+    phaseDetectionWindowMs: number;
+    /** Minimum observations for pattern detection */
+    minObservationsForPattern: number;
+    /** Anomaly detection sensitivity (0-1, higher = more sensitive) */
+    anomalySensitivity: number;
+    /** Stability threshold for attractor detection */
+    stabilityThreshold: number;
+    /** Maximum parallel execution groups */
+    maxParallelGroups: number;
+    /** Prediction horizon (ms) */
+    predictionHorizonMs: number;
+    /** Enable automatic optimization */
+    autoOptimize: boolean;
+    /** Enable automatic stabilization */
+    autoStabilize: boolean;
+    /** Enable Kuramoto CPG-driven phase scheduling */
+    useCPGScheduling: boolean;
+    /** CPG configuration override (uses DEFAULT_CPG_CONFIG if not provided) */
+    cpgConfig?: Partial<CPGConfig>;
+    /** CPG test phases override (uses DEFAULT_CPG_TEST_PHASES if not provided) */
+    cpgPhases?: CPGTestPhase[];
+}
+/**
+ * Default time crystal configuration
+ */
+export declare const DEFAULT_TIME_CRYSTAL_CONFIG: TimeCrystalConfig;
+/**
+ * Time crystal event types
+ */
+export type TimeCrystalEventType = 'crystal.observation' | 'crystal.phase.activated' | 'crystal.phase.completed' | 'crystal.attractor.changed' | 'crystal.anomaly.detected' | 'crystal.optimization.applied' | 'crystal.stabilization.applied' | 'crystal.cpg.tick' | 'crystal.cpg.transition' | 'crystal.cpg.started' | 'crystal.cpg.stopped' | 'crystal.cpg.repair';
+/**
+ * Default CI/CD phase definitions for time crystal initialization
+ */
+export declare const DEFAULT_CRYSTAL_PHASES: Omit<TimeCrystalPhase, 'state' | 'successRate' | 'avgActualDuration' | 'executionCount'>[];
+//# sourceMappingURL=time-crystal-types.d.ts.map

package/dist/coordination/mincut/time-crystal-types.js

@@ -0,0 +1,67 @@
+/**
+ * Agentic QE v3 - Time Crystal Types & Interfaces
+ * ADR-047: MinCut Self-Organizing QE Integration - Phase 4
+ *
+ * All types, interfaces, and configuration constants for the Time Crystal
+ * CI/CD coordination system.
+ */
+/** Domain name for time crystal events */
+export const TIME_CRYSTAL_SOURCE = 'coordination';
+/**
+ * Default time crystal configuration
+ */
+export const DEFAULT_TIME_CRYSTAL_CONFIG = {
+    enabled: true,
+    observationIntervalMs: 30000, // 30 seconds
+    phaseDetectionWindowMs: 3600000, // 1 hour
+    minObservationsForPattern: 10,
+    anomalySensitivity: 0.7,
+    stabilityThreshold: 0.8,
+    maxParallelGroups: 8,
+    predictionHorizonMs: 600000, // 10 minutes
+    autoOptimize: true,
+    autoStabilize: true,
+    useCPGScheduling: true, // Enable CPG by default
+};
+/**
+ * Default CI/CD phase definitions for time crystal initialization
+ */
+export const DEFAULT_CRYSTAL_PHASES = [
+    {
+        id: 'unit-tests',
+        name: 'Unit Tests',
+        periodMs: 60000,
+        offsetMs: 0,
+        expectedDuration: 30000,
+        optimalParallelism: 8,
+        testTypes: ['unit'],
+    },
+    {
+        id: 'integration-tests',
+        name: 'Integration Tests',
+        periodMs: 120000,
+        offsetMs: 30000,
+        expectedDuration: 60000,
+        optimalParallelism: 4,
+        testTypes: ['integration'],
+    },
+    {
+        id: 'e2e-tests',
+        name: 'End-to-End Tests',
+        periodMs: 300000,
+        offsetMs: 90000,
+        expectedDuration: 180000,
+        optimalParallelism: 2,
+        testTypes: ['e2e', 'visual'],
+    },
+    {
+        id: 'performance-tests',
+        name: 'Performance Tests',
+        periodMs: 600000,
+        offsetMs: 270000,
+        expectedDuration: 120000,
+        optimalParallelism: 1,
+        testTypes: ['performance', 'load'],
+    },
+];
+//# sourceMappingURL=time-crystal-types.js.map