kynjal-cli 4.0.0 → 4.0.1

package/dist/src/ruvector/model-router.js

@@ -18,88 +18,41 @@
  *
  * @module model-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, join } from 'path';
 /**
  * Model capabilities and characteristics
  */
-export var MODEL_CAPABILITIES = {
+export const MODEL_CAPABILITIES = {
     haiku: {
         maxComplexity: 0.4,
-        costMultiplier: 0.04,
-        speedMultiplier: 3.0,
-        description: 'Fast, cost-effective for simple tasks'
+        costMultiplier: 0.04, // ~25x cheaper than Opus
+        speedMultiplier: 3.0, // ~3x faster than Sonnet
+        description: 'Fast, cost-effective for simple tasks',
     },
     sonnet: {
         maxComplexity: 0.7,
-        costMultiplier: 0.2,
-        speedMultiplier: 1.5,
-        description: 'Balanced capability and cost'
+        costMultiplier: 0.2, // ~5x cheaper than Opus
+        speedMultiplier: 1.5, // ~1.5x faster than Opus
+        description: 'Balanced capability and cost',
     },
     opus: {
         maxComplexity: 1.0,
-        costMultiplier: 1.0,
-        speedMultiplier: 1.0,
-        description: 'Most capable for complex reasoning'
+        costMultiplier: 1.0, // Baseline
+        speedMultiplier: 1.0, // Baseline
+        description: 'Most capable for complex reasoning',
     },
     inherit: {
         maxComplexity: 1.0,
         costMultiplier: 1.0,
         speedMultiplier: 1.0,
-        description: 'Use parent model selection'
-    }
+        description: 'Use parent model selection',
+    },
 };
 /**
  * Complexity indicators for task classification
  */
