agentic-qe 3.7.21 → 3.8.0

package/dist/routing/simple-neural-router.js

@@ -0,0 +1,202 @@
+/**
+ * Simple Neural Router - Extracted from neural-tiny-dancer-router.ts
+ *
+ * Lightweight feedforward neural network for routing decisions.
+ * Uses Xavier initialization and simple policy gradient updates.
+ *
+ * Architecture:
+ *   Input(4) -> Dense(32, ReLU) -> Dense(3, Softmax) -> [p_haiku, p_sonnet, p_opus]
+ *
+ * @module routing/simple-neural-router
+ */
+// ============================================================================
+// Constants
+// ============================================================================
+/** Number of input features for the neural network */
+export const INPUT_SIZE = 4;
+/** Number of hidden units */
+export const HIDDEN_SIZE = 32;
+/** Number of output classes (tier1=haiku, tier2=sonnet, tier3=opus) */
+export const OUTPUT_SIZE = 3;
+/** Default learning rate for weight updates */
+export const DEFAULT_LEARNING_RATE = 0.01;
+// ============================================================================
+// SimpleNeuralRouter
+// ============================================================================
+/**
+ * Lightweight feedforward neural network for routing decisions.
+ * Uses Xavier initialization and simple policy gradient updates.
+ *
+ * Architecture:
+ *   Input(4) -> Dense(32, ReLU) -> Dense(3, Softmax) -> [p_haiku, p_sonnet, p_opus]
+ */
+export class SimpleNeuralRouter {
+    weightsInputHidden;
+    weightsHiddenOutput;
+    biasHidden;
+    biasOutput;
+    learningRate;
+    constructor(learningRate = DEFAULT_LEARNING_RATE) {
+        this.learningRate = learningRate;
+        this.weightsInputHidden = this.xavierInit(INPUT_SIZE, HIDDEN_SIZE);
+        this.weightsHiddenOutput = this.xavierInit(HIDDEN_SIZE, OUTPUT_SIZE);
+        this.biasHidden = new Float32Array(HIDDEN_SIZE);
+        this.biasOutput = new Float32Array(OUTPUT_SIZE);
+    }
+    /**
+     * Xavier/Glorot initialization for weight matrices
+     */
+    xavierInit(fanIn, fanOut) {
+        const scale = Math.sqrt(2.0 / (fanIn + fanOut));
+        const weights = new Float32Array(fanIn * fanOut);
+        for (let i = 0; i < weights.length; i++) {
+            // Box-Muller transform for normal distribution
+            const u1 = Math.random();
+            const u2 = Math.random();
+            const z = Math.sqrt(-2 * Math.log(Math.max(u1, 1e-10))) * Math.cos(2 * Math.PI * u2);
+            weights[i] = z * scale;
+        }
+        return weights;
+    }
+    /**
+     * Forward pass through the network
+     *
+     * @param features - Input feature vector [complexityScore, tokenEstimate, domainIndex, successRate]
+     * @returns Probability distribution over tiers [p_haiku, p_sonnet, p_opus]
+     */
+    forward(features) {
+        if (features.length !== INPUT_SIZE) {
+            throw new Error(`Expected ${INPUT_SIZE} features, got ${features.length}`);
+        }
+        // Input -> Hidden (matmul + bias + ReLU)
+        const hidden = new Float32Array(HIDDEN_SIZE);
+        for (let h = 0; h < HIDDEN_SIZE; h++) {
+            let sum = this.biasHidden[h];
+            for (let i = 0; i < INPUT_SIZE; i++) {
+                sum += features[i] * this.weightsInputHidden[i * HIDDEN_SIZE + h];
+            }
+            hidden[h] = Math.max(0, sum); // ReLU
+        }
+        // Hidden -> Output (matmul + bias)
+        const logits = new Float32Array(OUTPUT_SIZE);
+        for (let o = 0; o < OUTPUT_SIZE; o++) {
+            let sum = this.biasOutput[o];
+            for (let h = 0; h < HIDDEN_SIZE; h++) {
+                sum += hidden[h] * this.weightsHiddenOutput[h * OUTPUT_SIZE + o];
+            }
+            logits[o] = sum;
+        }
+        // Softmax
+        return this.softmax(logits);
+    }
+    /**
+     * Numerically stable softmax
+     */
+    softmax(logits) {
+        const maxLogit = Math.max(...logits);
+        const expValues = new Float32Array(logits.length);
+        let sumExp = 0;
+        for (let i = 0; i < logits.length; i++) {
+            expValues[i] = Math.exp(logits[i] - maxLogit);
+            sumExp += expValues[i];
+        }
+        const result = [];
+        for (let i = 0; i < logits.length; i++) {
+            result.push(expValues[i] / sumExp);
+        }
+        return result;
+    }
+    /**
+     * Update weights using simple policy gradient (REINFORCE)
+     *
+     * @param features - Input features used for the decision
+     * @param chosenTierIndex - Index of the tier that was chosen (0=haiku, 1=sonnet, 2=opus)
+     * @param reward - Reward signal (-1 to 1, where 1 = perfect, -1 = total failure)
+     */
+    updateWeights(features, chosenTierIndex, reward) {
+        // Forward pass to get current probabilities and hidden activations
+        const hidden = new Float32Array(HIDDEN_SIZE);
+        for (let h = 0; h < HIDDEN_SIZE; h++) {
+            let sum = this.biasHidden[h];
+            for (let i = 0; i < INPUT_SIZE; i++) {
+                sum += features[i] * this.weightsInputHidden[i * HIDDEN_SIZE + h];
+            }
+            hidden[h] = Math.max(0, sum);
+        }
+        const logits = new Float32Array(OUTPUT_SIZE);
+        for (let o = 0; o < OUTPUT_SIZE; o++) {
+            let sum = this.biasOutput[o];
+            for (let h = 0; h < HIDDEN_SIZE; h++) {
+                sum += hidden[h] * this.weightsHiddenOutput[h * OUTPUT_SIZE + o];
+            }
+            logits[o] = sum;
+        }
+        const probs = this.softmax(logits);
+        // Policy gradient: d log(pi) / d theta * reward
+        // For softmax output, gradient of log(pi_chosen) w.r.t. logits is:
+        //   (1{i=chosen} - pi_i) for each output i
+        const outputGrad = new Float32Array(OUTPUT_SIZE);
+        for (let o = 0; o < OUTPUT_SIZE; o++) {
+            outputGrad[o] = (o === chosenTierIndex ? 1 : 0) - probs[o];
+            outputGrad[o] *= reward * this.learningRate;
+        }
+        // Update output weights and biases
+        for (let h = 0; h < HIDDEN_SIZE; h++) {
+            for (let o = 0; o < OUTPUT_SIZE; o++) {
+                this.weightsHiddenOutput[h * OUTPUT_SIZE + o] += hidden[h] * outputGrad[o];
+            }
+        }
+        for (let o = 0; o < OUTPUT_SIZE; o++) {
+            this.biasOutput[o] += outputGrad[o];
+        }
+        // Backpropagate to hidden layer
+        const hiddenGrad = new Float32Array(HIDDEN_SIZE);
+        for (let h = 0; h < HIDDEN_SIZE; h++) {
+            if (hidden[h] <= 0)
+                continue; // ReLU derivative
+            let grad = 0;
+            for (let o = 0; o < OUTPUT_SIZE; o++) {
+                grad += outputGrad[o] * this.weightsHiddenOutput[h * OUTPUT_SIZE + o];
+            }
+            hiddenGrad[h] = grad;
+        }
+        // Update input weights and biases
+        for (let i = 0; i < INPUT_SIZE; i++) {
+            for (let h = 0; h < HIDDEN_SIZE; h++) {
+                this.weightsInputHidden[i * HIDDEN_SIZE + h] += features[i] * hiddenGrad[h];
+            }
+        }
+        for (let h = 0; h < HIDDEN_SIZE; h++) {
+            this.biasHidden[h] += hiddenGrad[h];
+        }
+    }
+    /**
+     * Serialize weights for persistence
+     */
+    serialize() {
+        return {
+            weightsInputHidden: Array.from(this.weightsInputHidden),
+            weightsHiddenOutput: Array.from(this.weightsHiddenOutput),
+            biasHidden: Array.from(this.biasHidden),
+            biasOutput: Array.from(this.biasOutput),
+        };
+    }
+    /**
+     * Deserialize weights from persistence
+     */
+    deserialize(data) {
+        if (data.weightsInputHidden.length === INPUT_SIZE * HIDDEN_SIZE) {
+            this.weightsInputHidden = new Float32Array(data.weightsInputHidden);
+        }
+        if (data.weightsHiddenOutput.length === HIDDEN_SIZE * OUTPUT_SIZE) {
+            this.weightsHiddenOutput = new Float32Array(data.weightsHiddenOutput);
+        }
+        if (data.biasHidden.length === HIDDEN_SIZE) {
+            this.biasHidden = new Float32Array(data.biasHidden);
+        }
+        if (data.biasOutput.length === OUTPUT_SIZE) {
+            this.biasOutput = new Float32Array(data.biasOutput);
+        }
+    }
+}
+//# sourceMappingURL=simple-neural-router.js.map

