kynjal-cli 4.0.0 → 4.0.1

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

@@ -8,53 +8,6 @@
  *
  * @module enhanced-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, readFileSync } from 'fs';
 import { extname } from 'path';
 import { getModelRouter } from './model-router.js';
@@ -64,7 +17,7 @@ import { getModelRouter } from './model-router.js';
 /**
  * Pattern definitions for Agent Booster intent detection
  */
-var INTENT_PATTERNS = {
+const INTENT_PATTERNS = {
     'var-to-const': {
         patterns: [
             /convert\s+var\s+to\s+const/i,
@@ -75,7 +28,7 @@ var INTENT_PATTERNS = {
             /use\s+const\s+instead\s+of\s+var/i,
         ],
         weight: 1.0,
-        description: 'Convert var declarations to const/let'
+        description: 'Convert var declarations to const/let',
     },
     'add-types': {
         patterns: [
@@ -86,7 +39,7 @@ var INTENT_PATTERNS = {
             /annotate\s+with\s+types?/i,
         ],
         weight: 0.9,
-        description: 'Add TypeScript type annotations'
+        description: 'Add TypeScript type annotations',
     },
     'add-error-handling': {
         patterns: [
@@ -96,8 +49,8 @@ var INTENT_PATTERNS = {
             /handle\s+errors?/i,
             /add\s+exception\s+handling/i,
         ],
-        weight: 0.7,
-        description: 'Wrap code in try/catch blocks'
+        weight: 0.7, // Lower weight - often needs more context
+        description: 'Wrap code in try/catch blocks',
     },
     'async-await': {
         patterns: [
@@ -111,7 +64,7 @@ var INTENT_PATTERNS = {
             /callbacks?\s+to\s+async/i,
         ],
         weight: 0.8,
-        description: 'Convert callbacks/promises to async/await'
+        description: 'Convert callbacks/promises to async/await',
     },
     'add-logging': {
         patterns: [
@@ -122,7 +75,7 @@ var INTENT_PATTERNS = {
             /add\s+trace\s+logging/i,
         ],
         weight: 0.85,
-        description: 'Add console.log or logging statements'
+        description: 'Add console.log or logging statements',
     },
     'remove-console': {
         patterns: [
@@ -136,13 +89,13 @@ var INTENT_PATTERNS = {
             /delete\s+(?:all\s+)?console\.log/i,
         ],
         weight: 0.95,
-        description: 'Remove console.* calls'
-    }
+        description: 'Remove console.* calls',
+    },
 };
 /**
  * File path extraction patterns
  */
-var FILE_PATH_PATTERNS = [
+const FILE_PATH_PATTERNS = [
     /(?:in|from|to|file|path)\s+[`"']?([a-zA-Z0-9_./\\-]+\.[a-zA-Z]+)[`"']?/i,
     /[`"']([a-zA-Z0-9_./\\-]+\.[a-zA-Z]+)[`"']/,
     /(\S+\.[tj]sx?)\b/i,
@@ -155,7 +108,7 @@ var FILE_PATH_PATTERNS = [
  * High-complexity keywords that indicate Tier 3 (Opus) routing
  * These tasks require deep reasoning and architectural understanding
  */
-var TIER3_KEYWORDS = [
+const TIER3_KEYWORDS = [
     // Architecture & Design
     /\b(microservices?|architecture|system\s+design|distributed)\b/i,
     /\b(design|architect|plan)\s+(a|an|the|complex)\b/i,
@@ -181,7 +134,7 @@ var TIER3_KEYWORDS = [
     /\b(performance\s+critical|low\s+latency|high\s+throughput)\b/i,
     /\b(memory\s+optimi|cache\s+strateg|concurrent)\b/i,
 ];
-var LANGUAGE_MAP = {
+const LANGUAGE_MAP = {
     '.js': 'javascript',
     '.jsx': 'javascript',
     '.ts': 'typescript',
@@ -195,7 +148,7 @@ var LANGUAGE_MAP = {
     '.swift': 'swift',
     '.c': 'c',
     '.cpp': 'cpp',
-    '.h': 'c'
+    '.h': 'c',
 };
 // ============================================================================
 // Enhanced Model Router Implementation
@@ -208,44 +161,52 @@ var LANGUAGE_MAP = {
  * - Tier 2: Haiku for low complexity tasks
  * - Tier 3: Sonnet/Opus for complex reasoning tasks
  */
-var EnhancedModelRouter = /** @class */ (function () {
-    function EnhancedModelRouter(config) {
-        this.config = __assign({ agentBoosterEnabled: true, agentBoosterConfidenceThreshold: 0.7, enabledIntents: [
+export class EnhancedModelRouter {
+    config;
+    tinyDancerRouter;
+    constructor(config) {
+        this.config = {
+            agentBoosterEnabled: true,
+            agentBoosterConfidenceThreshold: 0.7,
+            enabledIntents: [
                 'var-to-const',
                 'add-types',
                 'add-error-handling',
                 'async-await',
                 'add-logging',
                 'remove-console',
-            ], complexityThresholds: {
+            ],
+            complexityThresholds: {
                 haiku: 0.3,
                 sonnet: 0.6,
-                opus: 1.0
-            }, preferCost: false, preferQuality: false }, config);
+                opus: 1.0,
+            },
+            preferCost: false,
+            preferQuality: false,
+            ...config,
+        };
         this.tinyDancerRouter = getModelRouter();
     }
     /**
      * Detect code editing intent from task description
      */
-    EnhancedModelRouter.prototype.detectIntent = function (task) {
-        var taskLower = task.toLowerCase();
-        var bestIntent = null;
-        var bestScore = 0;
-        for (var _i = 0, _a = Object.entries(INTENT_PATTERNS); _i < _a.length; _i++) {
-            var _b = _a[_i], intentType = _b[0], config = _b[1];
+    detectIntent(task) {
+        const taskLower = task.toLowerCase();
+        let bestIntent = null;
+        let bestScore = 0;
+        for (const [intentType, config] of Object.entries(INTENT_PATTERNS)) {
             if (!this.config.enabledIntents.includes(intentType)) {
                 continue;
             }
-            for (var _c = 0, _d = config.patterns; _c < _d.length; _c++) {
-                var pattern = _d[_c];
+            for (const pattern of config.patterns) {
                 if (pattern.test(taskLower)) {
-                    var score = config.weight;
+                    const score = config.weight;
                     if (score > bestScore) {
                         bestScore = score;
                         bestIntent = {
                             type: intentType,
                             confidence: score,
-                            description: config.description
+                            description: config.description,
                         };
                     }
                 }
@@ -253,7 +214,7 @@ var EnhancedModelRouter = /** @class */ (function () {
         }
         // Extract file path if intent found
         if (bestIntent) {
-            var filePath = this.extractFilePath(task);
+            const filePath = this.extractFilePath(task);
             if (filePath) {
                 bestIntent.filePath = filePath;
                 bestIntent.language = this.detectLanguage(filePath);
@@ -264,297 +225,265 @@ var EnhancedModelRouter = /** @class */ (function () {
             }
         }
         return bestIntent;
-    };
+    }
     /**
      * Extract file path from task description
      */
-    EnhancedModelRouter.prototype.extractFilePath = function (task) {
-        for (var _i = 0, FILE_PATH_PATTERNS_1 = FILE_PATH_PATTERNS; _i < FILE_PATH_PATTERNS_1.length; _i++) {
-            var pattern = FILE_PATH_PATTERNS_1[_i];
-            var match = task.match(pattern);
+    extractFilePath(task) {
+        for (const pattern of FILE_PATH_PATTERNS) {
+            const match = task.match(pattern);
             if (match && match[1]) {
                 return match[1];
             }
         }
         return null;
-    };
+    }
     /**
      * Detect language from file extension
      */
-    EnhancedModelRouter.prototype.detectLanguage = function (filePath) {
-        var ext = extname(filePath).toLowerCase();
+    detectLanguage(filePath) {
+        const ext = extname(filePath).toLowerCase();
         return LANGUAGE_MAP[ext] || 'javascript';
-    };
+    }
     /**
      * Check if task contains Tier 3 (Opus) keywords
      */
-    EnhancedModelRouter.prototype.containsTier3Keywords = function (task) {
-        var count = 0;
-        for (var _i = 0, TIER3_KEYWORDS_1 = TIER3_KEYWORDS; _i < TIER3_KEYWORDS_1.length; _i++) {
-            var pattern = TIER3_KEYWORDS_1[_i];
+    containsTier3Keywords(task) {
+        let count = 0;
+        for (const pattern of TIER3_KEYWORDS) {
             if (pattern.test(task)) {
                 count++;
             }
         }
-        return { matches: count > 0, count: count };
-    };
+        return { matches: count > 0, count };
+    }
     /**
      * Route a task to the optimal tier and handler
      */
-    EnhancedModelRouter.prototype.route = function (task, context) {
-        return __awaiter(this, void 0, Promise, function () {
-            var intent, tier3Check, astComplexity, targetFile, _a, tinyDancerResult, finalComplexity, _b, haiku, sonnet;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        // Step 1: Try Agent Booster intent detection
-                        if (this.config.agentBoosterEnabled) {
-                            intent = this.detectIntent(task);
-                            if (intent && intent.confidence >= this.config.agentBoosterConfidenceThreshold) {
-                                return [2 /*return*/, {
-                                        tier: 1,
-                                        handler: 'agent-booster',
-                                        confidence: intent.confidence,
-                                        reasoning: "Agent Booster can handle \"" + intent.type + "\" with " + (intent.confidence * 100).toFixed(0) + "% confidence",
-                                        agentBoosterIntent: intent,
-                                        canSkipLLM: true,
-                                        estimatedLatencyMs: 1,
-                                        estimatedCost: 0
-                                    }];
-                            }
-                        }
-                        tier3Check = this.containsTier3Keywords(task);
-                        if (tier3Check.matches && tier3Check.count >= 2) {
-                            // Strong signal for Opus - multiple complex keywords
-                            return [2 /*return*/, {
-                                    tier: 3,
-                                    handler: 'opus',
-                                    model: 'opus',
-                                    confidence: Math.min(0.95, 0.7 + tier3Check.count * 0.1),
-                                    complexity: 0.8 + tier3Check.count * 0.05,
-                                    reasoning: "High complexity task (" + tier3Check.count + " architectural keywords) - using opus",
-                                    canSkipLLM: false,
-                                    estimatedLatencyMs: 5000,
-                                    estimatedCost: 0.015
-                                }];
-                        }
-                        targetFile = (context === null || context === void 0 ? void 0 : context.filePath) || this.extractFilePath(task);
-                        if (!(targetFile && existsSync(targetFile))) return [3 /*break*/, 4];
-                        _c.label = 1;
-                    case 1:
-                        _c.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.analyzeASTComplexity(targetFile)];
-                    case 2:
-                        astComplexity = _c.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        _a = _c.sent();
-                        return [3 /*break*/, 4];
-                    case 4: return [4 /*yield*/, this.tinyDancerRouter.route(task)];
-                    case 5:
-                        tinyDancerResult = _c.sent();
-                        finalComplexity = astComplexity !== undefined
-                            ? (astComplexity + tinyDancerResult.complexity) / 2
-                            : tinyDancerResult.complexity;
-                        // Boost complexity if tier3 keywords found (even just one)
-                        if (tier3Check.matches) {
-                            finalComplexity = Math.min(1.0, finalComplexity + 0.25);
-                        }
-                        _b = this.config.complexityThresholds, haiku = _b.haiku, sonnet = _b.sonnet;
-                        if (finalComplexity < haiku) {
-                            return [2 /*return*/, {
-                                    tier: 2,
-                                    handler: 'haiku',
-                                    model: 'haiku',
-                                    confidence: tinyDancerResult.confidence,
-                                    complexity: finalComplexity,
-                                    reasoning: "Low complexity (" + (finalComplexity * 100).toFixed(0) + "%) - using haiku",
-                                    canSkipLLM: false,
-                                    estimatedLatencyMs: 500,
-                                    estimatedCost: 0.0002
-                                }];
-                        }
-                        if (finalComplexity < sonnet) {
-                            return [2 /*return*/, {
-                                    tier: 2,
-                                    handler: 'sonnet',
-                                    model: 'sonnet',
-                                    confidence: tinyDancerResult.confidence,
-                                    complexity: finalComplexity,
-                                    reasoning: "Medium complexity (" + (finalComplexity * 100).toFixed(0) + "%) - using sonnet",
-                                    canSkipLLM: false,
-                                    estimatedLatencyMs: 2000,
-                                    estimatedCost: 0.003
-                                }];
-                        }
-                        return [2 /*return*/, {
-                                tier: 3,
-                                handler: 'opus',
-                                model: 'opus',
-                                confidence: tinyDancerResult.confidence,
-                                complexity: finalComplexity,
-                                reasoning: "High complexity (" + (finalComplexity * 100).toFixed(0) + "%) - using opus",
-                                canSkipLLM: false,
-                                estimatedLatencyMs: 5000,
-                                estimatedCost: 0.015
-                            }];
-                }
-            });
-        });
-    };
+    async route(task, context) {
+        // Step 1: Try Agent Booster intent detection
+        if (this.config.agentBoosterEnabled) {
+            const intent = this.detectIntent(task);
+            if (intent && intent.confidence >= this.config.agentBoosterConfidenceThreshold) {
+                return {
+                    tier: 1,
+                    handler: 'agent-booster',
+                    confidence: intent.confidence,
+                    reasoning: `Agent Booster can handle "${intent.type}" with ${(intent.confidence * 100).toFixed(0)}% confidence`,
+                    agentBoosterIntent: intent,
+                    canSkipLLM: true,
+                    estimatedLatencyMs: 1,
+                    estimatedCost: 0,
+                };
+            }
+        }
+        // Step 2: Check for Tier 3 keywords (architecture, security, distributed)
+        const tier3Check = this.containsTier3Keywords(task);
+        if (tier3Check.matches && tier3Check.count >= 2) {
+            // Strong signal for Opus - multiple complex keywords
+            return {
+                tier: 3,
+                handler: 'opus',
+                model: 'opus',
+                confidence: Math.min(0.95, 0.7 + tier3Check.count * 0.1),
+                complexity: 0.8 + tier3Check.count * 0.05,
+                reasoning: `High complexity task (${tier3Check.count} architectural keywords) - using opus`,
+                canSkipLLM: false,
+                estimatedLatencyMs: 5000,
+                estimatedCost: 0.015,
+            };
+        }
+        // Step 3: AST complexity analysis (if file path provided)
+        let astComplexity;
+        const targetFile = context?.filePath || this.extractFilePath(task);
+        if (targetFile && existsSync(targetFile)) {
+            try {
+                astComplexity = await this.analyzeASTComplexity(targetFile);
+            }
+            catch {
+                // AST analysis not available, continue with text-based routing
+            }
+        }
+        // Step 4: Text-based complexity + tiny-dancer routing
+        const tinyDancerResult = await this.tinyDancerRouter.route(task);
+        // Step 5: Combine AST complexity with tiny-dancer result
+        // Also boost if single tier3 keyword found
+        let finalComplexity = astComplexity !== undefined
+            ? (astComplexity + tinyDancerResult.complexity) / 2
+            : tinyDancerResult.complexity;
+        // Boost complexity if tier3 keywords found (even just one)
+        if (tier3Check.matches) {
+            finalComplexity = Math.min(1.0, finalComplexity + 0.25);
+        }
+        // Step 6: Determine tier based on complexity
+        const { haiku, sonnet } = this.config.complexityThresholds;
+        if (finalComplexity < haiku) {
+            return {
+                tier: 2,
+                handler: 'haiku',
+                model: 'haiku',
+                confidence: tinyDancerResult.confidence,
+                complexity: finalComplexity,
+                reasoning: `Low complexity (${(finalComplexity * 100).toFixed(0)}%) - using haiku`,
+                canSkipLLM: false,
+                estimatedLatencyMs: 500,
+                estimatedCost: 0.0002,
+            };
+        }
+        if (finalComplexity < sonnet) {
+            return {
+                tier: 2,
+                handler: 'sonnet',
+                model: 'sonnet',
+                confidence: tinyDancerResult.confidence,
+                complexity: finalComplexity,
+                reasoning: `Medium complexity (${(finalComplexity * 100).toFixed(0)}%) - using sonnet`,
+                canSkipLLM: false,
+                estimatedLatencyMs: 2000,
+                estimatedCost: 0.003,
+            };
+        }
+        return {
+            tier: 3,
+            handler: 'opus',
+            model: 'opus',
+            confidence: tinyDancerResult.confidence,
+            complexity: finalComplexity,
+            reasoning: `High complexity (${(finalComplexity * 100).toFixed(0)}%) - using opus`,
+            canSkipLLM: false,
+            estimatedLatencyMs: 5000,
+            estimatedCost: 0.015,
+        };
+    }
     /**
      * Analyze AST complexity of a file
      * Returns normalized complexity score (0-1)
      */
-    EnhancedModelRouter.prototype.analyzeASTComplexity = function (filePath) {
-        return __awaiter(this, void 0, Promise, function () {
-            var content, lines, complexity, avgIndent, controlFlowCount, functionCount;
-            return __generator(this, function (_a) {
-                try {
-                    content = readFileSync(filePath, 'utf-8');
-                    lines = content.split('\n');
-                    complexity = 0;
-                    // Line count contribution
-                    complexity += Math.min(0.3, lines.length / 1000);
-                    avgIndent = lines
-                        .filter(function (l) { return l.trim().length > 0; })
-                        .map(function (l) { var _a; return ((_a = l.match(/^(\s*)/)) === null || _a === void 0 ? void 0 : _a[1].length) || 0; })
-                        .reduce(function (sum, indent) { return sum + indent; }, 0) / Math.max(1, lines.length);
-                    complexity += Math.min(0.2, avgIndent / 20);
-                    controlFlowCount = (content.match(/\b(if|else|for|while|switch|case|try|catch|async|await)\b/g) || []).length;
-                    complexity += Math.min(0.3, controlFlowCount / 100);
-                    functionCount = (content.match(/\b(function|class|=>)\b/g) || []).length;
-                    complexity += Math.min(0.2, functionCount / 50);
-                    return [2 /*return*/, Math.min(1, complexity)];
-                }
-                catch (_b) {
-                    return [2 /*return*/, 0.5]; // Default to medium complexity on error
-                }
-                return [2 /*return*/];
-            });
-        });
-    };
+    async analyzeASTComplexity(filePath) {
+        try {
+            const content = readFileSync(filePath, 'utf-8');
+            const lines = content.split('\n');
+            // Simple heuristics for complexity
+            let complexity = 0;
+            // Line count contribution
+            complexity += Math.min(0.3, lines.length / 1000);
+            // Nesting depth estimation (count indentation)
+            const avgIndent = lines
+                .filter((l) => l.trim().length > 0)
+                .map((l) => l.match(/^(\s*)/)?.[1].length || 0)
+                .reduce((sum, indent) => sum + indent, 0) / Math.max(1, lines.length);
+            complexity += Math.min(0.2, avgIndent / 20);
+            // Control flow complexity (count keywords)
+            const controlFlowCount = (content.match(/\b(if|else|for|while|switch|case|try|catch|async|await)\b/g) || []).length;
+            complexity += Math.min(0.3, controlFlowCount / 100);
+            // Function/class count
+            const functionCount = (content.match(/\b(function|class|=>)\b/g) || []).length;
+            complexity += Math.min(0.2, functionCount / 50);
+            return Math.min(1, complexity);
+        }
+        catch {
+            return 0.5; // Default to medium complexity on error
+        }
+    }
     /**
      * Execute task using the appropriate tier
      * Returns the result and routing information
      */
-    EnhancedModelRouter.prototype.execute = function (task, context) {
-        return __awaiter(this, void 0, Promise, function () {
-            var routeResult, abResult;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.route(task, context)];
-                    case 1:
-                        routeResult = _a.sent();
-                        if (!(routeResult.tier === 1 && routeResult.agentBoosterIntent)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.tryAgentBooster(routeResult.agentBoosterIntent, context)];
-                    case 2:
-                        abResult = _a.sent();
-                        if (abResult.success) {
-                            return [2 /*return*/, {
-                                    result: { applied: true, confidence: abResult.confidence },
-                                    routeResult: routeResult
-                                }];
-                        }
-                        // Agent Booster failed, fall back to LLM
-                        routeResult.tier = 2;
-                        routeResult.handler = 'sonnet';
-                        routeResult.model = 'sonnet';
-                        routeResult.canSkipLLM = false;
-                        routeResult.reasoning += ' (Agent Booster fallback to LLM)';
-                        _a.label = 3;
-                    case 3: 
-                    // Return routing result - caller handles LLM invocation
-                    return [2 /*return*/, { result: routeResult.reasoning, routeResult: routeResult }];
-                }
-            });
-        });
-    };
+    async execute(task, context) {
+        const routeResult = await this.route(task, context);
+        if (routeResult.tier === 1 && routeResult.agentBoosterIntent) {
+            // Try to execute with Agent Booster
+            const abResult = await this.tryAgentBooster(routeResult.agentBoosterIntent, context);
+            if (abResult.success) {
+                return {
+                    result: { applied: true, confidence: abResult.confidence },
+                    routeResult,
+                };
+            }
+            // Agent Booster failed, fall back to LLM
+            routeResult.tier = 2;
+            routeResult.handler = 'sonnet';
+            routeResult.model = 'sonnet';
+            routeResult.canSkipLLM = false;
+            routeResult.reasoning += ' (Agent Booster fallback to LLM)';
+        }
+        // Return routing result - caller handles LLM invocation
+        return { result: routeResult.reasoning, routeResult };
+    }
     /**
      * Try to apply edit using Agent Booster
      */
-    EnhancedModelRouter.prototype.tryAgentBooster = function (intent, context) {
-        var _a, _b;
-        return __awaiter(this, void 0, Promise, function () {
-            var filePath, originalCode, intentToInstruction, instruction, language, boosterModule, result_1, SAFE_LANGUAGES, safeLang, execSync, cmd, result, parsed, _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        _d.trys.push([0, 5, , 6]);
-                        filePath = intent.filePath || (context === null || context === void 0 ? void 0 : context.filePath);
-                        if (!filePath || !existsSync(filePath)) {
-                            return [2 /*return*/, { success: false, confidence: 0 }];
-                        }
-                        originalCode = (context === null || context === void 0 ? void 0 : context.originalCode) || readFileSync(filePath, 'utf-8');
-                        intentToInstruction = {
-                            'var-to-const': 'Convert all var declarations to const',
-                            'add-types': 'Add TypeScript type annotations',
-                            'add-error-handling': 'Wrap in try/catch blocks',
-                            'async-await': 'Convert to async/await',
-                            'add-logging': 'Add console.log statements',
-                            'remove-console': 'Remove all console.* statements'
-                        };
-                        instruction = intentToInstruction[intent.type];
-                        language = intent.language || 'javascript';
-                        return [4 /*yield*/, import('agentic-flow/agent-booster')["catch"](function () { return import(/* @vite-ignore */ 'agentic-flow/intelligence/agent-booster-enhanced'); })["catch"](function () { return null; })];
-                    case 1:
-                        boosterModule = _d.sent();
-                        if (!(boosterModule === null || boosterModule === void 0 ? void 0 : boosterModule.enhancedApply)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, boosterModule.enhancedApply({
-                                code: originalCode,
-                                edit: instruction,
-                                language: language
-                            })];
-                    case 2:
-                        result_1 = _d.sent();
-                        if (result_1 && result_1.confidence >= this.config.agentBoosterConfidenceThreshold) {
-                            return [2 /*return*/, { success: true, confidence: result_1.confidence, output: result_1.output }];
-                        }
-                        return [2 /*return*/, { success: false, confidence: (_a = result_1 === null || result_1 === void 0 ? void 0 : result_1.confidence) !== null && _a !== void 0 ? _a : 0 }];
-                    case 3:
-                        SAFE_LANGUAGES = ['javascript', 'typescript', 'python', 'rust', 'go', 'java', 'c', 'cpp', 'ruby', 'swift', 'kotlin'];
-                        safeLang = SAFE_LANGUAGES.includes(language) ? language : 'javascript';
-                        return [4 /*yield*/, import('child_process')];
-                    case 4:
-                        execSync = (_d.sent()).execSync;
-                        cmd = "npx --yes agent-booster@0.2.2 apply --language " + safeLang;
-                        result = execSync(cmd, {
-                            encoding: 'utf-8',
-                            input: JSON.stringify({ code: originalCode, edit: instruction }),
-                            maxBuffer: 10 * 1024 * 1024,
-                            timeout: 5000,
-                            stdio: ['pipe', 'pipe', 'pipe']
-                        });
-                        parsed = JSON.parse(result);
-                        if (parsed.confidence >= this.config.agentBoosterConfidenceThreshold) {
-                            return [2 /*return*/, { success: true, confidence: parsed.confidence, output: parsed.output }];
-                        }
-                        return [2 /*return*/, { success: false, confidence: (_b = parsed.confidence) !== null && _b !== void 0 ? _b : 0 }];
-                    case 5:
-                        _c = _d.sent();
-                        // Agent Booster not available or failed
-                        return [2 /*return*/, { success: false, confidence: 0 }];
-                    case 6: return [2 /*return*/];
+    async tryAgentBooster(intent, context) {
+        try {
+            const filePath = intent.filePath || context?.filePath;
+            if (!filePath || !existsSync(filePath)) {
+                return { success: false, confidence: 0 };
+            }
+            const originalCode = context?.originalCode || readFileSync(filePath, 'utf-8');
+            const intentToInstruction = {
+                'var-to-const': 'Convert all var declarations to const',
+                'add-types': 'Add TypeScript type annotations',
+                'add-error-handling': 'Wrap in try/catch blocks',
+                'async-await': 'Convert to async/await',
+                'add-logging': 'Add console.log statements',
+                'remove-console': 'Remove all console.* statements',
+            };
+            const instruction = intentToInstruction[intent.type];
+            const language = intent.language || 'javascript';
+            // Try local agentic-flow agent-booster (v3 — no npx needed)
+            // Note: agent-booster export declared but dist missing in alpha.1; use intelligence path as fallback
+            const boosterModule = await import('agentic-flow/agent-booster')
+                .catch(() => import(/* @vite-ignore */ 'agentic-flow/intelligence/agent-booster-enhanced'))
+                .catch(() => null);
+            if (boosterModule?.enhancedApply) {
+                const result = await boosterModule.enhancedApply({
+                    code: originalCode,
+                    edit: instruction,
+                    language,
+                });
+                if (result && result.confidence >= this.config.agentBoosterConfidenceThreshold) {
+                    return { success: true, confidence: result.confidence, output: result.output };
                 }
+                return { success: false, confidence: result?.confidence ?? 0 };
+            }
+            // Fallback: shell out to npx agent-booster
+            // Sanitize language to prevent command injection (whitelist only)
+            const SAFE_LANGUAGES = ['javascript', 'typescript', 'python', 'rust', 'go', 'java', 'c', 'cpp', 'ruby', 'swift', 'kotlin'];
+            const safeLang = SAFE_LANGUAGES.includes(language) ? language : 'javascript';
+            const { execSync } = await import('child_process');
+            const cmd = `npx --yes agent-booster@0.2.2 apply --language ${safeLang}`;
+            const result = execSync(cmd, {
+                encoding: 'utf-8',
+                input: JSON.stringify({ code: originalCode, edit: instruction }),
+                maxBuffer: 10 * 1024 * 1024,
+                timeout: 5000,
+                stdio: ['pipe', 'pipe', 'pipe'],
             });
-        });
-    };
+            const parsed = JSON.parse(result);
+            if (parsed.confidence >= this.config.agentBoosterConfidenceThreshold) {
+                return { success: true, confidence: parsed.confidence, output: parsed.output };
+            }
+            return { success: false, confidence: parsed.confidence ?? 0 };
+        }
+        catch {
+            // Agent Booster not available or failed
+            return { success: false, confidence: 0 };
+        }
+    }
     /**
      * Get router statistics
      */
-    EnhancedModelRouter.prototype.getStats = function () {
+    getStats() {
         return {
-            config: __assign({}, this.config),
-            tinyDancerStats: this.tinyDancerRouter.getStats()
+            config: { ...this.config },
+            tinyDancerStats: this.tinyDancerRouter.getStats(),
         };
-    };
-    return EnhancedModelRouter;
-}());
-export { EnhancedModelRouter };
+    }
+}
 // ============================================================================
 // Singleton & Factory Functions
 // ============================================================================
-var enhancedRouterInstance = null;
+let enhancedRouterInstance = null;
 /**
  * Get or create the singleton EnhancedModelRouter instance
  */
@@ -582,23 +511,18 @@ export function createEnhancedModelRouter(config) {
 /**
  * Quick route function with enhanced routing
  */
-export function enhancedRouteToModel(task, context) {
-    return __awaiter(this, void 0, Promise, function () {
-        var router;
-        return __generator(this, function (_a) {
-            router = getEnhancedModelRouter();
-            return [2 /*return*/, router.route(task, context)];
-        });
-    });
+export async function enhancedRouteToModel(task, context) {
+    const router = getEnhancedModelRouter();
+    return router.route(task, context);
 }
 /**
  * Detect if a task can be handled by Agent Booster
  */
 export function canUseAgentBooster(task) {
-    var router = getEnhancedModelRouter();
-    var intent = router.detectIntent(task);
+    const router = getEnhancedModelRouter();
+    const intent = router.detectIntent(task);
     if (intent && intent.confidence >= 0.7) {
-        return { canUse: true, intent: intent };
+        return { canUse: true, intent };
     }
     return { canUse: false };
 }