-export var COMPLEXITY_INDICATORS = {
+export const COMPLEXITY_INDICATORS = {
     high: [
         'architect', 'design', 'refactor', 'optimize', 'security', 'audit',
         'complex', 'analyze', 'investigate', 'debug', 'performance', 'scale',
@@ -112,20 +65,20 @@ export var COMPLEXITY_INDICATORS = {
     low: [
         'simple', 'typo', 'comment', 'format', 'rename', 'move', 'copy',
         'delete', 'documentation', 'readme', 'config', 'version', 'bump',
-    ]
+    ],
 };
 // ============================================================================
 // Default Configuration
 // ============================================================================
-var DEFAULT_CONFIG = {
+const DEFAULT_CONFIG = {
     confidenceThreshold: 0.85,
     maxUncertainty: 0.15,
     enableCircuitBreaker: true,
     circuitBreakerThreshold: 5,
     statePath: '.swarm/model-router-state.json',
-    autoSaveInterval: 1,
+    autoSaveInterval: 1, // Save after every decision for CLI persistence
     enableCostOptimization: true,
-    preferSpeed: true
+    preferSpeed: true,
 };
 // ============================================================================
 // Model Router Implementation
@@ -133,177 +86,171 @@ var DEFAULT_CONFIG = {
 /**
  * Intelligent Model Router using complexity-based routing
  */
-var ModelRouter = /** @class */ (function () {
-    function ModelRouter(config) {
-        if (config === void 0) { config = {}; }
-        this.decisionCount = 0;
-        this.consecutiveFailures = {
-            haiku: 0,
-            sonnet: 0,
-            opus: 0,
-            inherit: 0
-        };
-        this.config = __assign(__assign({}, DEFAULT_CONFIG), config);
+export class ModelRouter {
+    config;
+    state;
+    decisionCount = 0;
+    consecutiveFailures = {
+        haiku: 0,
+        sonnet: 0,
+        opus: 0,
+        inherit: 0,
+    };
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
         this.state = this.loadState();
     }
     /**
      * Route a task to the optimal model
      */
-    ModelRouter.prototype.route = function (task, embedding) {
-        return __awaiter(this, void 0, Promise, function () {
-            var startTime, complexity, scores, adjustedScores, _a, model, confidence, uncertainty, inferenceTimeUs, result;
-            return __generator(this, function (_b) {
-                startTime = performance.now();
-                complexity = this.analyzeComplexity(task, embedding);
-                scores = this.computeModelScores(complexity);
-                adjustedScores = this.applyCircuitBreaker(scores);
-                _a = this.selectModel(adjustedScores, complexity.score), model = _a.model, confidence = _a.confidence, uncertainty = _a.uncertainty;
-                inferenceTimeUs = (performance.now() - startTime) * 1000;
-                result = {
-                    model: model,
-                    confidence: confidence,
-                    uncertainty: uncertainty,
-                    complexity: complexity.score,
-                    reasoning: this.buildReasoning(model, complexity, confidence),
-                    alternatives: Object.entries(adjustedScores)
-                        .filter(function (_a) {
-                        var m = _a[0];
-                        return m !== model;
-                    })
-                        .map(function (_a) {
-                        var m = _a[0], score = _a[1];
-                        return ({ model: m, score: score });
-                    })
-                        .sort(function (a, b) { return b.score - a.score; }),
-                    inferenceTimeUs: inferenceTimeUs,
-                    costMultiplier: MODEL_CAPABILITIES[model].costMultiplier
-                };
-                // Track decision
-                this.trackDecision(task, result);
-                return [2 /*return*/, result];
-            });
-        });
-    };
+    async route(task, embedding) {
+        const startTime = performance.now();
+        // Analyze task complexity
+        const complexity = this.analyzeComplexity(task, embedding);
+        // Compute base model scores
+        const scores = this.computeModelScores(complexity);
+        // Apply circuit breaker adjustments
+        const adjustedScores = this.applyCircuitBreaker(scores);
+        // Select best model
+        const { model, confidence, uncertainty } = this.selectModel(adjustedScores, complexity.score);
+        const inferenceTimeUs = (performance.now() - startTime) * 1000;
+        // Build result
+        const result = {
+            model,
+            confidence,
+            uncertainty,
+            complexity: complexity.score,
+            reasoning: this.buildReasoning(model, complexity, confidence),
+            alternatives: Object.entries(adjustedScores)
+                .filter(([m]) => m !== model)
+                .map(([m, score]) => ({ model: m, score }))
+                .sort((a, b) => b.score - a.score),
+            inferenceTimeUs,
+            costMultiplier: MODEL_CAPABILITIES[model].costMultiplier,
+        };
+        // Track decision
+        this.trackDecision(task, result);
+        return result;
+    }
     /**
      * Analyze task complexity
      */
-    ModelRouter.prototype.analyzeComplexity = function (task, embedding) {
-        var taskLower = task.toLowerCase();
-        var words = taskLower.split(/\s+/);
+    analyzeComplexity(task, embedding) {
+        const taskLower = task.toLowerCase();
+        const words = taskLower.split(/\s+/);
         // Find complexity indicators
-        var indicators = {
-            high: COMPLEXITY_INDICATORS.high.filter(function (ind) { return taskLower.includes(ind); }),
-            medium: COMPLEXITY_INDICATORS.medium.filter(function (ind) { return taskLower.includes(ind); }),
-            low: COMPLEXITY_INDICATORS.low.filter(function (ind) { return taskLower.includes(ind); })
+        const indicators = {
+            high: COMPLEXITY_INDICATORS.high.filter(ind => taskLower.includes(ind)),
+            medium: COMPLEXITY_INDICATORS.medium.filter(ind => taskLower.includes(ind)),
+            low: COMPLEXITY_INDICATORS.low.filter(ind => taskLower.includes(ind)),
         };
         // Compute feature scores
-        var lexicalComplexity = this.computeLexicalComplexity(task);
-        var semanticDepth = this.computeSemanticDepth(indicators, embedding);
-        var taskScope = this.computeTaskScope(task, words);
-        var uncertaintyLevel = this.computeUncertaintyLevel(task);
+        const lexicalComplexity = this.computeLexicalComplexity(task);
+        const semanticDepth = this.computeSemanticDepth(indicators, embedding);
+        const taskScope = this.computeTaskScope(task, words);
+        const uncertaintyLevel = this.computeUncertaintyLevel(task);
         // Weighted combination
-        var score = Math.min(1, Math.max(0, lexicalComplexity * 0.2 +
+        const score = Math.min(1, Math.max(0, lexicalComplexity * 0.2 +
             semanticDepth * 0.35 +
             taskScope * 0.25 +
             uncertaintyLevel * 0.2));
         return {
-            score: score,
-            indicators: indicators,
+            score,
+            indicators,
             features: {
-                lexicalComplexity: lexicalComplexity,
-                semanticDepth: semanticDepth,
-                taskScope: taskScope,
-                uncertaintyLevel: uncertaintyLevel
-            }
+                lexicalComplexity,
+                semanticDepth,
+                taskScope,
+                uncertaintyLevel,
+            },
         };
-    };
+    }
     /**
      * Compute lexical complexity from text features
      */
-    ModelRouter.prototype.computeLexicalComplexity = function (task) {
-        var words = task.split(/\s+/);
-        var avgWordLength = words.reduce(function (sum, w) { return sum + w.length; }, 0) / Math.max(1, words.length);
-        var sentenceLength = words.length;
+    computeLexicalComplexity(task) {
+        const words = task.split(/\s+/);
+        const avgWordLength = words.reduce((sum, w) => sum + w.length, 0) / Math.max(1, words.length);
+        const sentenceLength = words.length;
         // Normalize: longer sentences with longer words = more complex
-        var lengthScore = Math.min(1, sentenceLength / 50);
-        var wordScore = Math.min(1, (avgWordLength - 3) / 7); // 3-10 char words
+        const lengthScore = Math.min(1, sentenceLength / 50);
+        const wordScore = Math.min(1, (avgWordLength - 3) / 7); // 3-10 char words
         return lengthScore * 0.4 + wordScore * 0.6;
-    };
+    }
     /**
      * Compute semantic depth from indicators and embedding
      */
-    ModelRouter.prototype.computeSemanticDepth = function (indicators, embedding) {
+    computeSemanticDepth(indicators, embedding) {
         // Weight by indicator presence
-        var highWeight = indicators.high.length * 0.3;
-        var mediumWeight = indicators.medium.length * 0.15;
-        var lowWeight = indicators.low.length * -0.1;
-        var baseScore = Math.min(1, Math.max(0, 0.3 + highWeight + mediumWeight + lowWeight));
+        const highWeight = indicators.high.length * 0.3;
+        const mediumWeight = indicators.medium.length * 0.15;
+        const lowWeight = indicators.low.length * -0.1;
+        let baseScore = Math.min(1, Math.max(0, 0.3 + highWeight + mediumWeight + lowWeight));
         // Boost with embedding variance if available
         if (embedding && embedding.length > 0) {
-            var mean_1 = embedding.reduce(function (a, b) { return a + b; }, 0) / embedding.length;
-            var variance = embedding.reduce(function (sum, v) { return sum + Math.pow(v - mean_1, 2); }, 0) / embedding.length;
+            const mean = embedding.reduce((a, b) => a + b, 0) / embedding.length;
+            const variance = embedding.reduce((sum, v) => sum + Math.pow(v - mean, 2), 0) / embedding.length;
             // Higher variance suggests more nuanced semantics
             baseScore = baseScore * 0.7 + Math.min(1, variance * 10) * 0.3;
         }
         return baseScore;
-    };
+    }
     /**
      * Compute task scope from content analysis
      */
-    ModelRouter.prototype.computeTaskScope = function (task, words) {
+    computeTaskScope(task, words) {
         // Multi-file indicators
-        var multiFilePatterns = [
+        const multiFilePatterns = [
             /multiple files?/i, /across.*modules?/i, /refactor.*codebase/i,
             /all.*files/i, /entire.*project/i, /system.*wide/i,
         ];
-        var hasMultiFile = multiFilePatterns.some(function (p) { return p.test(task); }) ? 0.4 : 0;
+        const hasMultiFile = multiFilePatterns.some(p => p.test(task)) ? 0.4 : 0;
         // Code generation indicators
-        var codeGenPatterns = [
+        const codeGenPatterns = [
             /implement/i, /create.*feature/i, /build.*system/i,
             /design.*api/i, /write.*tests/i, /add.*functionality/i,
         ];
-        var hasCodeGen = codeGenPatterns.some(function (p) { return p.test(task); }) ? 0.3 : 0;
+        const hasCodeGen = codeGenPatterns.some(p => p.test(task)) ? 0.3 : 0;
         // Word count contribution
-        var wordCountScore = Math.min(0.3, words.length / 100);
+        const wordCountScore = Math.min(0.3, words.length / 100);
         return hasMultiFile + hasCodeGen + wordCountScore;
-    };
+    }
     /**
      * Compute uncertainty level from task phrasing
      */
-    ModelRouter.prototype.computeUncertaintyLevel = function (task) {
-        var uncertainPatterns = [
+    computeUncertaintyLevel(task) {
+        const uncertainPatterns = [
             /not sure/i, /might/i, /maybe/i, /possibly/i, /investigate/i,
             /figure out/i, /unclear/i, /unknown/i, /debug/i, /strange/i,
             /weird/i, /issue/i, /problem/i, /error/i, /bug/i,
         ];
-        var matchCount = uncertainPatterns.filter(function (p) { return p.test(task); }).length;
+        const matchCount = uncertainPatterns.filter(p => p.test(task)).length;
         return Math.min(1, matchCount * 0.2);
-    };
+    }
     /**
      * Compute scores for each model
      */
-    ModelRouter.prototype.computeModelScores = function (complexity) {
-        var score = complexity.score;
+    computeModelScores(complexity) {
+        const { score } = complexity;
         // Base scoring: inverse relationship with complexity
         // Low complexity → haiku scores high
         // High complexity → opus scores high
         return {
-            haiku: Math.max(0, 1 - score * 2),
-            sonnet: 1 - Math.abs(score - 0.5) * 2,
-            opus: Math.min(1, score * 1.5),
-            inherit: 0.1
+            haiku: Math.max(0, 1 - score * 2), // Drops off quickly as complexity rises
+            sonnet: 1 - Math.abs(score - 0.5) * 2, // Peaks at medium complexity
+            opus: Math.min(1, score * 1.5), // Rises with complexity
+            inherit: 0.1, // Low baseline unless explicitly needed
         };
-    };
+    }
     /**
      * Apply circuit breaker adjustments
      */
-    ModelRouter.prototype.applyCircuitBreaker = function (scores) {
+    applyCircuitBreaker(scores) {
         if (!this.config.enableCircuitBreaker) {
             return scores;
         }
-        var adjusted = __assign({}, scores);
-        for (var _i = 0, _a = Object.keys(adjusted); _i < _a.length; _i++) {
-            var model = _a[_i];
+        const adjusted = { ...scores };
+        for (const model of Object.keys(adjusted)) {
             if (this.consecutiveFailures[model] >= this.config.circuitBreakerThreshold) {
                 // Circuit is open - heavily penalize this model
                 adjusted[model] *= 0.1;
@@ -314,59 +261,56 @@ var ModelRouter = /** @class */ (function () {
             }
         }
         return adjusted;
-    };
+    }
     /**
      * Select the best model from scores
      */
-    ModelRouter.prototype.selectModel = function (scores, complexityScore) {
+    selectModel(scores, complexityScore) {
         // Get sorted models by score
-        var sorted = Object.entries(scores)
-            .filter(function (_a) {
-            var m = _a[0];
-            return m !== 'inherit';
-        })
-            .sort(function (a, b) { return b[1] - a[1]; });
-        var _a = sorted[0], bestModel = _a[0], bestScore = _a[1];
-        var _b = sorted[1] || ['sonnet', 0], secondModel = _b[0], secondScore = _b[1];
+        const sorted = Object.entries(scores)
+            .filter(([m]) => m !== 'inherit')
+            .sort((a, b) => b[1] - a[1]);
+        const [bestModel, bestScore] = sorted[0];
+        const [secondModel, secondScore] = sorted[1] || ['sonnet', 0];
         // Confidence is how much better the best is vs second
-        var confidence = bestScore > 0 ? Math.min(1, bestScore / (bestScore + secondScore + 0.01)) : 0.5;
+        const confidence = bestScore > 0 ? Math.min(1, bestScore / (bestScore + secondScore + 0.01)) : 0.5;
         // Uncertainty based on score spread and complexity
-        var scoreSpread = bestScore - secondScore;
-        var uncertainty = Math.max(0, 1 - scoreSpread - confidence * 0.5);
+        const scoreSpread = bestScore - secondScore;
+        const uncertainty = Math.max(0, 1 - scoreSpread - confidence * 0.5);
         // Escalate if uncertainty is too high
-        var model = bestModel;
+        let model = bestModel;
         if (uncertainty > this.config.maxUncertainty && bestModel !== 'opus') {
             // Escalate to more capable model
             model = bestModel === 'haiku' ? 'sonnet' : 'opus';
         }
-        return { model: model, confidence: confidence, uncertainty: uncertainty };
-    };
+        return { model, confidence, uncertainty };
+    }
     /**
      * Build human-readable reasoning
      */
-    ModelRouter.prototype.buildReasoning = function (model, complexity, confidence) {
-        var parts = [];
-        parts.push("Complexity: " + (complexity.score * 100).toFixed(0) + "%");
+    buildReasoning(model, complexity, confidence) {
+        const parts = [];
+        parts.push(`Complexity: ${(complexity.score * 100).toFixed(0)}%`);
         if (complexity.indicators.high.length > 0) {
-            parts.push("High-complexity indicators: " + complexity.indicators.high.join(', '));
+            parts.push(`High-complexity indicators: ${complexity.indicators.high.join(', ')}`);
         }
-        parts.push("Confidence: " + (confidence * 100).toFixed(0) + "%");
-        parts.push("Model: " + model + " - " + MODEL_CAPABILITIES[model].description);
+        parts.push(`Confidence: ${(confidence * 100).toFixed(0)}%`);
+        parts.push(`Model: ${model} - ${MODEL_CAPABILITIES[model].description}`);
         if (this.config.enableCostOptimization) {
-            parts.push("Cost: " + MODEL_CAPABILITIES[model].costMultiplier + "x baseline");
+            parts.push(`Cost: ${MODEL_CAPABILITIES[model].costMultiplier}x baseline`);
         }
         return parts.join(' | ');
-    };
+    }
     /**
      * Track routing decision for learning
      */
-    ModelRouter.prototype.trackDecision = function (task, result) {
+    trackDecision(task, result) {
         this.decisionCount++;
         this.state.totalDecisions++;
         this.state.modelDistribution[result.model] =
             (this.state.modelDistribution[result.model] || 0) + 1;
         // Update running averages
-        var n = this.state.totalDecisions;
+        const n = this.state.totalDecisions;
         this.state.avgComplexity =
             (this.state.avgComplexity * (n - 1) + result.complexity) / n;
         this.state.avgConfidence =
@@ -375,11 +319,11 @@ var ModelRouter = /** @class */ (function () {
         if (this.decisionCount % this.config.autoSaveInterval === 0) {
             this.saveState();
         }
-    };
+    }
     /**
      * Record outcome for learning
      */
-    ModelRouter.prototype.recordOutcome = function (task, model, outcome) {
+    recordOutcome(task, model, outcome) {
         // Update circuit breaker state
         if (outcome === 'failure') {
             this.consecutiveFailures[model]++;
@@ -390,10 +334,10 @@ var ModelRouter = /** @class */ (function () {
         // Track in history
         this.state.learningHistory.push({
             task: task.slice(0, 100),
-            model: model,
+            model,
             complexity: this.state.avgComplexity,
-            outcome: outcome,
-            timestamp: new Date().toISOString()
+            outcome,
+            timestamp: new Date().toISOString(),
         });
         // Keep history bounded
         if (this.state.learningHistory.length > 100) {
@@ -403,66 +347,66 @@ var ModelRouter = /** @class */ (function () {
             this.state.circuitBreakerTrips++;
         }
         this.saveState();
-    };
+    }
     /**
      * Get router statistics
      */
-    ModelRouter.prototype.getStats = function () {
+    getStats() {
         return {
             totalDecisions: this.state.totalDecisions,
-            modelDistribution: __assign({}, this.state.modelDistribution),
+            modelDistribution: { ...this.state.modelDistribution },
             avgComplexity: this.state.avgComplexity,
             avgConfidence: this.state.avgConfidence,
             circuitBreakerTrips: this.state.circuitBreakerTrips,
-            consecutiveFailures: __assign({}, this.consecutiveFailures)
+            consecutiveFailures: { ...this.consecutiveFailures },
         };
-    };
+    }
     /**
      * Load state from disk
      */
-    ModelRouter.prototype.loadState = function () {
-        var defaultState = {
+    loadState() {
+        const defaultState = {
             totalDecisions: 0,
             modelDistribution: { haiku: 0, sonnet: 0, opus: 0, inherit: 0 },
             avgComplexity: 0.5,
             avgConfidence: 0.8,
             circuitBreakerTrips: 0,
             lastUpdated: new Date().toISOString(),
-            learningHistory: []
+            learningHistory: [],
         };
         try {
-            var fullPath = join(process.cwd(), this.config.statePath);
+            const fullPath = join(process.cwd(), this.config.statePath);
             if (existsSync(fullPath)) {
-                var data = readFileSync(fullPath, 'utf-8');
-                return __assign(__assign({}, defaultState), JSON.parse(data));
+                const data = readFileSync(fullPath, 'utf-8');
+                return { ...defaultState, ...JSON.parse(data) };
             }
         }
-        catch (_a) {
+        catch {
             // Ignore load errors
         }
         return defaultState;
-    };
+    }
     /**
      * Save state to disk
      */
-    ModelRouter.prototype.saveState = function () {
+    saveState() {
         try {
-            var fullPath = join(process.cwd(), this.config.statePath);
-            var dir = dirname(fullPath);
+            const fullPath = join(process.cwd(), this.config.statePath);
+            const dir = dirname(fullPath);
             if (!existsSync(dir)) {
                 mkdirSync(dir, { recursive: true });
             }
             this.state.lastUpdated = new Date().toISOString();
             writeFileSync(fullPath, JSON.stringify(this.state, null, 2));
         }
-        catch (_a) {
+        catch {
             // Ignore save errors in non-critical scenarios
         }
-    };
+    }
     /**
      * Reset router state
      */
-    ModelRouter.prototype.reset = function () {
+    reset() {
         this.state = {
             totalDecisions: 0,
             modelDistribution: { haiku: 0, sonnet: 0, opus: 0, inherit: 0 },
@@ -470,19 +414,17 @@ var ModelRouter = /** @class */ (function () {
             avgConfidence: 0.8,
             circuitBreakerTrips: 0,
             lastUpdated: new Date().toISOString(),
-            learningHistory: []
+            learningHistory: [],
         };
         this.consecutiveFailures = { haiku: 0, sonnet: 0, opus: 0, inherit: 0 };
         this.decisionCount = 0;
         this.saveState();
-    };
-    return ModelRouter;
-}());
-export { ModelRouter };
+    }
+}
 // ============================================================================
 // Singleton & Factory Functions
 // ============================================================================
-var modelRouterInstance = null;
+let modelRouterInstance = null;
 /**
  * Get or create the singleton ModelRouter instance
  */
@@ -510,52 +452,37 @@ export function createModelRouter(config) {
 /**
  * Quick route function for common use case
  */
-export function routeToModel(task) {
-    return __awaiter(this, void 0, Promise, function () {
-        var router, result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    router = getModelRouter();
-                    return [4 /*yield*/, router.route(task)];
-                case 1:
-                    result = _a.sent();
-                    return [2 /*return*/, result.model];
-            }
-        });
-    });
+export async function routeToModel(task) {
+    const router = getModelRouter();
+    const result = await router.route(task);
+    return result.model;
 }
 /**
  * Route with full result
  */
-export function routeToModelFull(task, embedding) {
-    return __awaiter(this, void 0, Promise, function () {
-        var router;
-        return __generator(this, function (_a) {
-            router = getModelRouter();
-            return [2 /*return*/, router.route(task, embedding)];
-        });
-    });
+export async function routeToModelFull(task, embedding) {
+    const router = getModelRouter();
+    return router.route(task, embedding);
 }
 /**
  * Analyze task complexity without routing
  */
 export function analyzeTaskComplexity(task) {
-    var router = getModelRouter();
+    const router = getModelRouter();
     return router.analyzeComplexity(task, undefined);
 }
 /**
  * Get model router statistics
  */
 export function getModelRouterStats() {
-    var router = getModelRouter();
+    const router = getModelRouter();
     return router.getStats();
 }
 /**
  * Record routing outcome for learning
  */
 export function recordModelOutcome(task, model, outcome) {
-    var router = getModelRouter();
+    const router = getModelRouter();
     router.recordOutcome(task, model, outcome);
 }
 //# sourceMappingURL=model-router.js.map