kynjal-cli 4.0.0 → 4.0.1

package/dist/src/memory/sona-optimizer.js

@@ -13,79 +13,23 @@
  *
  * @module v3/cli/memory/sona-optimizer
  */
-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 };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { dirname, join } from 'path';
 // ============================================================================
 // Constants
 // ============================================================================
-var DEFAULT_PERSISTENCE_PATH = '.swarm/sona-patterns.json';
-var PATTERN_VERSION = '1.0.0';
-var MIN_CONFIDENCE = 0.1;
-var MAX_CONFIDENCE = 0.99;
-var CONFIDENCE_INCREMENT = 0.1;
-var CONFIDENCE_DECREMENT = 0.15;
-var DECAY_RATE = 0.01; // Per day
-var MAX_PATTERNS = 1000;
+const DEFAULT_PERSISTENCE_PATH = '.swarm/sona-patterns.json';
+const PATTERN_VERSION = '1.0.0';
+const MIN_CONFIDENCE = 0.1;
+const MAX_CONFIDENCE = 0.99;
+const CONFIDENCE_INCREMENT = 0.1;
+const CONFIDENCE_DECREMENT = 0.15;
+const DECAY_RATE = 0.01; // Per day
+const MAX_PATTERNS = 1000;
 /**
  * Common agent types for routing
  */
