kynjal-cli 4.0.0 → 4.0.1

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

@@ -13,59 +13,12 @@
  *
  * @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
  */
-var DEFAULT_CONFIG = {
+const DEFAULT_CONFIG = {
     learningRate: 0.1,
     gamma: 0.99,
     explorationInitial: 1.0,
@@ -81,12 +34,12 @@ var DEFAULT_CONFIG = {
     cacheTTL: 300000,
     modelPath: '.swarm/q-learning-model.json',
     autoSaveInterval: 100,
-    stateSpaceDim: 64
+    stateSpaceDim: 64,
 };
 /**
  * Route names mapping
  */
-var ROUTE_NAMES = [
+const ROUTE_NAMES = [
     'coder',
     'tester',
     'reviewer',
@@ -99,7 +52,7 @@ var ROUTE_NAMES = [
 /**
  * Task feature keywords for state representation
  */
-var FEATURE_KEYWORDS = [
+const FEATURE_KEYWORDS = [
     // Code-related
     'implement', 'code', 'write', 'create', 'build', 'develop',
     // Testing-related
@@ -127,155 +80,126 @@ var FEATURE_KEYWORDS = [
  * - Prioritized experience replay
  * - Model persistence
  */
-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);
+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 };
         this.epsilon = this.config.explorationInitial;
     }
     /**
      * Initialize the router, attempting to load ruvector native module
      * and restore persisted model if available
      */
-    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*/];
-                }
-            });
-        });
-    };
+    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();
+    }
     /**
      * Load model from persistence file
      */
-    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*/];
-            });
-        });
-    };
+    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;
+        }
+    }
     /**
      * Save model to persistence file
      */
-    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*/];
-            });
-        });
-    };
+    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;
+        }
+    }
     /**
      * Route a task based on its context
      * Uses LRU cache for repeated task patterns
      */
