kynjal-cli 3.1.3 → 4.0.0

package/dist/src/ruvector/q-learning-router.js

@@ -13,12 +13,59 @@
  *
  * @module q-learning-router
  */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { dirname } from 'path';
 /**
  * Default configuration
  */
-const DEFAULT_CONFIG = {
+var DEFAULT_CONFIG = {
     learningRate: 0.1,
     gamma: 0.99,
     explorationInitial: 1.0,
@@ -34,12 +81,12 @@ const DEFAULT_CONFIG = {
     cacheTTL: 300000,
     modelPath: '.swarm/q-learning-model.json',
     autoSaveInterval: 100,
-    stateSpaceDim: 64,
+    stateSpaceDim: 64
 };
 /**
  * Route names mapping
  */
-const ROUTE_NAMES = [
+var ROUTE_NAMES = [
     'coder',
     'tester',
     'reviewer',
@@ -52,7 +99,7 @@ const ROUTE_NAMES = [
 /**
  * Task feature keywords for state representation
  */
-const FEATURE_KEYWORDS = [
+var FEATURE_KEYWORDS = [
     // Code-related
     'implement', 'code', 'write', 'create', 'build', 'develop',
     // Testing-related
@@ -80,126 +127,155 @@ const FEATURE_KEYWORDS = [
  * - Prioritized experience replay
  * - Model persistence
  */
-export class QLearningRouter {
-    config;
-    qTable = new Map();
-    epsilon;
-    stepCount = 0;
-    updateCount = 0;
-    avgTDError = 0;
-    ruvectorEngine = null;
-    useNative = false;
-    // Experience replay buffer (circular buffer)
-    replayBuffer = [];
-    replayBufferIdx = 0;
-    totalExperiences = 0;
-    // LRU cache for route decisions
-    routeCache = new Map();
-    cacheOrder = [];
-    cacheHits = 0;
-    cacheMisses = 0;
-    // Feature hash cache for state representation
-    featureHashCache = new Map();
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
+var QLearningRouter = /** @class */ (function () {
+    function QLearningRouter(config) {
+        if (config === void 0) { config = {}; }
+        this.qTable = new Map();
+        this.stepCount = 0;
+        this.updateCount = 0;
+        this.avgTDError = 0;
+        this.ruvectorEngine = null;
+        this.useNative = false;
+        // Experience replay buffer (circular buffer)
+        this.replayBuffer = [];
+        this.replayBufferIdx = 0;
+        this.totalExperiences = 0;
+        // LRU cache for route decisions
+        this.routeCache = new Map();
+        this.cacheOrder = [];
+        this.cacheHits = 0;
+        this.cacheMisses = 0;
+        // Feature hash cache for state representation
+        this.featureHashCache = new Map();
+        this.config = __assign(__assign({}, DEFAULT_CONFIG), config);
         this.epsilon = this.config.explorationInitial;
     }
     /**
      * Initialize the router, attempting to load ruvector native module
      * and restore persisted model if available
      */
-    async initialize() {
-        try {
-            const ruvector = await import('@ruvector/core');
-            this.ruvectorEngine = ruvector.createQLearning?.(this.config);
-            this.useNative = !!this.ruvectorEngine;
-        }
-        catch {
-            // Fallback to JS implementation
-            this.useNative = false;
-        }
-        // Try to load persisted model
-        await this.loadModel();
-    }
+    QLearningRouter.prototype.initialize = function () {
+        var _a, _b;
+        return __awaiter(this, void 0, Promise, function () {
+            var ruvector, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _d.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, import('@ruvector/core')];
+                    case 1:
+                        ruvector = _d.sent();
+                        this.ruvectorEngine = (_b = (_a = ruvector).createQLearning) === null || _b === void 0 ? void 0 : _b.call(_a, this.config);
+                        this.useNative = !!this.ruvectorEngine;
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _c = _d.sent();
+                        // Fallback to JS implementation
+                        this.useNative = false;
+                        return [3 /*break*/, 3];
+                    case 3: 
+                    // Try to load persisted model
+                    return [4 /*yield*/, this.loadModel()];
+                    case 4:
+                        // Try to load persisted model
+                        _d.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Load model from persistence file
      */
-    async loadModel(path) {
-        const modelPath = path || this.config.modelPath;
-        try {
-            if (!existsSync(modelPath)) {
-                return false;
-            }
-            const data = readFileSync(modelPath, 'utf-8');
-            const model = JSON.parse(data);
-            // Validate version compatibility
-            if (!model.version || !model.version.startsWith('1.')) {
-                console.warn(`[Q-Learning] Incompatible model version: ${model.version}`);
-                return false;
-            }
-            // Import Q-table
-            this.import(model.qTable);
-            // Restore stats
-            this.stepCount = model.stats.stepCount || 0;
-            this.updateCount = model.stats.updateCount || 0;
-            this.avgTDError = model.stats.avgTDError || 0;
-            this.epsilon = model.stats.epsilon || this.config.explorationInitial;
-            this.totalExperiences = model.metadata?.totalExperiences || 0;
-            return true;
-        }
-        catch (err) {
-            console.warn(`[Q-Learning] Failed to load model: ${err}`);
-            return false;
-        }
-    }
+    QLearningRouter.prototype.loadModel = function (path) {
+        var _a;
+        return __awaiter(this, void 0, Promise, function () {
+            var modelPath, data, model;
+            return __generator(this, function (_b) {
+                modelPath = path || this.config.modelPath;
+                try {
+                    if (!existsSync(modelPath)) {
+                        return [2 /*return*/, false];
+                    }
+                    data = readFileSync(modelPath, 'utf-8');
+                    model = JSON.parse(data);
+                    // Validate version compatibility
+                    if (!model.version || !model.version.startsWith('1.')) {
+                        console.warn("[Q-Learning] Incompatible model version: " + model.version);
+                        return [2 /*return*/, false];
+                    }
+                    // Import Q-table
+                    this["import"](model.qTable);
+                    // Restore stats
+                    this.stepCount = model.stats.stepCount || 0;
+                    this.updateCount = model.stats.updateCount || 0;
+                    this.avgTDError = model.stats.avgTDError || 0;
+                    this.epsilon = model.stats.epsilon || this.config.explorationInitial;
+                    this.totalExperiences = ((_a = model.metadata) === null || _a === void 0 ? void 0 : _a.totalExperiences) || 0;
+                    return [2 /*return*/, true];
+                }
+                catch (err) {
+                    console.warn("[Q-Learning] Failed to load model: " + err);
+                    return [2 /*return*/, false];
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
     /**
      * Save model to persistence file
      */
-    async saveModel(path) {
-        const modelPath = path || this.config.modelPath;
-        try {
-            // Ensure directory exists
-            const dir = dirname(modelPath);
-            if (!existsSync(dir)) {
-                mkdirSync(dir, { recursive: true });
-            }
-            const model = {
-                version: '1.0.0',
-                config: {
-                    learningRate: this.config.learningRate,
-                    gamma: this.config.gamma,
-                    explorationDecayType: this.config.explorationDecayType,
-                    numActions: this.config.numActions,
-                },
-                qTable: this.export(),
-                stats: {
-                    stepCount: this.stepCount,
-                    updateCount: this.updateCount,
-                    avgTDError: this.avgTDError,
-                    epsilon: this.epsilon,
-                },
-                metadata: {
-                    savedAt: new Date().toISOString(),
-                    totalExperiences: this.totalExperiences,
-                },
-            };
-            writeFileSync(modelPath, JSON.stringify(model, null, 2));
-            return true;
-        }
-        catch (err) {
-            console.warn(`[Q-Learning] Failed to save model: ${err}`);
-            return false;
-        }
-    }
+    QLearningRouter.prototype.saveModel = function (path) {
+        return __awaiter(this, void 0, Promise, function () {
+            var modelPath, dir, model;
+            return __generator(this, function (_a) {
+                modelPath = path || this.config.modelPath;
+                try {
+                    dir = dirname(modelPath);
+                    if (!existsSync(dir)) {
+                        mkdirSync(dir, { recursive: true });
+                    }
+                    model = {
+                        version: '1.0.0',
+                        config: {
+                            learningRate: this.config.learningRate,
+                            gamma: this.config.gamma,
+                            explorationDecayType: this.config.explorationDecayType,
+                            numActions: this.config.numActions
+                        },
+                        qTable: this["export"](),
+                        stats: {
+                            stepCount: this.stepCount,
+                            updateCount: this.updateCount,
+                            avgTDError: this.avgTDError,
+                            epsilon: this.epsilon
+                        },
+                        metadata: {
+                            savedAt: new Date().toISOString(),
+                            totalExperiences: this.totalExperiences
+                        }
+                    };
+                    writeFileSync(modelPath, JSON.stringify(model, null, 2));
+                    return [2 /*return*/, true];
+                }
+                catch (err) {
+                    console.warn("[Q-Learning] Failed to save model: " + err);
+                    return [2 /*return*/, false];
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
     /**
      * Route a task based on its context
      * Uses LRU cache for repeated task patterns
      */
-    route(taskContext, explore = true) {
-        const stateKey = this.hashStateOptimized(taskContext);
+    QLearningRouter.prototype.route = function (taskContext, explore) {
+        if (explore === void 0) { explore = true; }
+        var stateKey = this.hashStateOptimized(taskContext);
         // Check cache first (only for exploitation, not exploration)
         if (!explore) {
-            const cached = this.getCachedRoute(stateKey);
+            var cached = this.getCachedRoute(stateKey);
             if (cached) {
                 this.cacheHits++;
                 return cached;
@@ -207,9 +283,9 @@ export class QLearningRouter {
             this.cacheMisses++;
         }
         // Check if we should explore using decayed epsilon
-        const shouldExplore = explore && Math.random() < this.epsilon;
-        let actionIdx;
-        let qValues;
+        var shouldExplore = explore && Math.random() < this.epsilon;
+        var actionIdx;
+        var qValues;
         if (shouldExplore) {
             // Random exploration
             actionIdx = Math.floor(Math.random() * this.config.numActions);
@@ -221,95 +297,95 @@ export class QLearningRouter {
             actionIdx = this.argmax(qValues);
         }
         // Calculate confidence from softmax of Q-values
-        const confidence = this.softmaxConfidence(qValues, actionIdx);
+        var confidence = this.softmaxConfidence(qValues, actionIdx);
         // Get alternatives sorted by Q-value
-        const alternatives = ROUTE_NAMES
-            .map((route, idx) => ({ route, score: qValues[idx] }))
-            .sort((a, b) => b.score - a.score)
+        var alternatives = ROUTE_NAMES
+            .map(function (route, idx) { return ({ route: route, score: qValues[idx] }); })
+            .sort(function (a, b) { return b.score - a.score; })
             .slice(1, 4); // Top 3 alternatives
-        const decision = {
+        var decision = {
             route: ROUTE_NAMES[actionIdx] || 'coder',
-            confidence,
-            qValues,
+            confidence: confidence,
+            qValues: qValues,
             explored: shouldExplore,
-            alternatives,
+            alternatives: alternatives
         };
         // Cache the decision for exploitation queries
         if (!shouldExplore) {
             this.cacheRoute(stateKey, decision);
         }
         return decision;
-    }
+    };
     /**
      * Get cached route decision (LRU cache)
      */
-    getCachedRoute(stateKey) {
-        const entry = this.routeCache.get(stateKey);
+    QLearningRouter.prototype.getCachedRoute = function (stateKey) {
+        var entry = this.routeCache.get(stateKey);
         if (!entry) {
             return null;
         }
         // Check TTL
         if (Date.now() - entry.timestamp > this.config.cacheTTL) {
-            this.routeCache.delete(stateKey);
-            this.cacheOrder = this.cacheOrder.filter(k => k !== stateKey);
+            this.routeCache["delete"](stateKey);
+            this.cacheOrder = this.cacheOrder.filter(function (k) { return k !== stateKey; });
             return null;
         }
         // Update LRU order
-        this.cacheOrder = this.cacheOrder.filter(k => k !== stateKey);
+        this.cacheOrder = this.cacheOrder.filter(function (k) { return k !== stateKey; });
         this.cacheOrder.push(stateKey);
         entry.hits++;
         return entry.decision;
-    }
+    };
     /**
      * Cache a route decision (LRU eviction)
      */
-    cacheRoute(stateKey, decision) {
+    QLearningRouter.prototype.cacheRoute = function (stateKey, decision) {
         // Evict oldest if cache is full
         while (this.routeCache.size >= this.config.cacheSize && this.cacheOrder.length > 0) {
-            const oldest = this.cacheOrder.shift();
+            var oldest = this.cacheOrder.shift();
             if (oldest) {
-                this.routeCache.delete(oldest);
+                this.routeCache["delete"](oldest);
             }
         }
         this.routeCache.set(stateKey, {
-            decision,
+            decision: decision,
             timestamp: Date.now(),
-            hits: 0,
+            hits: 0
         });
         this.cacheOrder.push(stateKey);
-    }
+    };
     /**
      * Invalidate cache (call after significant Q-table updates)
      */
-    invalidateCache() {
+    QLearningRouter.prototype.invalidateCache = function () {
         this.routeCache.clear();
         this.cacheOrder = [];
-    }
+    };
     /**
      * Update Q-values based on feedback
      * Includes experience replay for stable learning
      */
-    update(taskContext, action, reward, nextContext) {
-        const stateKey = this.hashStateOptimized(taskContext);
-        const actionIdx = ROUTE_NAMES.indexOf(action);
+    QLearningRouter.prototype.update = function (taskContext, action, reward, nextContext) {
+        var stateKey = this.hashStateOptimized(taskContext);
+        var actionIdx = ROUTE_NAMES.indexOf(action);
         if (actionIdx === -1) {
             return 0;
         }
-        const nextStateKey = nextContext ? this.hashStateOptimized(nextContext) : null;
+        var nextStateKey = nextContext ? this.hashStateOptimized(nextContext) : null;
         // Store experience in replay buffer
         if (this.config.enableReplay) {
-            const experience = {
-                stateKey,
-                actionIdx,
-                reward,
-                nextStateKey,
+            var experience = {
+                stateKey: stateKey,
+                actionIdx: actionIdx,
+                reward: reward,
+                nextStateKey: nextStateKey,
                 timestamp: Date.now(),
-                priority: Math.abs(reward) + 0.1, // Initial priority based on reward magnitude
+                priority: Math.abs(reward) + 0.1
             };
             this.addToReplayBuffer(experience);
         }
         // Perform direct update
-        const tdError = this.updateQValue(stateKey, actionIdx, reward, nextStateKey);
+        var tdError = this.updateQValue(stateKey, actionIdx, reward, nextStateKey);
         // Perform experience replay
         if (this.config.enableReplay && this.replayBuffer.length >= this.config.replayBatchSize) {
             this.experienceReplay();
@@ -325,25 +401,25 @@ export class QLearningRouter {
         this.avgTDError = (this.avgTDError * (this.updateCount - 1) + Math.abs(tdError)) / this.updateCount;
         // Auto-save periodically
         if (this.config.autoSaveInterval > 0 && this.updateCount % this.config.autoSaveInterval === 0) {
-            this.saveModel().catch(() => { }); // Fire and forget
+            this.saveModel()["catch"](function () { }); // Fire and forget
         }
         // Invalidate cache periodically to reflect Q-table changes
         if (this.updateCount % 50 === 0) {
             this.invalidateCache();
         }
         return tdError;
-    }
+    };
     /**
      * Internal Q-value update
      */
-    updateQValue(stateKey, actionIdx, reward, nextStateKey) {
-        const entry = this.getOrCreateEntry(stateKey);
-        const currentQ = entry.qValues[actionIdx];
+    QLearningRouter.prototype.updateQValue = function (stateKey, actionIdx, reward, nextStateKey) {
+        var entry = this.getOrCreateEntry(stateKey);
+        var currentQ = entry.qValues[actionIdx];
         // Calculate target Q-value
-        let targetQ;
+        var targetQ;
         if (nextStateKey) {
-            const nextQValues = this.getQValues(nextStateKey);
-            const maxNextQ = Math.max(...nextQValues);
+            var nextQValues = this.getQValues(nextStateKey);
+            var maxNextQ = Math.max.apply(Math, nextQValues);
             targetQ = reward + this.config.gamma * maxNextQ;
         }
         else {
@@ -351,17 +427,17 @@ export class QLearningRouter {
             targetQ = reward;
         }
         // TD error
-        const tdError = targetQ - currentQ;
+        var tdError = targetQ - currentQ;
         // Update Q-value
         entry.qValues[actionIdx] += this.config.learningRate * tdError;
         entry.visits++;
         entry.lastUpdate = Date.now();
         return tdError;
-    }
+    };
     /**
      * Add experience to circular replay buffer
      */
-    addToReplayBuffer(experience) {
+    QLearningRouter.prototype.addToReplayBuffer = function (experience) {
         if (this.replayBuffer.length < this.config.replayBufferSize) {
             this.replayBuffer.push(experience);
         }
@@ -370,35 +446,36 @@ export class QLearningRouter {
         }
         this.replayBufferIdx = (this.replayBufferIdx + 1) % this.config.replayBufferSize;
         this.totalExperiences++;
-    }
+    };
     /**
      * Perform prioritized experience replay
      * Samples mini-batch from buffer and updates Q-values
      */
-    experienceReplay() {
+    QLearningRouter.prototype.experienceReplay = function () {
         if (this.replayBuffer.length < this.config.replayBatchSize) {
             return;
         }
         // Prioritized sampling based on TD error magnitude
-        const batch = this.samplePrioritizedBatch(this.config.replayBatchSize);
-        for (const exp of batch) {
-            const tdError = this.updateQValue(exp.stateKey, exp.actionIdx, exp.reward, exp.nextStateKey);
+        var batch = this.samplePrioritizedBatch(this.config.replayBatchSize);
+        for (var _i = 0, batch_1 = batch; _i < batch_1.length; _i++) {
+            var exp = batch_1[_i];
+            var tdError = this.updateQValue(exp.stateKey, exp.actionIdx, exp.reward, exp.nextStateKey);
             // Update priority for future sampling
             exp.priority = Math.abs(tdError) + 0.01; // Small constant to avoid zero priority
         }
-    }
+    };
     /**
      * Sample a prioritized batch from replay buffer
      * Uses proportional prioritization
      */
-    samplePrioritizedBatch(batchSize) {
-        const totalPriority = this.replayBuffer.reduce((sum, exp) => sum + exp.priority, 0);
-        const batch = [];
-        const selected = new Set();
+    QLearningRouter.prototype.samplePrioritizedBatch = function (batchSize) {
+        var totalPriority = this.replayBuffer.reduce(function (sum, exp) { return sum + exp.priority; }, 0);
+        var batch = [];
+        var selected = new Set();
         while (batch.length < batchSize && selected.size < this.replayBuffer.length) {
-            let threshold = Math.random() * totalPriority;
-            let cumSum = 0;
-            for (let i = 0; i < this.replayBuffer.length; i++) {
+            var threshold = Math.random() * totalPriority;
+            var cumSum = 0;
+            for (var i = 0; i < this.replayBuffer.length; i++) {
                 if (selected.has(i))
                     continue;
                 cumSum += this.replayBuffer[i].priority;
@@ -410,19 +487,19 @@ export class QLearningRouter {
             }
         }
         return batch;
-    }
+    };
     /**
      * Calculate epsilon using configured decay strategy
      */
-    calculateEpsilon() {
-        const { explorationInitial, explorationFinal, explorationDecay, explorationDecayType } = this.config;
-        const progress = Math.min(this.stepCount / explorationDecay, 1.0);
+    QLearningRouter.prototype.calculateEpsilon = function () {
+        var _a = this.config, explorationInitial = _a.explorationInitial, explorationFinal = _a.explorationFinal, explorationDecay = _a.explorationDecay, explorationDecayType = _a.explorationDecayType;
+        var progress = Math.min(this.stepCount / explorationDecay, 1.0);
         switch (explorationDecayType) {
             case 'linear':
                 return explorationFinal + (explorationInitial - explorationFinal) * (1 - progress);
             case 'exponential':
                 // Exponential decay: epsilon = final + (initial - final) * exp(-decay_rate * step)
-                const decayRate = -Math.log((explorationFinal / explorationInitial) + 1e-8) / explorationDecay;
+                var decayRate = -Math.log((explorationFinal / explorationInitial) + 1e-8) / explorationDecay;
                 return explorationFinal + (explorationInitial - explorationFinal) * Math.exp(-decayRate * this.stepCount);
             case 'cosine':
                 // Cosine annealing: smooth transition
@@ -430,12 +507,12 @@ export class QLearningRouter {
             default:
                 return Math.max(explorationFinal, explorationInitial - this.stepCount / explorationDecay);
         }
-    }
+    };
     /**
      * Get statistics including cache and replay buffer metrics
      */
-    getStats() {
-        const cacheHitRate = this.cacheHits + this.cacheMisses > 0
+    QLearningRouter.prototype.getStats = function () {
+        var cacheHitRate = this.cacheHits + this.cacheMisses > 0
             ? this.cacheHits / (this.cacheHits + this.cacheMisses)
             : 0;
         return {
@@ -449,18 +526,18 @@ export class QLearningRouter {
             cacheSize: this.routeCache.size,
             cacheHits: this.cacheHits,
             cacheMisses: this.cacheMisses,
-            cacheHitRate,
+            cacheHitRate: cacheHitRate,
             // Replay buffer metrics
             replayBufferSize: this.replayBuffer.length,
             totalExperiences: this.totalExperiences,
             // Feature hash cache
-            featureHashCacheSize: this.featureHashCache.size,
+            featureHashCacheSize: this.featureHashCache.size
         };
-    }
+    };
     /**
      * Reset the router (clears all learned data)
      */
-    reset() {
+    QLearningRouter.prototype.reset = function () {
         this.qTable.clear();
         this.epsilon = this.config.explorationInitial;
         this.stepCount = 0;
@@ -477,119 +554,121 @@ export class QLearningRouter {
         this.cacheMisses = 0;
         // Reset feature hash cache
         this.featureHashCache.clear();
-    }
+    };
     /**
      * Export Q-table for persistence
      */
-    export() {
-        const result = {};
-        for (const [key, entry] of this.qTable) {
+    QLearningRouter.prototype["export"] = function () {
+        var result = {};
+        for (var _i = 0, _a = this.qTable; _i < _a.length; _i++) {
+            var _b = _a[_i], key = _b[0], entry = _b[1];
             result[key] = {
                 qValues: Array.from(entry.qValues),
-                visits: entry.visits,
+                visits: entry.visits
             };
         }
         return result;
-    }
+    };
     /**
      * Import Q-table from persistence
      */
-    import(data) {
+    QLearningRouter.prototype["import"] = function (data) {
         this.qTable.clear();
-        for (const [key, entry] of Object.entries(data)) {
+        for (var _i = 0, _a = Object.entries(data); _i < _a.length; _i++) {
+            var _b = _a[_i], key = _b[0], entry = _b[1];
             this.qTable.set(key, {
                 qValues: new Float32Array(entry.qValues),
                 visits: entry.visits,
-                lastUpdate: Date.now(),
+                lastUpdate: Date.now()
             });
         }
-    }
+    };
     // Private methods
     /**
      * Legacy hash function (kept for backward compatibility)
      */
-    hashState(context) {
+    QLearningRouter.prototype.hashState = function (context) {
         // Simple hash for context string
-        let hash = 0;
-        for (let i = 0; i < context.length; i++) {
-            const char = context.charCodeAt(i);
+        var hash = 0;
+        for (var i = 0; i < context.length; i++) {
+            var char = context.charCodeAt(i);
             hash = ((hash << 5) - hash) + char;
             hash = hash & hash; // Convert to 32-bit integer
         }
-        return `state_${hash}`;
-    }
+        return "state_" + hash;
+    };
     /**
      * Optimized state hashing using feature extraction
      * Creates a more semantic representation of the task context
      */
-    hashStateOptimized(context) {
+    QLearningRouter.prototype.hashStateOptimized = function (context) {
         // Check feature hash cache first
         if (this.featureHashCache.has(context)) {
-            const cached = this.featureHashCache.get(context);
+            var cached = this.featureHashCache.get(context);
             return this.featureVectorToKey(cached);
         }
         // Extract features from context
-        const features = this.extractFeatures(context);
+        var features = this.extractFeatures(context);
         // Cache the feature vector
         if (this.featureHashCache.size < 1000) { // Limit cache size
             this.featureHashCache.set(context, features);
         }
         return this.featureVectorToKey(features);
-    }
+    };
     /**
      * Extract feature vector from task context
      * Uses keyword matching and n-gram hashing
      */
-    extractFeatures(context) {
-        const features = new Float32Array(this.config.stateSpaceDim);
-        const lowerContext = context.toLowerCase();
-        const words = lowerContext.split(/\s+/);
+    QLearningRouter.prototype.extractFeatures = function (context) {
+        var features = new Float32Array(this.config.stateSpaceDim);
+        var lowerContext = context.toLowerCase();
+        var words = lowerContext.split(/\s+/);
         // Feature 1-32: Keyword presence (binary features)
-        for (let i = 0; i < FEATURE_KEYWORDS.length && i < 32; i++) {
+        for (var i = 0; i < FEATURE_KEYWORDS.length && i < 32; i++) {
             if (lowerContext.includes(FEATURE_KEYWORDS[i])) {
                 features[i] = 1.0;
             }
         }
         // Feature 33-40: Context length buckets
-        const lengthBucket = Math.min(Math.floor(context.length / 50), 7);
+        var lengthBucket = Math.min(Math.floor(context.length / 50), 7);
         features[32 + lengthBucket] = 1.0;
         // Feature 41-48: Word count buckets
-        const wordBucket = Math.min(Math.floor(words.length / 5), 7);
+        var wordBucket = Math.min(Math.floor(words.length / 5), 7);
         features[40 + wordBucket] = 1.0;
         // Feature 49-56: File extension hints
-        const extPatterns = ['.ts', '.js', '.py', '.go', '.rs', '.java', '.md', '.json'];
-        for (let i = 0; i < extPatterns.length; i++) {
+        var extPatterns = ['.ts', '.js', '.py', '.go', '.rs', '.java', '.md', '.json'];
+        for (var i = 0; i < extPatterns.length; i++) {
             if (lowerContext.includes(extPatterns[i])) {
                 features[48 + i] = 1.0;
             }
         }
         // Feature 57-64: N-gram hash features (for capturing unique patterns)
-        for (let i = 0; i < words.length - 1 && i < 8; i++) {
-            const bigram = `${words[i]}_${words[i + 1]}`;
-            const hash = this.murmurhash3(bigram) % 8;
+        for (var i = 0; i < words.length - 1 && i < 8; i++) {
+            var bigram = words[i] + "_" + words[i + 1];
+            var hash = this.murmurhash3(bigram) % 8;
             features[56 + hash] += 0.25;
         }
         // Normalize features
-        let norm = 0;
-        for (let i = 0; i < features.length; i++) {
+        var norm = 0;
+        for (var i = 0; i < features.length; i++) {
             norm += features[i] * features[i];
         }
         norm = Math.sqrt(norm) || 1;
-        for (let i = 0; i < features.length; i++) {
+        for (var i = 0; i < features.length; i++) {
             features[i] /= norm;
         }
         return features;
-    }
+    };
     /**
      * Convert feature vector to state key
      * Uses locality-sensitive hashing for similar contexts
      */
-    featureVectorToKey(features) {
+    QLearningRouter.prototype.featureVectorToKey = function (features) {
         // Quantize features to create discrete state
-        const quantized = [];
-        for (let i = 0; i < features.length; i += 4) {
-            let bucket = 0;
-            for (let j = 0; j < 4 && i + j < features.length; j++) {
+        var quantized = [];
+        for (var i = 0; i < features.length; i += 4) {
+            var bucket = 0;
+            for (var j = 0; j < 4 && i + j < features.length; j++) {
                 if (features[i + j] > 0.25) {
                     bucket |= (1 << j);
                 }
@@ -597,21 +676,21 @@ export class QLearningRouter {
             quantized.push(bucket);
         }
         // Create hash from quantized values
-        let hash = 0;
-        for (let i = 0; i < quantized.length; i++) {
+        var hash = 0;
+        for (var i = 0; i < quantized.length; i++) {
             hash = ((hash << 4) ^ quantized[i]) & 0x7fffffff;
         }
-        return `fstate_${hash.toString(36)}`;
-    }
+        return "fstate_" + hash.toString(36);
+    };
     /**
      * MurmurHash3 32-bit implementation for n-gram hashing
      */
-    murmurhash3(str) {
-        let h1 = 0xdeadbeef;
-        const c1 = 0xcc9e2d51;
-        const c2 = 0x1b873593;
-        for (let i = 0; i < str.length; i++) {
-            let k1 = str.charCodeAt(i);
+    QLearningRouter.prototype.murmurhash3 = function (str) {
+        var h1 = 0xdeadbeef;
+        var c1 = 0xcc9e2d51;
+        var c2 = 0x1b873593;
+        for (var i = 0; i < str.length; i++) {
+            var k1 = str.charCodeAt(i);
             k1 = Math.imul(k1, c1);
             k1 = (k1 << 15) | (k1 >>> 17);
             k1 = Math.imul(k1, c2);
@@ -626,52 +705,54 @@ export class QLearningRouter {
         h1 = Math.imul(h1, 0xc2b2ae35);
         h1 ^= h1 >>> 16;
         return h1 >>> 0;
-    }
-    getQValues(stateKey) {
-        const entry = this.qTable.get(stateKey);
+    };
+    QLearningRouter.prototype.getQValues = function (stateKey) {
+        var entry = this.qTable.get(stateKey);
         if (!entry) {
             return new Array(this.config.numActions).fill(0);
         }
         return Array.from(entry.qValues);
-    }
-    getOrCreateEntry(stateKey) {
-        let entry = this.qTable.get(stateKey);
+    };
+    QLearningRouter.prototype.getOrCreateEntry = function (stateKey) {
+        var entry = this.qTable.get(stateKey);
         if (!entry) {
             entry = {
                 qValues: new Float32Array(this.config.numActions),
                 visits: 0,
-                lastUpdate: Date.now(),
+                lastUpdate: Date.now()
             };
             this.qTable.set(stateKey, entry);
         }
         return entry;
-    }
-    argmax(values) {
-        let maxIdx = 0;
-        let maxVal = values[0];
-        for (let i = 1; i < values.length; i++) {
+    };
+    QLearningRouter.prototype.argmax = function (values) {
+        var maxIdx = 0;
+        var maxVal = values[0];
+        for (var i = 1; i < values.length; i++) {
             if (values[i] > maxVal) {
                 maxVal = values[i];
                 maxIdx = i;
             }
         }
         return maxIdx;
-    }
-    softmaxConfidence(qValues, actionIdx) {
-        const maxQ = Math.max(...qValues);
-        const expValues = qValues.map(q => Math.exp(q - maxQ)); // Subtract max for numerical stability
-        const sumExp = expValues.reduce((a, b) => a + b, 0);
+    };
+    QLearningRouter.prototype.softmaxConfidence = function (qValues, actionIdx) {
+        var maxQ = Math.max.apply(Math, qValues);
+        var expValues = qValues.map(function (q) { return Math.exp(q - maxQ); }); // Subtract max for numerical stability
+        var sumExp = expValues.reduce(function (a, b) { return a + b; }, 0);
         return expValues[actionIdx] / sumExp;
-    }
-    pruneQTable() {
-        const entries = Array.from(this.qTable.entries())
-            .sort((a, b) => a[1].lastUpdate - b[1].lastUpdate);
-        const toRemove = entries.length - Math.floor(this.config.maxStates * 0.8);
-        for (let i = 0; i < toRemove; i++) {
-            this.qTable.delete(entries[i][0]);
-        }
-    }
-}
+    };
+    QLearningRouter.prototype.pruneQTable = function () {
+        var entries = Array.from(this.qTable.entries())
+            .sort(function (a, b) { return a[1].lastUpdate - b[1].lastUpdate; });
+        var toRemove = entries.length - Math.floor(this.config.maxStates * 0.8);
+        for (var i = 0; i < toRemove; i++) {
+            this.qTable["delete"](entries[i][0]);
+        }
+    };
+    return QLearningRouter;
+}());
+export { QLearningRouter };
 /**
  * Factory function
  */