agentic-qe 3.7.21 → 3.8.0

package/dist/test-scheduling/dag-attention-scheduler.js

@@ -0,0 +1,358 @@
+/**
+ * DAG Attention Scheduler for Intelligent Test Execution Ordering
+ * RuVector Integration Plan - Phase 4, Task 4.2
+ *
+ * Uses DAG-based attention mechanisms to intelligently order test execution:
+ * - Critical Path Attention: Identifies the longest chain in the test dependency DAG
+ * - Parallel Branch Attention: Finds sets of tests that can run concurrently
+ * - MinCut-Gated Attention: Prunes low-value tests to speed up execution
+ *
+ * Self-learning: tracks execution times and improves ordering over runs.
+ * TypeScript implementation (no native package exists for DAG attention).
+ *
+ * @module test-scheduling/dag-attention-scheduler
+ */
+// ============================================================================
+// Native WASM Backend Status
+// No native package exists for DAG attention — the TypeScript
+// implementation IS the production implementation.
+// ============================================================================
+const _nativeAvailable = false;
+// ============================================================================
+// DAGAttentionScheduler
+// ============================================================================
+/**
+ * DAG-based test scheduler using attention mechanisms for intelligent ordering.
+ *
+ * Three attention types control scheduling:
+ * 1. Critical Path Attention - finds the longest dependency chain
+ * 2. Parallel Branch Attention - finds independent test groups
+ * 3. MinCut-Gated Attention - prunes low-value tests under a time budget
+ *
+ * Self-learning: records actual execution times and adjusts estimated
+ * durations over successive runs via exponential moving average.
+ */
+export class DAGAttentionScheduler {
+    executionHistory = [];
+    learnedDurations = new Map();
+    runCount = 0;
+    lastPrunedCount = 0;
+    learningRate;
+    maxHistorySize;
+    constructor(options) {
+        this.learningRate = options?.learningRate ?? 0.3;
+        this.maxHistorySize = options?.maxHistorySize ?? 10_000;
+    }
+    // --------------------------------------------------------------------------
+    // Public API
+    // --------------------------------------------------------------------------
+    /**
+     * Build the internal TestDAG from an array of test nodes.
+     * Validates dependencies, computes forward edges, critical path,
+     * and parallel groups.
+     * @throws Error if a dependency references a non-existent test ID
+     */
+    buildTestDAG(tests) {
+        const nodes = new Map();
+        const edges = new Map();
+        for (const test of tests) {
+            const adjusted = this.applyLearnedDuration(test);
+            nodes.set(adjusted.id, adjusted);
+            edges.set(adjusted.id, []);
+        }
+        for (const test of tests) {
+            for (const depId of test.dependencies) {
+                if (!nodes.has(depId)) {
+                    throw new Error(`Test '${test.id}' depends on '${depId}' which does not exist in the test set`);
+                }
+                edges.get(depId).push(test.id);
+            }
+        }
+        const criticalPath = this.computeCriticalPath(nodes, edges);
+        const parallelGroups = this.computeParallelGroups(nodes, edges);
+        return { nodes, edges, criticalPath, parallelGroups };
+    }
+    /** Find the critical path (longest duration chain) through the DAG. */
+    findCriticalPath(dag) {
+        return dag.criticalPath
+            .map((id) => dag.nodes.get(id))
+            .filter((n) => n !== undefined);
+    }
+    /** Find groups of tests that can execute concurrently. */
+    findParallelBranches(dag) {
+        return dag.parallelGroups.map((group) => group
+            .map((id) => dag.nodes.get(id))
+            .filter((n) => n !== undefined));
+    }
+    /**
+     * Prune low-value tests from the DAG to fit within a time budget.
+     * Tests are scored by attention weight (priority * failure weight *
+     * downstream impact). Lowest-scored tests are removed first, unless
+     * they are on the critical path or have active dependents.
+     */
+    pruneByMinCut(dag, budget) {
+        const totalDuration = this.sumDurations(dag.nodes);
+        if (totalDuration <= budget) {
+            this.lastPrunedCount = 0;
+            return dag;
+        }
+        const scores = this.computeAttentionScores(dag);
+        const sortedTests = Array.from(scores.entries()).sort((a, b) => a[1] - b[1]);
+        const criticalSet = new Set(dag.criticalPath);
+        const prunedIds = new Set();
+        let currentDuration = totalDuration;
+        for (const [testId] of sortedTests) {
+            if (currentDuration <= budget)
+                break;
+            if (criticalSet.has(testId))
+                continue;
+            const dependents = dag.edges.get(testId) ?? [];
+            if (dependents.some((depId) => !prunedIds.has(depId)))
+                continue;
+            const node = dag.nodes.get(testId);
+            if (!node)
+                continue;
+            prunedIds.add(testId);
+            currentDuration -= node.estimatedDuration;
+        }
+        this.lastPrunedCount = prunedIds.size;
+        const remaining = Array.from(dag.nodes.values()).filter((n) => !prunedIds.has(n.id));
+        return this.buildTestDAG(remaining);
+    }
+    /** Produce a complete execution schedule for the given tests. */
+    schedule(tests) {
+        if (tests.length === 0) {
+            return { phases: [], totalEstimatedTime: 0, criticalPathTime: 0, parallelism: 0 };
+        }
+        const dag = this.buildTestDAG(tests);
+        const parallelBranches = this.findParallelBranches(dag);
+        const phases = parallelBranches.map((group) => ({
+            tests: group,
+            canRunInParallel: group.length > 1,
+        }));
+        const criticalPathTime = this.computeCriticalPathDuration(dag);
+        const totalWork = this.sumDurations(dag.nodes);
+        const wallClockEstimate = phases.reduce((total, phase) => {
+            if (phase.canRunInParallel) {
+                return total + Math.max(...phase.tests.map((t) => t.estimatedDuration));
+            }
+            return total + phase.tests.reduce((s, t) => s + t.estimatedDuration, 0);
+        }, 0);
+        const parallelism = wallClockEstimate > 0 ? totalWork / wallClockEstimate : 1;
+        this.runCount++;
+        return { phases, totalEstimatedTime: wallClockEstimate, criticalPathTime, parallelism };
+    }
+    /** Return optimization statistics. */
+    getOptimizationStats() {
+        return {
+            totalTests: 0,
+            criticalPathLength: 0,
+            parallelGroupCount: 0,
+            prunedTests: this.lastPrunedCount,
+            estimatedTimeSaved: 0,
+            historicalRuns: this.runCount,
+            usingNativeBackend: _nativeAvailable,
+        };
+    }
+    /** Record actual execution results for self-learning via EMA. */
+    recordExecution(testId, actualDuration, result) {
+        this.executionHistory.push({ testId, actualDuration, result, timestamp: Date.now() });
+        if (this.executionHistory.length > this.maxHistorySize) {
+            this.executionHistory = this.executionHistory.slice(-this.maxHistorySize);
+        }
+        const current = this.learnedDurations.get(testId);
+        if (current !== undefined) {
+            this.learnedDurations.set(testId, current * (1 - this.learningRate) + actualDuration * this.learningRate);
+        }
+        else {
+            this.learnedDurations.set(testId, actualDuration);
+        }
+    }
+    /** Get learned duration for a test, or undefined if no history. */
+    getLearnedDuration(testId) {
+        return this.learnedDurations.get(testId);
+    }
+    /** Check whether the native ruvector-dag-wasm backend is available. */
+    isNativeBackendAvailable() {
+        return _nativeAvailable;
+    }
+    // --------------------------------------------------------------------------
+    // Internal: Critical Path (longest-path DP on topological order)
+    // --------------------------------------------------------------------------
+    computeCriticalPath(nodes, edges) {
+        const sorted = this.topologicalSort(nodes, edges);
+        if (sorted.length === 0)
+            return [];
+        const dist = new Map();
+        const pred = new Map();
+        for (const id of sorted) {
+            dist.set(id, nodes.get(id).estimatedDuration);
+            pred.set(id, null);
+        }
+        for (const id of sorted) {
+            const currentDist = dist.get(id);
+            for (const depId of edges.get(id) ?? []) {
+                const depNode = nodes.get(depId);
+                if (!depNode)
+                    continue;
+                const newDist = currentDist + depNode.estimatedDuration;
+                if (newDist > (dist.get(depId) ?? 0)) {
+                    dist.set(depId, newDist);
+                    pred.set(depId, id);
+                }
+            }
+        }
+        let maxDist = 0;
+        let endNode = null;
+        for (const [id, d] of dist) {
+            if (d > maxDist) {
+                maxDist = d;
+                endNode = id;
+            }
+        }
+        if (!endNode)
+            return [];
+        const path = [];
+        let cur = endNode;
+        while (cur !== null) {
+            path.unshift(cur);
+            cur = pred.get(cur) ?? null;
+        }
+        return path;
+    }
+    computeCriticalPathDuration(dag) {
+        return dag.criticalPath.reduce((total, id) => total + (dag.nodes.get(id)?.estimatedDuration ?? 0), 0);
+    }
+    // --------------------------------------------------------------------------
+    // Internal: Parallel Groups (topological levels)
+    // --------------------------------------------------------------------------
+    computeParallelGroups(nodes, edges) {
+        const sorted = this.topologicalSort(nodes, edges);
+        if (sorted.length === 0)
+            return [];
+        const depSets = new Map();
+        for (const [id, node] of nodes) {
+            depSets.set(id, new Set(node.dependencies));
+        }
+        const level = new Map();
+        for (const id of sorted) {
+            let maxDepLevel = -1;
+            for (const depId of depSets.get(id) ?? new Set()) {
+                const depLevel = level.get(depId);
+                if (depLevel !== undefined && depLevel > maxDepLevel)
+                    maxDepLevel = depLevel;
+            }
+            level.set(id, maxDepLevel + 1);
+        }
+        const groups = new Map();
+        for (const id of sorted) {
+            const lvl = level.get(id) ?? 0;
+            if (!groups.has(lvl))
+                groups.set(lvl, []);
+            groups.get(lvl).push(id);
+        }
+        const maxLevel = Math.max(...Array.from(groups.keys()), -1);
+        const result = [];
+        for (let i = 0; i <= maxLevel; i++) {
+            const group = groups.get(i);
+            if (group && group.length > 0)
+                result.push(group);
+        }
+        return result;
+    }
+    // --------------------------------------------------------------------------
+    // Internal: Attention Scores for MinCut Pruning
+    // --------------------------------------------------------------------------
+    computeAttentionScores(dag) {
+        const scores = new Map();
+        const transitiveCounts = this.countTransitiveDependents(dag);
+        for (const [id, node] of dag.nodes) {
+            const failureWeight = node.lastResult === 'fail' ? 2.0 : 1.0;
+            const downstream = transitiveCounts.get(id) ?? 0;
+            scores.set(id, node.priority * failureWeight * (1 + downstream));
+        }
+        return scores;
+    }
+    countTransitiveDependents(dag) {
+        const counts = new Map();
+        const visited = new Map();
+        const getTransitive = (id) => {
+            if (visited.has(id))
+                return visited.get(id);
+            const result = new Set();
+            for (const depId of dag.edges.get(id) ?? []) {
+                result.add(depId);
+                for (const transId of getTransitive(depId))
+                    result.add(transId);
+            }
+            visited.set(id, result);
+            return result;
+        };
+        for (const id of dag.nodes.keys()) {
+            counts.set(id, getTransitive(id).size);
+        }
+        return counts;
+    }
+    // --------------------------------------------------------------------------
+    // Internal: Topological Sort (Kahn's Algorithm)
+    // --------------------------------------------------------------------------
+    topologicalSort(nodes, edges) {
+        const inDegree = new Map();
+        for (const id of nodes.keys())
+            inDegree.set(id, 0);
+        for (const children of edges.values()) {
+            for (const childId of children) {
+                if (inDegree.has(childId)) {
+                    inDegree.set(childId, (inDegree.get(childId) ?? 0) + 1);
+                }
+            }
+        }
+        const queue = [];
+        for (const [id, deg] of inDegree) {
+            if (deg === 0)
+                queue.push(id);
+        }
+        const sorted = [];
+        while (queue.length > 0) {
+            const nodeId = queue.shift();
+            sorted.push(nodeId);
+            for (const childId of edges.get(nodeId) ?? []) {
+                const newDeg = (inDegree.get(childId) ?? 0) - 1;
+                inDegree.set(childId, newDeg);
+                if (newDeg === 0)
+                    queue.push(childId);
+            }
+        }
+        if (sorted.length !== nodes.size) {
+            throw new Error(`Cycle detected in test DAG: sorted ${sorted.length} of ${nodes.size} nodes`);
+        }
+        return sorted;
+    }
+    // --------------------------------------------------------------------------
+    // Internal: Self-Learning
+    // --------------------------------------------------------------------------
+    applyLearnedDuration(test) {
+        const learned = this.learnedDurations.get(test.id);
+        if (learned !== undefined) {
+            return { ...test, estimatedDuration: Math.round(learned) };
+        }
+        return test;
+    }
+    // --------------------------------------------------------------------------
+    // Internal: Utilities
+    // --------------------------------------------------------------------------
+    sumDurations(nodes) {
+        let total = 0;
+        for (const node of nodes.values())
+            total += node.estimatedDuration;
+        return total;
+    }
+}
+// ============================================================================
+// Factory Function
+// ============================================================================
+/** Create a DAGAttentionScheduler with optional configuration. */
+export function createDAGAttentionScheduler(options) {
+    return new DAGAttentionScheduler(options);
+}
+//# sourceMappingURL=dag-attention-scheduler.js.map