-    QLearningRouter.prototype.route = function (taskContext, explore) {
-        if (explore === void 0) { explore = true; }
-        var stateKey = this.hashStateOptimized(taskContext);
+    route(taskContext, explore = true) {
+        const stateKey = this.hashStateOptimized(taskContext);
         // Check cache first (only for exploitation, not exploration)
         if (!explore) {
-            var cached = this.getCachedRoute(stateKey);
+            const cached = this.getCachedRoute(stateKey);
             if (cached) {
                 this.cacheHits++;
                 return cached;
@@ -283,9 +207,9 @@ var QLearningRouter = /** @class */ (function () {
             this.cacheMisses++;
         }
         // Check if we should explore using decayed epsilon
-        var shouldExplore = explore && Math.random() < this.epsilon;
-        var actionIdx;
-        var qValues;
+        const shouldExplore = explore && Math.random() < this.epsilon;
+        let actionIdx;
+        let qValues;
         if (shouldExplore) {
             // Random exploration
             actionIdx = Math.floor(Math.random() * this.config.numActions);
@@ -297,95 +221,95 @@ var QLearningRouter = /** @class */ (function () {
             actionIdx = this.argmax(qValues);
         }
         // Calculate confidence from softmax of Q-values
-        var confidence = this.softmaxConfidence(qValues, actionIdx);
+        const confidence = this.softmaxConfidence(qValues, actionIdx);
         // Get alternatives sorted by Q-value
-        var alternatives = ROUTE_NAMES
-            .map(function (route, idx) { return ({ route: route, score: qValues[idx] }); })
-            .sort(function (a, b) { return b.score - a.score; })
+        const alternatives = ROUTE_NAMES
+            .map((route, idx) => ({ route, score: qValues[idx] }))
+            .sort((a, b) => b.score - a.score)
             .slice(1, 4); // Top 3 alternatives
-        var decision = {
+        const decision = {
             route: ROUTE_NAMES[actionIdx] || 'coder',
-            confidence: confidence,
-            qValues: qValues,
+            confidence,
+            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)
      */
-    QLearningRouter.prototype.getCachedRoute = function (stateKey) {
-        var entry = this.routeCache.get(stateKey);
+    getCachedRoute(stateKey) {
+        const 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(function (k) { return k !== stateKey; });
+            this.routeCache.delete(stateKey);
+            this.cacheOrder = this.cacheOrder.filter(k => k !== stateKey);
             return null;
         }
         // Update LRU order
-        this.cacheOrder = this.cacheOrder.filter(function (k) { return k !== stateKey; });
+        this.cacheOrder = this.cacheOrder.filter(k => k !== stateKey);
         this.cacheOrder.push(stateKey);
         entry.hits++;
         return entry.decision;
-    };
+    }
     /**
      * Cache a route decision (LRU eviction)
      */
-    QLearningRouter.prototype.cacheRoute = function (stateKey, decision) {
+    cacheRoute(stateKey, decision) {
         // Evict oldest if cache is full
         while (this.routeCache.size >= this.config.cacheSize && this.cacheOrder.length > 0) {
-            var oldest = this.cacheOrder.shift();
+            const 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)
      */
-    QLearningRouter.prototype.invalidateCache = function () {
+    invalidateCache() {
         this.routeCache.clear();
         this.cacheOrder = [];
-    };
+    }
     /**
      * Update Q-values based on feedback
      * Includes experience replay for stable learning
      */
-    QLearningRouter.prototype.update = function (taskContext, action, reward, nextContext) {
-        var stateKey = this.hashStateOptimized(taskContext);
-        var actionIdx = ROUTE_NAMES.indexOf(action);
+    update(taskContext, action, reward, nextContext) {
+        const stateKey = this.hashStateOptimized(taskContext);
+        const actionIdx = ROUTE_NAMES.indexOf(action);
         if (actionIdx === -1) {
             return 0;
         }
-        var nextStateKey = nextContext ? this.hashStateOptimized(nextContext) : null;
+        const nextStateKey = nextContext ? this.hashStateOptimized(nextContext) : null;
         // Store experience in replay buffer
         if (this.config.enableReplay) {
-            var experience = {
-                stateKey: stateKey,
-                actionIdx: actionIdx,
-                reward: reward,
-                nextStateKey: nextStateKey,
+            const experience = {
+                stateKey,
+                actionIdx,
+                reward,
+                nextStateKey,
                 timestamp: Date.now(),
-                priority: Math.abs(reward) + 0.1
+                priority: Math.abs(reward) + 0.1, // Initial priority based on reward magnitude
             };
             this.addToReplayBuffer(experience);
         }
         // Perform direct update
-        var tdError = this.updateQValue(stateKey, actionIdx, reward, nextStateKey);
+        const tdError = this.updateQValue(stateKey, actionIdx, reward, nextStateKey);
         // Perform experience replay
         if (this.config.enableReplay && this.replayBuffer.length >= this.config.replayBatchSize) {
             this.experienceReplay();
@@ -401,25 +325,25 @@ var QLearningRouter = /** @class */ (function () {
         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"](function () { }); // Fire and forget
+            this.saveModel().catch(() => { }); // Fire and forget
         }
         // Invalidate cache periodically to reflect Q-table changes
         if (this.updateCount % 50 === 0) {
             this.invalidateCache();
         }
         return tdError;
-    };
+    }
     /**
      * Internal Q-value update
      */
-    QLearningRouter.prototype.updateQValue = function (stateKey, actionIdx, reward, nextStateKey) {
-        var entry = this.getOrCreateEntry(stateKey);
-        var currentQ = entry.qValues[actionIdx];
+    updateQValue(stateKey, actionIdx, reward, nextStateKey) {
+        const entry = this.getOrCreateEntry(stateKey);
+        const currentQ = entry.qValues[actionIdx];
         // Calculate target Q-value
-        var targetQ;
+        let targetQ;
         if (nextStateKey) {
-            var nextQValues = this.getQValues(nextStateKey);
-            var maxNextQ = Math.max.apply(Math, nextQValues);
+            const nextQValues = this.getQValues(nextStateKey);
+            const maxNextQ = Math.max(...nextQValues);
             targetQ = reward + this.config.gamma * maxNextQ;
         }
         else {
@@ -427,17 +351,17 @@ var QLearningRouter = /** @class */ (function () {
             targetQ = reward;
         }
         // TD error
-        var tdError = targetQ - currentQ;
+        const 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
      */
-    QLearningRouter.prototype.addToReplayBuffer = function (experience) {
+    addToReplayBuffer(experience) {
         if (this.replayBuffer.length < this.config.replayBufferSize) {
             this.replayBuffer.push(experience);
         }
@@ -446,36 +370,35 @@ var QLearningRouter = /** @class */ (function () {
         }
         this.replayBufferIdx = (this.replayBufferIdx + 1) % this.config.replayBufferSize;
         this.totalExperiences++;
-    };
+    }
     /**
      * Perform prioritized experience replay
      * Samples mini-batch from buffer and updates Q-values
      */
-    QLearningRouter.prototype.experienceReplay = function () {
+    experienceReplay() {
         if (this.replayBuffer.length < this.config.replayBatchSize) {
             return;
         }
         // Prioritized sampling based on TD error magnitude
-        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);
+        const batch = this.samplePrioritizedBatch(this.config.replayBatchSize);
+        for (const exp of batch) {
+            const 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
      */
-    QLearningRouter.prototype.samplePrioritizedBatch = function (batchSize) {
-        var totalPriority = this.replayBuffer.reduce(function (sum, exp) { return sum + exp.priority; }, 0);
-        var batch = [];
-        var selected = new Set();
+    samplePrioritizedBatch(batchSize) {
+        const totalPriority = this.replayBuffer.reduce((sum, exp) => sum + exp.priority, 0);
+        const batch = [];
+        const selected = new Set();
         while (batch.length < batchSize && selected.size < this.replayBuffer.length) {
-            var threshold = Math.random() * totalPriority;
-            var cumSum = 0;
-            for (var i = 0; i < this.replayBuffer.length; i++) {
+            let threshold = Math.random() * totalPriority;
+            let cumSum = 0;
+            for (let i = 0; i < this.replayBuffer.length; i++) {
                 if (selected.has(i))
                     continue;
                 cumSum += this.replayBuffer[i].priority;
@@ -487,19 +410,19 @@ var QLearningRouter = /** @class */ (function () {
             }
         }
         return batch;
-    };
+    }
     /**
      * Calculate epsilon using configured decay strategy
      */
-    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);
+    calculateEpsilon() {
+        const { explorationInitial, explorationFinal, explorationDecay, explorationDecayType } = this.config;
+        const 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)
-                var decayRate = -Math.log((explorationFinal / explorationInitial) + 1e-8) / explorationDecay;
+                const decayRate = -Math.log((explorationFinal / explorationInitial) + 1e-8) / explorationDecay;
                 return explorationFinal + (explorationInitial - explorationFinal) * Math.exp(-decayRate * this.stepCount);
             case 'cosine':
                 // Cosine annealing: smooth transition
@@ -507,12 +430,12 @@ var QLearningRouter = /** @class */ (function () {
             default:
                 return Math.max(explorationFinal, explorationInitial - this.stepCount / explorationDecay);
         }
-    };
+    }
     /**
      * Get statistics including cache and replay buffer metrics
      */
-    QLearningRouter.prototype.getStats = function () {
-        var cacheHitRate = this.cacheHits + this.cacheMisses > 0
+    getStats() {
+        const cacheHitRate = this.cacheHits + this.cacheMisses > 0
             ? this.cacheHits / (this.cacheHits + this.cacheMisses)
             : 0;
         return {
@@ -526,18 +449,18 @@ var QLearningRouter = /** @class */ (function () {
             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)
      */
-    QLearningRouter.prototype.reset = function () {
+    reset() {
         this.qTable.clear();
         this.epsilon = this.config.explorationInitial;
         this.stepCount = 0;
@@ -554,121 +477,119 @@ var QLearningRouter = /** @class */ (function () {
         this.cacheMisses = 0;
         // Reset feature hash cache
         this.featureHashCache.clear();
-    };
+    }
     /**
      * Export Q-table for persistence
      */
-    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];
+    export() {
+        const result = {};
+        for (const [key, entry] of this.qTable) {
             result[key] = {
                 qValues: Array.from(entry.qValues),
-                visits: entry.visits
+                visits: entry.visits,
             };
         }
         return result;
-    };
+    }
     /**
      * Import Q-table from persistence
      */
-    QLearningRouter.prototype["import"] = function (data) {
+    import(data) {
         this.qTable.clear();
-        for (var _i = 0, _a = Object.entries(data); _i < _a.length; _i++) {
-            var _b = _a[_i], key = _b[0], entry = _b[1];
+        for (const [key, entry] of Object.entries(data)) {
             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)
      */
-    QLearningRouter.prototype.hashState = function (context) {
+    hashState(context) {
         // Simple hash for context string
-        var hash = 0;
-        for (var i = 0; i < context.length; i++) {
-            var char = context.charCodeAt(i);
+        let hash = 0;
+        for (let i = 0; i < context.length; i++) {
+            const 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
      */
-    QLearningRouter.prototype.hashStateOptimized = function (context) {
+    hashStateOptimized(context) {
         // Check feature hash cache first
         if (this.featureHashCache.has(context)) {
-            var cached = this.featureHashCache.get(context);
+            const cached = this.featureHashCache.get(context);
             return this.featureVectorToKey(cached);
         }
         // Extract features from context
-        var features = this.extractFeatures(context);
+        const 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
      */
-    QLearningRouter.prototype.extractFeatures = function (context) {
-        var features = new Float32Array(this.config.stateSpaceDim);
-        var lowerContext = context.toLowerCase();
-        var words = lowerContext.split(/\s+/);
+    extractFeatures(context) {
+        const features = new Float32Array(this.config.stateSpaceDim);
+        const lowerContext = context.toLowerCase();
+        const words = lowerContext.split(/\s+/);
         // Feature 1-32: Keyword presence (binary features)
-        for (var i = 0; i < FEATURE_KEYWORDS.length && i < 32; i++) {
+        for (let 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
-        var lengthBucket = Math.min(Math.floor(context.length / 50), 7);
+        const lengthBucket = Math.min(Math.floor(context.length / 50), 7);
         features[32 + lengthBucket] = 1.0;
         // Feature 41-48: Word count buckets
-        var wordBucket = Math.min(Math.floor(words.length / 5), 7);
+        const wordBucket = Math.min(Math.floor(words.length / 5), 7);
         features[40 + wordBucket] = 1.0;
         // Feature 49-56: File extension hints
-        var extPatterns = ['.ts', '.js', '.py', '.go', '.rs', '.java', '.md', '.json'];
-        for (var i = 0; i < extPatterns.length; i++) {
+        const extPatterns = ['.ts', '.js', '.py', '.go', '.rs', '.java', '.md', '.json'];
+        for (let 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 (var i = 0; i < words.length - 1 && i < 8; i++) {
-            var bigram = words[i] + "_" + words[i + 1];
-            var hash = this.murmurhash3(bigram) % 8;
+        for (let i = 0; i < words.length - 1 && i < 8; i++) {
+            const bigram = `${words[i]}_${words[i + 1]}`;
+            const hash = this.murmurhash3(bigram) % 8;
             features[56 + hash] += 0.25;
         }
         // Normalize features
-        var norm = 0;
-        for (var i = 0; i < features.length; i++) {
+        let norm = 0;
+        for (let i = 0; i < features.length; i++) {
             norm += features[i] * features[i];
         }
         norm = Math.sqrt(norm) || 1;
-        for (var i = 0; i < features.length; i++) {
+        for (let i = 0; i < features.length; i++) {
             features[i] /= norm;
         }
         return features;
-    };
+    }
     /**
      * Convert feature vector to state key
      * Uses locality-sensitive hashing for similar contexts
      */
-    QLearningRouter.prototype.featureVectorToKey = function (features) {
+    featureVectorToKey(features) {
         // Quantize features to create discrete state
-        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++) {
+        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++) {
                 if (features[i + j] > 0.25) {
                     bucket |= (1 << j);
                 }
@@ -676,21 +597,21 @@ var QLearningRouter = /** @class */ (function () {
             quantized.push(bucket);
         }
         // Create hash from quantized values
-        var hash = 0;
-        for (var i = 0; i < quantized.length; i++) {
+        let hash = 0;
+        for (let 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
      */
-    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);
+    murmurhash3(str) {
+        let h1 = 0xdeadbeef;
+        const c1 = 0xcc9e2d51;
+        const c2 = 0x1b873593;
+        for (let i = 0; i < str.length; i++) {
+            let k1 = str.charCodeAt(i);
             k1 = Math.imul(k1, c1);
             k1 = (k1 << 15) | (k1 >>> 17);
             k1 = Math.imul(k1, c2);
@@ -705,54 +626,52 @@ var QLearningRouter = /** @class */ (function () {
         h1 = Math.imul(h1, 0xc2b2ae35);
         h1 ^= h1 >>> 16;
         return h1 >>> 0;
-    };
-    QLearningRouter.prototype.getQValues = function (stateKey) {
-        var entry = this.qTable.get(stateKey);
+    }
+    getQValues(stateKey) {
+        const entry = this.qTable.get(stateKey);
         if (!entry) {
             return new Array(this.config.numActions).fill(0);
         }
         return Array.from(entry.qValues);
-    };
-    QLearningRouter.prototype.getOrCreateEntry = function (stateKey) {
-        var entry = this.qTable.get(stateKey);
+    }
+    getOrCreateEntry(stateKey) {
+        let 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;
-    };
-    QLearningRouter.prototype.argmax = function (values) {
-        var maxIdx = 0;
-        var maxVal = values[0];
-        for (var i = 1; i < values.length; i++) {
+    }
+    argmax(values) {
+        let maxIdx = 0;
+        let maxVal = values[0];
+        for (let i = 1; i < values.length; i++) {
             if (values[i] > maxVal) {
                 maxVal = values[i];
                 maxIdx = i;
             }
         }
         return maxIdx;
-    };
-    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);
+    }
+    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);
         return expValues[actionIdx] / sumExp;
-    };
-    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 };
+    }
+    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]);
+        }
+    }
+}
 /**
  * Factory function
  */