package/dist/routing/tiny-dancer-router.d.ts

@@ -178,10 +178,29 @@ export declare class TinyDancerRouter {
     getConfig(): TinyDancerConfig;
 }
 /**
- * Create a new TinyDancer router instance
+ * Create a new TinyDancer router instance (rule-based)
  *
  * @param config - Router configuration
  * @returns Configured TinyDancer router
  */
 export declare function createTinyDancerRouter(config?: TinyDancerConfig): TinyDancerRouter;
+/**
+ * Create a TinyDancer router, selecting rule-based or neural based on feature flag.
+ *
+ * When `useNeuralRouting` is enabled in RuVector feature flags, returns a
+ * NeuralTinyDancerRouter that wraps the rule-based router with a neural network.
+ * Otherwise returns the standard rule-based TinyDancerRouter.
+ *
+ * Both implement the same `route()` interface returning `RouteResult`.
+ *
+ * @param config - Router configuration
+ * @returns Either a TinyDancerRouter or NeuralTinyDancerRouter
+ */
+/** Shared router interface for both rule-based and neural routers */
+export interface ITaskRouter {
+    route(task: QETask | ClassifiableTask): Promise<RouteResult>;
+    recordOutcome?(...args: unknown[]): void;
+    reset?(): void;
+}
+export declare function createSmartTinyDancerRouter(config?: TinyDancerConfig): ITaskRouter;
 //# sourceMappingURL=tiny-dancer-router.d.ts.map