package/dist/test-scheduling/dag-attention-types.d.ts

@@ -0,0 +1,81 @@
+/**
+ * DAG Attention Scheduler Types
+ * RuVector Integration Plan - Phase 4, Task 4.2
+ *
+ * Type definitions for DAG-based test execution ordering.
+ *
+ * @module test-scheduling/dag-attention-types
+ */
+/** A test node in the dependency graph */
+export interface TestNode {
+    /** Unique identifier */
+    id: string;
+    /** Human-readable test name */
+    name: string;
+    /** Estimated duration in milliseconds */
+    estimatedDuration: number;
+    /** IDs of tests that must complete before this test can start */
+    dependencies: string[];
+    /** Numeric priority (higher = more important) */
+    priority: number;
+    /** Tags for categorization (e.g., 'unit', 'integration') */
+    tags: string[];
+    /** Last recorded execution time in ms */
+    lastExecutionTime?: number;
+    /** Last test result */
+    lastResult?: 'pass' | 'fail' | 'skip';
+}
+/** Internal DAG representation built from TestNode[] */
+export interface TestDAG {
+    /** All nodes indexed by ID */
+    nodes: Map<string, TestNode>;
+    /** Forward edges: node -> its direct dependents */
+    edges: Map<string, string[]>;
+    /** IDs on the critical path, in execution order */
+    criticalPath: string[];
+    /** Groups of test IDs that can run in parallel */
+    parallelGroups: string[][];
+}
+/** A single phase in the scheduled execution */
+export interface SchedulePhase {
+    /** Tests assigned to this phase */
+    tests: TestNode[];
+    /** Whether the tests in this phase can run concurrently */
+    canRunInParallel: boolean;
+}
+/** Full scheduled execution plan */
+export interface ScheduledExecution {
+    /** Ordered phases of execution */
+    phases: SchedulePhase[];
+    /** Total estimated wall-clock time in ms */
+    totalEstimatedTime: number;
+    /** Sum of durations along the critical path in ms */
+    criticalPathTime: number;
+    /** Effective parallelism factor (total work / wall-clock) */
+    parallelism: number;
+}
+/** Statistics about scheduler optimizations */
+export interface SchedulerStats {
+    /** Total number of tests in the DAG */
+    totalTests: number;
+    /** Number of tests on the critical path */
+    criticalPathLength: number;
+    /** Number of parallel groups discovered */
+    parallelGroupCount: number;
+    /** Number of tests pruned by MinCut */
+    prunedTests: number;
+    /** Estimated time saved via parallelism (ms) */
+    estimatedTimeSaved: number;
+    /** Number of completed scheduling runs tracked */
+    historicalRuns: number;
+    /** Whether the native WASM backend is in use */
+    usingNativeBackend: boolean;
+}
+/** Historical record for self-learning */
+export interface ExecutionRecord {
+    testId: string;
+    actualDuration: number;
+    result: 'pass' | 'fail' | 'skip';
+    timestamp: number;
+}
+//# sourceMappingURL=dag-attention-types.d.ts.map