-var AGENT_TYPES = [
+const AGENT_TYPES = [
     'coder',
     'tester',
     'reviewer',
@@ -100,7 +44,7 @@ var AGENT_TYPES = [
 /**
  * Task keywords for pattern extraction
  */
-var KEYWORD_CATEGORIES = {
+const KEYWORD_CATEGORIES = {
     coder: [
         'implement', 'code', 'write', 'create', 'build', 'develop', 'add',
         'feature', 'function', 'class', 'module', 'api', 'endpoint',
@@ -125,7 +69,7 @@ var KEYWORD_CATEGORIES = {
         'optimize', 'performance', 'speed', 'memory', 'improve', 'enhance',
         'faster', 'efficient', 'reduce', 'benchmark',
     ],
-    "debugger": [
+    debugger: [
         'debug', 'fix', 'bug', 'error', 'issue', 'problem', 'crash',
         'exception', 'trace', 'diagnose', 'resolve',
     ],
@@ -140,7 +84,7 @@ var KEYWORD_CATEGORIES = {
     'performance-engineer': [
         'profiling', 'bottleneck', 'latency', 'throughput', 'cache',
         'scale', 'load', 'stress', 'concurrent', 'parallel',
-    ]
+    ],
 };
 // ============================================================================
 // SONAOptimizer Class
@@ -151,81 +95,69 @@ var KEYWORD_CATEGORIES = {
  * Learns from past task outcomes to improve future routing decisions.
  * Integrates with Q-learning router for hybrid routing strategy.
  */
-var SONAOptimizer = /** @class */ (function () {
-    function SONAOptimizer(options) {
-        this.patterns = new Map();
-        this.trajectoriesProcessed = 0;
-        this.successfulRoutings = 0;
-        this.failedRoutings = 0;
-        this.lastUpdate = null;
-        this.qLearningRouter = null;
-        this.qLearningEnabled = false;
-        this.persistencePath = (options === null || options === void 0 ? void 0 : options.persistencePath) || DEFAULT_PERSISTENCE_PATH;
+export class SONAOptimizer {
+    patterns = new Map();
+    trajectoriesProcessed = 0;
+    successfulRoutings = 0;
+    failedRoutings = 0;
+    lastUpdate = null;
+    persistencePath;
+    qLearningRouter = null;
+    qLearningEnabled = false;
+    constructor(options) {
+        this.persistencePath = options?.persistencePath || DEFAULT_PERSISTENCE_PATH;
     }
     /**
      * Initialize the optimizer and load persisted state
      */
-    SONAOptimizer.prototype.initialize = function () {
-        return __awaiter(this, void 0, Promise, function () {
-            var loaded, QLearningRouter, _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        loaded = this.loadFromDisk();
-                        _b.label = 1;
-                    case 1:
-                        _b.trys.push([1, 4, , 5]);
-                        return [4 /*yield*/, import('../ruvector/q-learning-router.js')];
-                    case 2:
-                        QLearningRouter = (_b.sent()).QLearningRouter;
-                        this.qLearningRouter = new QLearningRouter();
-                        return [4 /*yield*/, this.qLearningRouter.initialize()];
-                    case 3:
-                        _b.sent();
-                        this.qLearningEnabled = true;
-                        return [3 /*break*/, 5];
-                    case 4:
-                        _a = _b.sent();
-                        // Q-learning not available, continue without it
-                        this.qLearningEnabled = false;
-                        return [3 /*break*/, 5];
-                    case 5: return [2 /*return*/, {
-                            success: true,
-                            patternsLoaded: loaded ? this.patterns.size : 0
-                        }];
-                }
-            });
-        });
-    };
+    async initialize() {
+        // Load persisted patterns
+        const loaded = this.loadFromDisk();
+        // Try to load Q-learning router lazily
+        try {
+            const { QLearningRouter } = await import('../ruvector/q-learning-router.js');
+            this.qLearningRouter = new QLearningRouter();
+            await this.qLearningRouter.initialize();
+            this.qLearningEnabled = true;
+        }
+        catch {
+            // Q-learning not available, continue without it
+            this.qLearningEnabled = false;
+        }
+        return {
+            success: true,
+            patternsLoaded: loaded ? this.patterns.size : 0,
+        };
+    }
     /**
      * Process a trajectory outcome and learn from it
      * Called by hooksTrajectoryEnd
      */
-    SONAOptimizer.prototype.processTrajectoryOutcome = function (outcome) {
-        var task = outcome.task, agent = outcome.agent, success = outcome.success;
+    processTrajectoryOutcome(outcome) {
+        const { task, agent, success } = outcome;
         // Extract keywords from task
-        var keywords = this.extractKeywords(task);
+        const keywords = this.extractKeywords(task);
         if (keywords.length === 0) {
             return {
                 learned: false,
                 patternKey: '',
                 confidence: 0,
-                keywordsExtracted: []
+                keywordsExtracted: [],
             };
         }
         // Create pattern key from sorted keywords
-        var patternKey = this.createPatternKey(keywords, agent);
+        const patternKey = this.createPatternKey(keywords, agent);
         // Get or create pattern
-        var pattern = this.patterns.get(patternKey);
+        let pattern = this.patterns.get(patternKey);
         if (!pattern) {
             pattern = {
-                keywords: keywords,
-                agent: agent,
-                confidence: 0.5,
+                keywords,
+                agent,
+                confidence: 0.5, // Start at neutral
                 successCount: 0,
                 failureCount: 0,
                 lastUsed: Date.now(),
-                createdAt: Date.now()
+                createdAt: Date.now(),
             };
         }
         // Update pattern based on outcome
@@ -248,25 +180,25 @@ var SONAOptimizer = /** @class */ (function () {
         this.prunePatterns();
         // Update Q-learning router if available
         if (this.qLearningRouter) {
-            var reward = success ? 1.0 : -0.5;
+            const reward = success ? 1.0 : -0.5;
             this.qLearningRouter.update(task, agent, reward);
         }
         // Persist to disk (debounced)
         this.saveToDisk();
         return {
             learned: true,
-            patternKey: patternKey,
+            patternKey,
             confidence: pattern.confidence,
-            keywordsExtracted: keywords
+            keywordsExtracted: keywords,
         };
-    };
+    }
     /**
      * Get routing suggestion based on learned patterns
      */
-    SONAOptimizer.prototype.getRoutingSuggestion = function (task) {
-        var keywords = this.extractKeywords(task);
+    getRoutingSuggestion(task) {
+        const keywords = this.extractKeywords(task);
         // Try SONA pattern matching first
-        var sonaResult = this.findBestPatternMatch(keywords);
+        const sonaResult = this.findBestPatternMatch(keywords);
         if (sonaResult && sonaResult.confidence >= 0.6) {
             return {
                 agent: sonaResult.agent,
@@ -274,29 +206,29 @@ var SONAOptimizer = /** @class */ (function () {
                 usedQLearning: false,
                 source: 'sona-pattern',
                 alternatives: this.getAlternatives(keywords, sonaResult.agent),
-                matchedKeywords: sonaResult.matchedKeywords
+                matchedKeywords: sonaResult.matchedKeywords,
             };
         }
         // Try Q-learning router if available
         if (this.qLearningRouter && this.qLearningEnabled) {
             try {
-                var decision = this.qLearningRouter.route(task, false);
+                const decision = this.qLearningRouter.route(task, false);
                 if (decision.confidence >= 0.5) {
                     return {
                         agent: decision.route,
                         confidence: decision.confidence,
                         usedQLearning: true,
                         source: 'q-learning',
-                        alternatives: decision.alternatives
+                        alternatives: decision.alternatives,
                     };
                 }
             }
-            catch (_a) {
+            catch {
                 // Q-learning failed, continue to fallback
             }
         }
         // Fallback to keyword-based heuristic
-        var keywordMatch = this.matchKeywordsToAgent(keywords);
+        const keywordMatch = this.matchKeywordsToAgent(keywords);
         if (keywordMatch) {
             return {
                 agent: keywordMatch.agent,
@@ -304,7 +236,7 @@ var SONAOptimizer = /** @class */ (function () {
                 usedQLearning: false,
                 source: 'keyword-match',
                 alternatives: this.getAlternatives(keywords, keywordMatch.agent),
-                matchedKeywords: keywordMatch.matchedKeywords
+                matchedKeywords: keywordMatch.matchedKeywords,
             };
         }
         // Default fallback
@@ -316,16 +248,15 @@ var SONAOptimizer = /** @class */ (function () {
             alternatives: [
                 { agent: 'researcher', score: 0.2 },
                 { agent: 'architect', score: 0.15 },
-            ]
+            ],
         };
-    };
+    }
     /**
      * Get optimizer statistics
      */
-    SONAOptimizer.prototype.getStats = function () {
-        var totalConfidence = 0;
-        for (var _i = 0, _a = this.patterns.values(); _i < _a.length; _i++) {
-            var pattern = _a[_i];
+    getStats() {
+        let totalConfidence = 0;
+        for (const pattern of this.patterns.values()) {
             totalConfidence += pattern.confidence;
         }
         return {
@@ -335,25 +266,24 @@ var SONAOptimizer = /** @class */ (function () {
             trajectoriesProcessed: this.trajectoriesProcessed,
             avgConfidence: this.patterns.size > 0 ? totalConfidence / this.patterns.size : 0,
             qLearningEnabled: this.qLearningEnabled,
-            lastUpdate: this.lastUpdate
+            lastUpdate: this.lastUpdate,
         };
-    };
+    }
     /**
      * Apply temporal decay to pattern confidence
      * Reduces confidence of unused patterns
      */
-    SONAOptimizer.prototype.applyTemporalDecay = function () {
-        var now = Date.now();
-        var decayed = 0;
-        for (var _i = 0, _a = this.patterns; _i < _a.length; _i++) {
-            var _b = _a[_i], key = _b[0], pattern = _b[1];
-            var daysSinceUse = (now - pattern.lastUsed) / (1000 * 60 * 60 * 24);
+    applyTemporalDecay() {
+        const now = Date.now();
+        let decayed = 0;
+        for (const [key, pattern] of this.patterns) {
+            const daysSinceUse = (now - pattern.lastUsed) / (1000 * 60 * 60 * 24);
             if (daysSinceUse > 1) {
-                var decay = Math.exp(-DECAY_RATE * daysSinceUse);
-                var newConfidence = pattern.confidence * decay;
+                const decay = Math.exp(-DECAY_RATE * daysSinceUse);
+                const newConfidence = pattern.confidence * decay;
                 if (newConfidence < MIN_CONFIDENCE) {
                     // Remove patterns with very low confidence
-                    this.patterns["delete"](key);
+                    this.patterns.delete(key);
                 }
                 else {
                     pattern.confidence = newConfidence;
@@ -365,11 +295,11 @@ var SONAOptimizer = /** @class */ (function () {
             this.saveToDisk();
         }
         return decayed;
-    };
+    }
     /**
      * Reset all learned patterns
      */
-    SONAOptimizer.prototype.reset = function () {
+    reset() {
         this.patterns.clear();
         this.trajectoriesProcessed = 0;
         this.successfulRoutings = 0;
@@ -379,25 +309,23 @@ var SONAOptimizer = /** @class */ (function () {
             this.qLearningRouter.reset();
         }
         this.saveToDisk();
-    };
+    }
     /**
      * Export patterns for analysis
      */
-    SONAOptimizer.prototype.exportPatterns = function () {
-        var result = {};
-        for (var _i = 0, _a = this.patterns; _i < _a.length; _i++) {
-            var _b = _a[_i], key = _b[0], pattern = _b[1];
-            result[key] = __assign({}, pattern);
+    exportPatterns() {
+        const result = {};
+        for (const [key, pattern] of this.patterns) {
+            result[key] = { ...pattern };
         }
         return result;
-    };
+    }
     /**
      * Import patterns (for migration or testing)
      */
-    SONAOptimizer.prototype.importPatterns = function (patterns) {
-        var imported = 0;
-        for (var _i = 0, _a = Object.entries(patterns); _i < _a.length; _i++) {
-            var _b = _a[_i], key = _b[0], pattern = _b[1];
+    importPatterns(patterns) {
+        let imported = 0;
+        for (const [key, pattern] of Object.entries(patterns)) {
             if (this.validatePattern(pattern)) {
                 this.patterns.set(key, pattern);
                 imported++;
@@ -405,108 +333,99 @@ var SONAOptimizer = /** @class */ (function () {
         }
         this.saveToDisk();
         return imported;
-    };
+    }
     // ============================================================================
     // Private Methods
     // ============================================================================
     /**
      * Extract meaningful keywords from task description
      */
-    SONAOptimizer.prototype.extractKeywords = function (task) {
+    extractKeywords(task) {
         if (!task || typeof task !== 'string') {
             return [];
         }
-        var lower = task.toLowerCase();
-        var words = lower.split(/[\s\-_.,;:!?'"()\[\]{}]+/).filter(function (w) { return w.length > 2; });
+        const lower = task.toLowerCase();
+        const words = lower.split(/[\s\-_.,;:!?'"()\[\]{}]+/).filter(w => w.length > 2);
         // Extract keywords that match our categories
-        var keywords = new Set();
-        for (var _i = 0, _a = Object.values(KEYWORD_CATEGORIES); _i < _a.length; _i++) {
-            var categoryKeywords = _a[_i];
-            for (var _b = 0, categoryKeywords_1 = categoryKeywords; _b < categoryKeywords_1.length; _b++) {
-                var keyword = categoryKeywords_1[_b];
+        const keywords = new Set();
+        for (const categoryKeywords of Object.values(KEYWORD_CATEGORIES)) {
+            for (const keyword of categoryKeywords) {
                 if (lower.includes(keyword)) {
                     keywords.add(keyword);
                 }
             }
         }
         // Add any significant words not in categories
-        for (var _c = 0, words_1 = words; _c < words_1.length; _c++) {
-            var word = words_1[_c];
+        for (const word of words) {
             if (word.length >= 4 && !this.isStopWord(word)) {
                 keywords.add(word);
             }
         }
         return Array.from(keywords).slice(0, 10); // Limit to 10 keywords
-    };
+    }
     /**
      * Check if word is a stop word
      */
-    SONAOptimizer.prototype.isStopWord = function (word) {
-        var stopWords = new Set([
+    isStopWord(word) {
+        const stopWords = new Set([
             'the', 'and', 'for', 'that', 'this', 'with', 'from', 'have', 'been',
             'will', 'would', 'could', 'should', 'into', 'then', 'than', 'when',
             'where', 'which', 'there', 'their', 'what', 'about', 'more', 'some',
             'also', 'just', 'only', 'other', 'very', 'after', 'most', 'such',
         ]);
         return stopWords.has(word);
-    };
+    }
     /**
      * Create a unique pattern key from keywords and agent
      */
-    SONAOptimizer.prototype.createPatternKey = function (keywords, agent) {
-        var sortedKeywords = __spreadArray([], keywords, true).sort();
-        return agent + ":" + sortedKeywords.join('+');
-    };
+    createPatternKey(keywords, agent) {
+        const sortedKeywords = [...keywords].sort();
+        return `${agent}:${sortedKeywords.join('+')}`;
+    }
     /**
      * Find the best matching pattern for given keywords
      */
-    SONAOptimizer.prototype.findBestPatternMatch = function (keywords) {
+    findBestPatternMatch(keywords) {
         if (keywords.length === 0 || this.patterns.size === 0) {
             return null;
         }
-        var bestMatch = null;
-        var bestScore = 0;
-        for (var _i = 0, _a = this.patterns.values(); _i < _a.length; _i++) {
-            var pattern = _a[_i];
-            var matchedKeywords = pattern.keywords.filter(function (k) { return keywords.includes(k); });
-            var matchRatio = matchedKeywords.length / Math.max(pattern.keywords.length, keywords.length);
+        let bestMatch = null;
+        let bestScore = 0;
+        for (const pattern of this.patterns.values()) {
+            const matchedKeywords = pattern.keywords.filter(k => keywords.includes(k));
+            const matchRatio = matchedKeywords.length / Math.max(pattern.keywords.length, keywords.length);
             // Combine match ratio with confidence
-            var score = matchRatio * pattern.confidence;
+            const score = matchRatio * pattern.confidence;
             if (score > bestScore && matchedKeywords.length >= 1) {
                 bestScore = score;
                 bestMatch = {
                     agent: pattern.agent,
                     confidence: pattern.confidence * matchRatio,
-                    matchedKeywords: matchedKeywords
+                    matchedKeywords,
                 };
             }
         }
         return bestMatch;
-    };
+    }
     /**
      * Match keywords to agent using category heuristics
      */
-    SONAOptimizer.prototype.matchKeywordsToAgent = function (keywords) {
-        var scores = {};
-        var _loop_1 = function (agent, categoryKeywords) {
-            var matched = keywords.filter(function (k) { return categoryKeywords.includes(k); });
+    matchKeywordsToAgent(keywords) {
+        const scores = {};
+        for (const [agent, categoryKeywords] of Object.entries(KEYWORD_CATEGORIES)) {
+            const matched = keywords.filter(k => categoryKeywords.includes(k));
             if (matched.length > 0) {
                 scores[agent] = {
                     score: matched.length / categoryKeywords.length,
-                    matched: matched
+                    matched,
                 };
             }
-        };
-        for (var _i = 0, _a = Object.entries(KEYWORD_CATEGORIES); _i < _a.length; _i++) {
-            var _b = _a[_i], agent = _b[0], categoryKeywords = _b[1];
-            _loop_1(agent, categoryKeywords);
         }
         // Find best scoring agent
-        var bestAgent = '';
-        var bestScore = 0;
-        var bestMatched = [];
-        for (var _c = 0, _d = Object.entries(scores); _c < _d.length; _c++) {
-            var _e = _d[_c], agent = _e[0], data = _e[1];
+        let bestAgent = '';
+        let bestScore = 0;
+        let bestMatched = [];
+        for (const [agent, data] of Object.entries(scores)) {
             if (data.score > bestScore) {
                 bestScore = data.score;
                 bestAgent = agent;
@@ -517,82 +436,76 @@ var SONAOptimizer = /** @class */ (function () {
             return {
                 agent: bestAgent,
                 confidence: Math.min(0.7, 0.3 + bestScore),
-                matchedKeywords: bestMatched
+                matchedKeywords: bestMatched,
             };
         }
         return null;
-    };
+    }
     /**
      * Get alternative agent suggestions
      */
-    SONAOptimizer.prototype.getAlternatives = function (keywords, excludeAgent) {
-        var alternatives = [];
-        var _loop_2 = function (agent, categoryKeywords) {
+    getAlternatives(keywords, excludeAgent) {
+        const alternatives = [];
+        for (const [agent, categoryKeywords] of Object.entries(KEYWORD_CATEGORIES)) {
             if (agent === excludeAgent)
-                return "continue";
-            var matched = keywords.filter(function (k) { return categoryKeywords.includes(k); });
+                continue;
+            const matched = keywords.filter(k => categoryKeywords.includes(k));
             if (matched.length > 0) {
                 alternatives.push({
-                    agent: agent,
-                    score: matched.length / Math.max(keywords.length, 1) * 0.5
+                    agent,
+                    score: matched.length / Math.max(keywords.length, 1) * 0.5,
                 });
             }
-        };
-        for (var _i = 0, _a = Object.entries(KEYWORD_CATEGORIES); _i < _a.length; _i++) {
-            var _b = _a[_i], agent = _b[0], categoryKeywords = _b[1];
-            _loop_2(agent, categoryKeywords);
         }
         return alternatives
-            .sort(function (a, b) { return b.score - a.score; })
+            .sort((a, b) => b.score - a.score)
             .slice(0, 3);
-    };
+    }
     /**
      * Prune old/low-confidence patterns if over limit
      */
-    SONAOptimizer.prototype.prunePatterns = function () {
+    prunePatterns() {
         if (this.patterns.size <= MAX_PATTERNS) {
             return;
         }
         // Sort patterns by score (confidence * recency)
-        var entries = Array.from(this.patterns.entries()).map(function (_a) {
-            var key = _a[0], pattern = _a[1];
-            var ageInDays = (Date.now() - pattern.lastUsed) / (1000 * 60 * 60 * 24);
-            var recency = Math.exp(-0.1 * ageInDays);
-            var score = pattern.confidence * recency;
-            return { key: key, pattern: pattern, score: score };
+        const entries = Array.from(this.patterns.entries()).map(([key, pattern]) => {
+            const ageInDays = (Date.now() - pattern.lastUsed) / (1000 * 60 * 60 * 24);
+            const recency = Math.exp(-0.1 * ageInDays);
+            const score = pattern.confidence * recency;
+            return { key, pattern, score };
         });
-        entries.sort(function (a, b) { return a.score - b.score; });
+        entries.sort((a, b) => a.score - b.score);
         // Remove lowest-scoring patterns
-        var toRemove = entries.slice(0, entries.length - Math.floor(MAX_PATTERNS * 0.8));
-        for (var _i = 0, toRemove_1 = toRemove; _i < toRemove_1.length; _i++) {
-            var key = toRemove_1[_i].key;
-            this.patterns["delete"](key);
+        const toRemove = entries.slice(0, entries.length - Math.floor(MAX_PATTERNS * 0.8));
+        for (const { key } of toRemove) {
+            this.patterns.delete(key);
         }
-    };
+    }
     /**
      * Validate pattern structure
      */
-    SONAOptimizer.prototype.validatePattern = function (pattern) {
+    validatePattern(pattern) {
         if (!pattern || typeof pattern !== 'object')
             return false;
-        var p = pattern;
+        const p = pattern;
         return (Array.isArray(p.keywords) &&
             typeof p.agent === 'string' &&
             typeof p.confidence === 'number' &&
             typeof p.successCount === 'number' &&
             typeof p.failureCount === 'number');
-    };
+    }
     /**
      * Load patterns from disk
      */
-    SONAOptimizer.prototype.loadFromDisk = function () {
+    loadFromDisk() {
         try {
-            var fullPath = join(process.cwd(), this.persistencePath);
+            const fullPath = join(process.cwd(), this.persistencePath);
             if (!existsSync(fullPath)) {
                 return false;
             }
-            var data = readFileSync(fullPath, 'utf-8');
-            var state = JSON.parse(data);
+            const data = readFileSync(fullPath, 'utf-8');
+            const state = JSON.parse(data);
             // Validate version
             if (!state.version || !state.version.startsWith('1.')) {
                 console.error('[SONA] Incompatible state version, starting fresh');
@@ -600,8 +513,7 @@ var SONAOptimizer = /** @class */ (function () {
             }
             // Load patterns
             this.patterns.clear();
-            for (var _i = 0, _a = Object.entries(state.patterns); _i < _a.length; _i++) {
-                var _b = _a[_i], key = _b[0], pattern = _b[1];
+            for (const [key, pattern] of Object.entries(state.patterns)) {
                 if (this.validatePattern(pattern)) {
                     this.patterns.set(key, pattern);
                 }
@@ -616,83 +528,68 @@ var SONAOptimizer = /** @class */ (function () {
             return true;
         }
         catch (err) {
-            console.error("[SONA] Failed to load state: " + err);
+            console.error(`[SONA] Failed to load state: ${err}`);
             return false;
         }
-    };
+    }
     /**
      * Save patterns to disk
      */
-    SONAOptimizer.prototype.saveToDisk = function () {
+    saveToDisk() {
         try {
-            var fullPath = join(process.cwd(), this.persistencePath);
-            var dir = dirname(fullPath);
+            const fullPath = join(process.cwd(), this.persistencePath);
+            const dir = dirname(fullPath);
             // Ensure directory exists
             if (!existsSync(dir)) {
                 mkdirSync(dir, { recursive: true });
             }
-            var state = {
+            const state = {
                 version: PATTERN_VERSION,
                 patterns: this.exportPatterns(),
                 stats: {
                     trajectoriesProcessed: this.trajectoriesProcessed,
                     successfulRoutings: this.successfulRoutings,
                     failedRoutings: this.failedRoutings,
-                    lastUpdate: this.lastUpdate
+                    lastUpdate: this.lastUpdate,
                 },
                 metadata: {
                     createdAt: new Date().toISOString(),
-                    savedAt: new Date().toISOString()
-                }
+                    savedAt: new Date().toISOString(),
+                },
             };
             writeFileSync(fullPath, JSON.stringify(state, null, 2));
             return true;
         }
         catch (err) {
-            console.error("[SONA] Failed to save state: " + err);
+            console.error(`[SONA] Failed to save state: ${err}`);
             return false;
         }
-    };
-    return SONAOptimizer;
-}());
-export { SONAOptimizer };
+    }
+}
 // ============================================================================
 // Singleton Instance
 // ============================================================================
-var sonaOptimizerInstance = null;
-var initializationPromise = null;
+let sonaOptimizerInstance = null;
+let initializationPromise = null;
 /**
  * Get the singleton SONAOptimizer instance
  * Uses lazy initialization to avoid circular imports
  */
-export function getSONAOptimizer() {
-    return __awaiter(this, void 0, Promise, function () {
-        var _this = this;
-        return __generator(this, function (_a) {
-            if (sonaOptimizerInstance) {
-                return [2 /*return*/, sonaOptimizerInstance];
-            }
-            // Prevent multiple concurrent initializations
-            if (initializationPromise) {
-                return [2 /*return*/, initializationPromise];
-            }
-            initializationPromise = (function () { return __awaiter(_this, void 0, void 0, function () {
-                var optimizer;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            optimizer = new SONAOptimizer();
-                            return [4 /*yield*/, optimizer.initialize()];
-                        case 1:
-                            _a.sent();
-                            sonaOptimizerInstance = optimizer;
-                            return [2 /*return*/, optimizer];
-                    }
-                });
-            }); })();
-            return [2 /*return*/, initializationPromise];
-        });
-    });
+export async function getSONAOptimizer() {
+    if (sonaOptimizerInstance) {
+        return sonaOptimizerInstance;
+    }
+    // Prevent multiple concurrent initializations
+    if (initializationPromise) {
+        return initializationPromise;
+    }
+    initializationPromise = (async () => {
+        const optimizer = new SONAOptimizer();
+        await optimizer.initialize();
+        sonaOptimizerInstance = optimizer;
+        return optimizer;
+    })();
+    return initializationPromise;
 }
 /**
  * Reset the singleton instance (for testing)
@@ -707,57 +604,30 @@ export function resetSONAOptimizer() {
 /**
  * Process a trajectory outcome (convenience function)
  */
-export function processTrajectory(outcome) {
-    return __awaiter(this, void 0, Promise, function () {
-        var optimizer;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getSONAOptimizer()];
-                case 1:
-                    optimizer = _a.sent();
-                    return [2 /*return*/, optimizer.processTrajectoryOutcome(outcome)];
-            }
-        });
-    });
+export async function processTrajectory(outcome) {
+    const optimizer = await getSONAOptimizer();
+    return optimizer.processTrajectoryOutcome(outcome);
 }
 /**
  * Get routing suggestion (convenience function)
  */
-export function getSuggestion(task) {
-    return __awaiter(this, void 0, Promise, function () {
-        var optimizer;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getSONAOptimizer()];
-                case 1:
-                    optimizer = _a.sent();
-                    return [2 /*return*/, optimizer.getRoutingSuggestion(task)];
-            }
-        });
-    });
+export async function getSuggestion(task) {
+    const optimizer = await getSONAOptimizer();
+    return optimizer.getRoutingSuggestion(task);
 }
 /**
  * Get SONA statistics (convenience function)
  */
-export function getSONAStats() {
-    return __awaiter(this, void 0, Promise, function () {
-        var optimizer;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getSONAOptimizer()];
-                case 1:
-                    optimizer = _a.sent();
-                    return [2 /*return*/, optimizer.getStats()];
-            }
-        });
-    });
+export async function getSONAStats() {
+    const optimizer = await getSONAOptimizer();
+    return optimizer.getStats();
 }
 export default {
-    SONAOptimizer: SONAOptimizer,
-    getSONAOptimizer: getSONAOptimizer,
-    resetSONAOptimizer: resetSONAOptimizer,
-    processTrajectory: processTrajectory,
-    getSuggestion: getSuggestion,
-    getSONAStats: getSONAStats
+    SONAOptimizer,
+    getSONAOptimizer,
+    resetSONAOptimizer,
+    processTrajectory,
+    getSuggestion,
+    getSONAStats,
 };
 //# sourceMappingURL=sona-optimizer.js.map