package/dist/routing/tiny-dancer-router.js

@@ -330,10 +330,10 @@ export class TinyDancerRouter {
     }
 }
 // ============================================================================
-// Factory Function
+// Factory Functions
 // ============================================================================
 /**
- * Create a new TinyDancer router instance
+ * Create a new TinyDancer router instance (rule-based)
  *
  * @param config - Router configuration
  * @returns Configured TinyDancer router
@@ -341,4 +341,23 @@ export class TinyDancerRouter {
 export function createTinyDancerRouter(config) {
     return new TinyDancerRouter(config);
 }
+export function createSmartTinyDancerRouter(config) {
+    try {
+        // Dynamically check feature flag to avoid circular imports
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { getRuVectorFeatureFlags } = require('../integrations/ruvector/feature-flags.js');
+        const flags = getRuVectorFeatureFlags();
+        if (flags.useNeuralRouting) {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const { NeuralTinyDancerRouter } = require('./neural-tiny-dancer-router.js');
+            return new NeuralTinyDancerRouter(config);
+        }
+    }
+    catch (err) {
+        // Feature flags or neural router not available - use rule-based
+        if (process.env.DEBUG)
+            console.debug('[Router] Neural router unavailable, using rule-based:', err instanceof Error ? err.message : err);
+    }
+    return new TinyDancerRouter(config);
+}
 //# sourceMappingURL=tiny-dancer-router.js.map

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

@@ -0,0 +1,81 @@
+/**
+ * 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
+ */
+import type { TestNode, TestDAG, ScheduledExecution, SchedulerStats } from './dag-attention-types.js';
+export type { TestNode, TestDAG, SchedulePhase, ScheduledExecution, SchedulerStats, } from './dag-attention-types.js';
+/**
+ * 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 declare class DAGAttentionScheduler {
+    private executionHistory;
+    private learnedDurations;
+    private runCount;
+    private lastPrunedCount;
+    private readonly learningRate;
+    private readonly maxHistorySize;
+    constructor(options?: {
+        learningRate?: number;
+        maxHistorySize?: number;
+    });
+    /**
+     * 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: TestNode[]): TestDAG;
+    /** Find the critical path (longest duration chain) through the DAG. */
+    findCriticalPath(dag: TestDAG): TestNode[];
+    /** Find groups of tests that can execute concurrently. */
+    findParallelBranches(dag: TestDAG): TestNode[][];
+    /**
+     * 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: TestDAG, budget: number): TestDAG;
+    /** Produce a complete execution schedule for the given tests. */
+    schedule(tests: TestNode[]): ScheduledExecution;
+    /** Return optimization statistics. */
+    getOptimizationStats(): SchedulerStats;
+    /** Record actual execution results for self-learning via EMA. */
+    recordExecution(testId: string, actualDuration: number, result: 'pass' | 'fail' | 'skip'): void;
+    /** Get learned duration for a test, or undefined if no history. */
+    getLearnedDuration(testId: string): number | undefined;
+    /** Check whether the native ruvector-dag-wasm backend is available. */
+    isNativeBackendAvailable(): boolean;
+    private computeCriticalPath;
+    private computeCriticalPathDuration;
+    private computeParallelGroups;
+    private computeAttentionScores;
+    private countTransitiveDependents;
+    private topologicalSort;
+    private applyLearnedDuration;
+    private sumDurations;
+}
+/** Create a DAGAttentionScheduler with optional configuration. */
+export declare function createDAGAttentionScheduler(options?: {
+    learningRate?: number;
+    maxHistorySize?: number;
+}): DAGAttentionScheduler;
+//# sourceMappingURL=dag-attention-scheduler.d.ts.map