package/dist/test-scheduling/dag-attention-types.js

@@ -0,0 +1,10 @@
+/**
+ * DAG Attention Scheduler Types
+ * RuVector Integration Plan - Phase 4, Task 4.2
+ *
+ * Type definitions for DAG-based test execution ordering.
+ *
+ * @module test-scheduling/dag-attention-types
+ */
+export {};
+//# sourceMappingURL=dag-attention-types.js.map

package/dist/test-scheduling/index.d.ts

@@ -72,4 +72,5 @@ export { GitAwareTestSelector, createTestSelector, getAffectedTests, type TestSe
 export { FlakyTestTracker, createFlakyTracker, loadFlakyTracker, saveFlakyTracker, type FlakyTrackerConfig, type FlakyAnalysis, } from './flaky-tracking/flaky-tracker';
 export { GitHubActionsReporter, createGitHubActionsReporter, reportToGitHubActions, detectCIEnvironment, type GitHubActionsConfig, } from './cicd/github-actions';
 export { TestSchedulingPipeline, createTestPipeline, runTestPipeline, type PipelineConfig, type PipelineResult, } from './pipeline';
+export { DAGAttentionScheduler, createDAGAttentionScheduler, type TestNode, type TestDAG, type SchedulePhase, type ScheduledExecution, type SchedulerStats as DAGSchedulerStats, } from './dag-attention-scheduler';
 //# sourceMappingURL=index.d.ts.map

package/dist/test-scheduling/index.js

@@ -89,4 +89,8 @@ export { GitHubActionsReporter, createGitHubActionsReporter, reportToGitHubActio
 // Integration Pipeline
 // ============================================================================
 export { TestSchedulingPipeline, createTestPipeline, runTestPipeline, } from './pipeline';
+// ============================================================================
+// DAG Attention Scheduler (Phase 4, Task 4.2)
+// ============================================================================
+export { DAGAttentionScheduler, createDAGAttentionScheduler, } from './dag-attention-scheduler';
 //# sourceMappingURL=index.js.map

package/dist/test-scheduling/pipeline.d.ts

@@ -55,6 +55,14 @@ export interface PipelineConfig {
     flakyTracker?: Partial<FlakyTrackerConfig>;
     /** Run all tests (skip git-aware selection) */
     runAllTests?: boolean;
+    /**
+     * Enable DAG attention scheduling for dependency-aware test ordering.
+     * When enabled and test dependencies are available, uses DAGAttentionScheduler
+     * to optimize execution order via critical path and parallel branch detection.
+     * Requires feature flag useDAGAttention to also be on.
+     * @default false
+     */
+    useDAGAttention?: boolean;
 }
 export interface PipelineResult {
     /** Test phase results */

package/dist/test-scheduling/pipeline.js

@@ -123,6 +123,34 @@ export class TestSchedulingPipeline {
             }
         }
         const selectionMs = performance.now() - selectionStart;
+        // Step 1b: DAG attention-based ordering (when enabled and tests selected)
+        if (this.config.useDAGAttention && selectedTests.length > 0) {
+            try {
+                const { isDAGAttentionEnabled } = await import('../integrations/ruvector/feature-flags.js');
+                if (isDAGAttentionEnabled()) {
+                    const { createDAGAttentionScheduler } = await import('./dag-attention-scheduler.js');
+                    const dagScheduler = createDAGAttentionScheduler();
+                    const nodes = selectedTests.map(t => ({
+                        id: t, name: t, estimatedDuration: 1000,
+                        dependencies: [], priority: 1, tags: [],
+                    }));
+                    const schedule = dagScheduler.schedule(nodes);
+                    // Flatten scheduled phases into ordered test list
+                    const orderedTests = [];
+                    for (const phase of schedule.phases) {
+                        orderedTests.push(...phase.tests.map(t => t.id));
+                    }
+                    if (orderedTests.length > 0) {
+                        selectedTests = orderedTests;
+                    }
+                }
+            }
+            catch (err) {
+                // DAG scheduling is best-effort; fall through to default ordering
+                if (process.env.DEBUG)
+                    console.debug('[Pipeline] DAG attention scheduling skipped:', err instanceof Error ? err.message : err);
+            }
+        }
         // Step 2: Execute tests
         const executionStart = performance.now();
         let phaseResults;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-qe",
-  "version": "3.7.21",
+  "version": "3.8.0",
   "description": "Agentic Quality Engineering V3 - Domain-Driven Design Architecture with 13 Bounded Contexts, O(log n) coverage analysis, ReasoningBank learning, 60 specialized QE agents, mathematical Coherence verification, deep Claude Flow integration",
   "type": "module",
   "main": "./dist/index.js",
@@ -131,6 +131,8 @@
     "@faker-js/faker": "^10.2.0",
     "@ruvector/attention": "0.1.3",
     "@ruvector/gnn": "0.1.19",
+    "@ruvector/learning-wasm": "^0.1.29",
+    "@ruvector/router": "^0.1.28",
     "@ruvector/rvf-node": "^0.1.7",
     "@ruvector/sona": "0.1.5",
     "@xenova/transformers": "^2.17.2",
@@ -164,7 +166,9 @@
     "@ruvector/gnn-linux-arm64-gnu": "0.1.19",
     "@ruvector/gnn-linux-arm64-musl": "npm:@ruvector/gnn-linux-arm64-gnu@0.1.19",
     "@ruvector/gnn-linux-x64-gnu": "0.1.19",
-    "@ruvector/gnn-linux-x64-musl": "npm:@ruvector/gnn-linux-x64-gnu@0.1.19"
+    "@ruvector/gnn-linux-x64-musl": "npm:@ruvector/gnn-linux-x64-gnu@0.1.19",
+    "@ruvector/tiny-dancer-linux-arm64-gnu": "^0.1.17",
+    "rvlite": "^0.2.4"
   },
   "resolutions": {
     "graceful-fs": "^4.2.11",

package/dist/cli/commands/migrate.d.ts

@@ -1,9 +0,0 @@
-/**
- * Agentic QE v3 - Migrate Command
- *
- * V2-to-V3 migration tools with agent compatibility (ADR-048).
- */
-import { Command } from 'commander';
-import type { CLIContext } from '../handlers/interfaces.js';
-export declare function createMigrateCommand(context: CLIContext, cleanupAndExit: (code: number) => Promise<never>, ensureInitialized: () => Promise<boolean>): Command;
-//# sourceMappingURL=migrate.d.ts.map