kynjal-cli 4.0.0 → 4.0.1

package/dist/src/appliance/ruvllm-bridge.js

@@ -12,101 +12,42 @@
  *
  * @module @claude-flow/cli/appliance/ruvllm-bridge
  */
-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 { readdir, stat } from 'node:fs/promises';
 import { join, extname, basename } from 'node:path';
-var DEFAULT_CONFIG = {
+const DEFAULT_CONFIG = {
     modelsDir: './models', defaultModel: '', maxTokens: 512,
-    temperature: 0.7, contextSize: 4096, kvCachePath: '', verbose: false
+    temperature: 0.7, contextSize: 4096, kvCachePath: '', verbose: false,
 };
 // ── Quantization / parameter heuristics ─────────────────────
-var QUANT_PATTERNS = [
+const QUANT_PATTERNS = [
     [/q4_k_m/i, 'q4_k_m'], [/q4_k_s/i, 'q4_k_s'], [/q4_0/i, 'q4_0'],
     [/q5_k_m/i, 'q5_k_m'], [/q5_0/i, 'q5_0'], [/q8_0/i, 'q8_0'],
     [/f16/i, 'f16'], [/f32/i, 'f32'],
 ];
 function inferQuantization(filename) {
-    for (var _i = 0, QUANT_PATTERNS_1 = QUANT_PATTERNS; _i < QUANT_PATTERNS_1.length; _i++) {
-        var _a = QUANT_PATTERNS_1[_i], re = _a[0], label = _a[1];
+    for (const [re, label] of QUANT_PATTERNS)
         if (re.test(filename))
             return label;
-    }
     return 'unknown';
 }
 function inferParameters(filename) {
-    var m = filename.match(/(\d+)[._-]?b/i);
+    const m = filename.match(/(\d+)[._-]?b/i);
     return m ? m[0].toUpperCase().replace(/[._-]/g, '') : 'unknown';
 }
 // ── Complexity heuristic ────────────────────────────────────
-var HIGH = new Set([
+const HIGH = new Set([
     'architect', 'design', 'refactor', 'security', 'audit', 'complex',
     'analyze', 'distributed', 'concurrent', 'algorithm', 'investigate',
     'optimize', 'debug', 'system', 'integration',
 ]);
-var LOW = new Set([
+const LOW = new Set([
     'rename', 'typo', 'format', 'comment', 'version', 'bump',
     'move', 'copy', 'delete', 'simple', 'config',
 ]);
 function estimateComplexity(desc) {
-    var words = desc.toLowerCase().split(/\s+/);
-    var score = 0.3;
-    for (var _i = 0, words_1 = words; _i < words_1.length; _i++) {
-        var w = words_1[_i];
+    const words = desc.toLowerCase().split(/\s+/);
+    let score = 0.3;
+    for (const w of words) {
         if (HIGH.has(w))
             score += 0.15;
         if (LOW.has(w))
@@ -115,350 +56,219 @@ function estimateComplexity(desc) {
     return Math.max(0, Math.min(1, score + Math.min(0.2, words.length / 200)));
 }
 // ── Bridge ──────────────────────────────────────────────────
-var RuvllmBridge = /** @class */ (function () {
-    function RuvllmBridge(config) {
-        this.models = new Map();
-        this.activeModel = null;
-        this.kvCacheEntries = 0;
-        this.ruvectorCore = null;
-        this.ruvectorRouter = null;
-        this.ruvectorSona = null;
-        this.ggufEngine = null;
+export class RuvllmBridge {
+    config;
+    models = new Map();
+    activeModel = null;
+    kvCacheEntries = 0;
+    ruvectorCore = null;
+    ruvectorRouter = null;
+    ruvectorSona = null;
+    ggufEngine = null;
+    constructor(config) {
         if (!config.modelsDir)
             throw new Error('RuvllmConfig.modelsDir is required');
-        this.config = __assign(__assign({}, DEFAULT_CONFIG), config);
+        this.config = { ...DEFAULT_CONFIG, ...config };
     }
     /** Probe optional @ruvector packages, initialize GGUF engine, and scan modelsDir. */
-    RuvllmBridge.prototype.initialize = function () {
-        return __awaiter(this, void 0, Promise, function () {
-            var _a, _b, _c, GgufEngine, _d, pkgs;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
-                    case 0:
-                        _a = this;
-                        return [4 /*yield*/, this.tryImport('@ruvector/core')];
-                    case 1:
-                        _a.ruvectorCore = _e.sent();
-                        _b = this;
-                        return [4 /*yield*/, this.tryImport('@ruvector/router')];
-                    case 2:
-                        _b.ruvectorRouter = _e.sent();
-                        _c = this;
-                        return [4 /*yield*/, this.tryImport('@ruvector/sona')];
-                    case 3:
-                        _c.ruvectorSona = _e.sent();
-                        _e.label = 4;
-                    case 4:
-                        _e.trys.push([4, 7, , 8]);
-                        return [4 /*yield*/, import('./gguf-engine.js')];
-                    case 5:
-                        GgufEngine = (_e.sent()).GgufEngine;
-                        this.ggufEngine = new GgufEngine({
-                            contextSize: this.config.contextSize,
-                            maxTokens: this.config.maxTokens,
-                            temperature: this.config.temperature,
-                            kvCachePath: this.config.kvCachePath,
-                            verbose: this.config.verbose
-                        });
-                        return [4 /*yield*/, this.ggufEngine.initialize()];
-                    case 6:
-                        _e.sent();
-                        return [3 /*break*/, 8];
-                    case 7:
-                        _d = _e.sent();
-                        return [3 /*break*/, 8];
-                    case 8: return [4 /*yield*/, this.scanModelsDir()];
-                    case 9:
-                        _e.sent();
-                        if (this.config.verbose) {
-                            pkgs = [
-                                this.ruvectorCore && '@ruvector/core',
-                                this.ruvectorRouter && '@ruvector/router',
-                                this.ruvectorSona && '@ruvector/sona',
-                                this.ggufEngine && 'gguf-engine',
-                            ].filter(Boolean);
-                            if (pkgs.length)
-                                console.log("[ruvLLM] Loaded: " + pkgs.join(', '));
-                            console.log("[ruvLLM] " + this.models.size + " model(s) in " + this.config.modelsDir);
-                        }
-                        return [2 /*return*/];
-                }
+    async initialize() {
+        this.ruvectorCore = await this.tryImport('@ruvector/core');
+        this.ruvectorRouter = await this.tryImport('@ruvector/router');
+        this.ruvectorSona = await this.tryImport('@ruvector/sona');
+        // Initialize GGUF engine for local model inference
+        try {
+            const { GgufEngine } = await import('./gguf-engine.js');
+            this.ggufEngine = new GgufEngine({
+                contextSize: this.config.contextSize,
+                maxTokens: this.config.maxTokens,
+                temperature: this.config.temperature,
+                kvCachePath: this.config.kvCachePath,
+                verbose: this.config.verbose,
             });
-        });
-    };
+            await this.ggufEngine.initialize();
+        }
+        catch {
+            // GGUF engine is optional
+        }
+        await this.scanModelsDir();
+        if (this.config.verbose) {
+            const pkgs = [
+                this.ruvectorCore && '@ruvector/core',
+                this.ruvectorRouter && '@ruvector/router',
+                this.ruvectorSona && '@ruvector/sona',
+                this.ggufEngine && 'gguf-engine',
+            ].filter(Boolean);
+            if (pkgs.length)
+                console.log(`[ruvLLM] Loaded: ${pkgs.join(', ')}`);
+            console.log(`[ruvLLM] ${this.models.size} model(s) in ${this.config.modelsDir}`);
+        }
+    }
     /** Return all discovered GGUF models. */
-    RuvllmBridge.prototype.listModels = function () {
-        return __awaiter(this, void 0, Promise, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, Array.from(this.models.values())];
-            });
-        });
-    };
+    async listModels() {
+        return Array.from(this.models.values());
+    }
     /** Load a model into memory (delegates to GGUF engine or @ruvector/core). */
-    RuvllmBridge.prototype.loadModel = function (name) {
-        var _a;
-        return __awaiter(this, void 0, Promise, function () {
-            var info, meta;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        info = this.models.get(name);
-                        if (!info)
-                            throw new Error("Model \"" + name + "\" not found. Available: " + __spreadArray([], this.models.keys(), true).join(', '));
-                        if (!this.ggufEngine) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.ggufEngine.loadModel(info.path)];
-                    case 1:
-                        meta = _b.sent();
-                        if (meta.architecture)
-                            info.parameters = meta.architecture;
-                        if (meta.quantization)
-                            info.quantization = meta.quantization;
-                        return [3 /*break*/, 4];
-                    case 2:
-                        if (!((_a = this.ruvectorCore) === null || _a === void 0 ? void 0 : _a.loadModel)) return [3 /*break*/, 4];
-                        return [4 /*yield*/, this.ruvectorCore.loadModel(info.path, { contextSize: this.config.contextSize })];
-                    case 3:
-                        _b.sent();
-                        _b.label = 4;
-                    case 4:
-                        info.loaded = true;
-                        this.activeModel = name;
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async loadModel(name) {
+        const info = this.models.get(name);
+        if (!info)
+            throw new Error(`Model "${name}" not found. Available: ${[...this.models.keys()].join(', ')}`);
+        // Prefer GGUF engine (parses header, loads via node-llama-cpp if available)
+        if (this.ggufEngine) {
+            const meta = await this.ggufEngine.loadModel(info.path);
+            if (meta.architecture)
+                info.parameters = meta.architecture;
+            if (meta.quantization)
+                info.quantization = meta.quantization;
+        }
+        else if (this.ruvectorCore?.loadModel) {
+            await this.ruvectorCore.loadModel(info.path, { contextSize: this.config.contextSize });
+        }
+        info.loaded = true;
+        this.activeModel = name;
+    }
     /**
      * Generate text from a prompt. Routes through tiers:
      * 1. Agent Booster (trivial transforms, no LLM).
      * 2. Local GGUF model via @ruvector/core.
      * 3. Cloud fallback (empty response -- caller handles upstream).
      */
-    RuvllmBridge.prototype.generate = function (request) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-        return __awaiter(this, void 0, Promise, function () {
-            var start, modelName, booster, info, r, r, err_1;
-            return __generator(this, function (_l) {
-                switch (_l.label) {
-                    case 0:
-                        start = performance.now();
-                        modelName = (_c = (_b = (_a = request.model) !== null && _a !== void 0 ? _a : this.config.defaultModel) !== null && _b !== void 0 ? _b : this.activeModel) !== null && _c !== void 0 ? _c : '';
-                        booster = this.tryAgentBooster(request.prompt);
-                        if (booster !== null) {
-                            return [2 /*return*/, { text: booster, model: 'agent-booster', tokensUsed: 0, latencyMs: performance.now() - start, tier: 1, cached: false }];
-                        }
-                        info = this.models.get(modelName);
-                        if (!(info === null || info === void 0 ? void 0 : info.loaded)) return [3 /*break*/, 7];
-                        _l.label = 1;
-                    case 1:
-                        _l.trys.push([1, 6, , 7]);
-                        if (!this.ggufEngine) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.ggufEngine.generate({
-                                prompt: request.prompt,
-                                maxTokens: (_d = request.maxTokens) !== null && _d !== void 0 ? _d : this.config.maxTokens,
-                                temperature: (_e = request.temperature) !== null && _e !== void 0 ? _e : this.config.temperature,
-                                stopSequences: request.stopSequences
-                            })];
-                    case 2:
-                        r = _l.sent();
-                        return [2 /*return*/, { text: r.text, model: modelName, tokensUsed: r.tokensUsed, latencyMs: performance.now() - start, tier: 2, cached: false }];
-                    case 3:
-                        if (!((_f = this.ruvectorCore) === null || _f === void 0 ? void 0 : _f.generate)) return [3 /*break*/, 5];
-                        return [4 /*yield*/, this.ruvectorCore.generate({
-                                model: info.path, prompt: request.prompt,
-                                maxTokens: (_g = request.maxTokens) !== null && _g !== void 0 ? _g : this.config.maxTokens,
-                                temperature: (_h = request.temperature) !== null && _h !== void 0 ? _h : this.config.temperature,
-                                stopSequences: request.stopSequences
-                            })];
-                    case 4:
-                        r = _l.sent();
-                        return [2 /*return*/, { text: (_j = r.text) !== null && _j !== void 0 ? _j : '', model: modelName, tokensUsed: (_k = r.tokensUsed) !== null && _k !== void 0 ? _k : 0, latencyMs: performance.now() - start, tier: 2, cached: false }];
-                    case 5: return [3 /*break*/, 7];
-                    case 6:
-                        err_1 = _l.sent();
-                        if (this.config.verbose)
-                            console.warn('[ruvLLM] Local generation failed, tier 3 fallback:', err_1);
-                        return [3 /*break*/, 7];
-                    case 7: 
-                    // Tier 3: Cloud fallback
-                    return [2 /*return*/, { text: '', model: 'cloud-fallback', tokensUsed: 0, latencyMs: performance.now() - start, tier: 3, cached: false }];
+    async generate(request) {
+        const start = performance.now();
+        const modelName = request.model ?? this.config.defaultModel ?? this.activeModel ?? '';
+        // Tier 1: Agent Booster
+        const booster = this.tryAgentBooster(request.prompt);
+        if (booster !== null) {
+            return { text: booster, model: 'agent-booster', tokensUsed: 0, latencyMs: performance.now() - start, tier: 1, cached: false };
+        }
+        // Tier 2: Local model (GGUF engine preferred, then @ruvector/core)
+        const info = this.models.get(modelName);
+        if (info?.loaded) {
+            try {
+                if (this.ggufEngine) {
+                    const r = await this.ggufEngine.generate({
+                        prompt: request.prompt,
+                        maxTokens: request.maxTokens ?? this.config.maxTokens,
+                        temperature: request.temperature ?? this.config.temperature,
+                        stopSequences: request.stopSequences,
+                    });
+                    return { text: r.text, model: modelName, tokensUsed: r.tokensUsed, latencyMs: performance.now() - start, tier: 2, cached: false };
                 }
-            });
-        });
-    };
-    /** Route a task description to the optimal tier. Uses @ruvector/router when available. */
-    RuvllmBridge.prototype.routeTask = function (description) {
-        var _a, _b, _c, _d;
-        return __awaiter(this, void 0, Promise, function () {
-            var r, _e, complexity, words;
-            return __generator(this, function (_f) {
-                switch (_f.label) {
-                    case 0:
-                        if (!((_a = this.ruvectorRouter) === null || _a === void 0 ? void 0 : _a.route)) return [3 /*break*/, 4];
-                        _f.label = 1;
-                    case 1:
-                        _f.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.ruvectorRouter.route(description)];
-                    case 2:
-                        r = _f.sent();
-                        return [2 /*return*/, { tier: (_b = r.tier) !== null && _b !== void 0 ? _b : 3, model: (_c = r.model) !== null && _c !== void 0 ? _c : 'cloud', confidence: (_d = r.confidence) !== null && _d !== void 0 ? _d : 0.5 }];
-                    case 3:
-                        _e = _f.sent();
-                        return [3 /*break*/, 4];
-                    case 4:
-                        complexity = estimateComplexity(description);
-                        words = description.split(/\s+/).length;
-                        if (words < 15 && complexity < 0.25)
-                            return [2 /*return*/, { tier: 1, model: 'agent-booster', confidence: 0.9 }];
-                        if (complexity < 0.55 && this.activeModel)
-                            return [2 /*return*/, { tier: 2, model: this.activeModel, confidence: 0.7 }];
-                        return [2 /*return*/, { tier: 3, model: 'cloud', confidence: 0.6 }];
+                else if (this.ruvectorCore?.generate) {
+                    const r = await this.ruvectorCore.generate({
+                        model: info.path, prompt: request.prompt,
+                        maxTokens: request.maxTokens ?? this.config.maxTokens,
+                        temperature: request.temperature ?? this.config.temperature,
+                        stopSequences: request.stopSequences,
+                    });
+                    return { text: r.text ?? '', model: modelName, tokensUsed: r.tokensUsed ?? 0, latencyMs: performance.now() - start, tier: 2, cached: false };
                 }
-            });
-        });
-    };
+            }
+            catch (err) {
+                if (this.config.verbose)
+                    console.warn('[ruvLLM] Local generation failed, tier 3 fallback:', err);
+            }
+        }
+        // Tier 3: Cloud fallback
+        return { text: '', model: 'cloud-fallback', tokensUsed: 0, latencyMs: performance.now() - start, tier: 3, cached: false };
+    }
+    /** Route a task description to the optimal tier. Uses @ruvector/router when available. */
+    async routeTask(description) {
+        if (this.ruvectorRouter?.route) {
+            try {
+                const r = await this.ruvectorRouter.route(description);
+                return { tier: r.tier ?? 3, model: r.model ?? 'cloud', confidence: r.confidence ?? 0.5 };
+            }
+            catch { /* fall through */ }
+        }
+        const complexity = estimateComplexity(description);
+        const words = description.split(/\s+/).length;
+        if (words < 15 && complexity < 0.25)
+            return { tier: 1, model: 'agent-booster', confidence: 0.9 };
+        if (complexity < 0.55 && this.activeModel)
+            return { tier: 2, model: this.activeModel, confidence: 0.7 };
+        return { tier: 3, model: 'cloud', confidence: 0.6 };
+    }
     /** Return current bridge status. */
-    RuvllmBridge.prototype.getStatus = function () {
-        return __awaiter(this, void 0, Promise, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, {
-                        available: this.models.size > 0 || this.ruvectorCore !== null,
-                        ruvectorCore: this.ruvectorCore !== null,
-                        ruvectorRouter: this.ruvectorRouter !== null,
-                        ruvectorSona: this.ruvectorSona !== null,
-                        modelsLoaded: __spreadArray([], this.models.values(), true).filter(function (m) { return m.loaded; }).map(function (m) { return m.name; }),
-                        kvCacheSize: this.kvCacheEntries
-                    }];
-            });
-        });
-    };
+    async getStatus() {
+        return {
+            available: this.models.size > 0 || this.ruvectorCore !== null,
+            ruvectorCore: this.ruvectorCore !== null,
+            ruvectorRouter: this.ruvectorRouter !== null,
+            ruvectorSona: this.ruvectorSona !== null,
+            modelsLoaded: [...this.models.values()].filter((m) => m.loaded).map((m) => m.name),
+            kvCacheSize: this.kvCacheEntries,
+        };
+    }
     /** Persist KV-cache, unload models, and clean up. */
-    RuvllmBridge.prototype.shutdown = function () {
-        var _a, _b;
-        return __awaiter(this, void 0, Promise, function () {
-            var e_1, _i, _c, info;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        if (!this.ggufEngine) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.ggufEngine.shutdown()];
-                    case 1:
-                        _d.sent();
-                        this.ggufEngine = null;
-                        _d.label = 2;
-                    case 2:
-                        if (!(this.config.kvCachePath && ((_a = this.ruvectorCore) === null || _a === void 0 ? void 0 : _a.persistKvCache))) return [3 /*break*/, 6];
-                        _d.label = 3;
-                    case 3:
-                        _d.trys.push([3, 5, , 6]);
-                        return [4 /*yield*/, this.ruvectorCore.persistKvCache(this.config.kvCachePath)];
-                    case 4:
-                        _d.sent();
-                        return [3 /*break*/, 6];
-                    case 5:
-                        e_1 = _d.sent();
-                        if (this.config.verbose)
-                            console.warn('[ruvLLM] KV-cache persist failed:', e_1);
-                        return [3 /*break*/, 6];
-                    case 6:
-                        if (!((_b = this.ruvectorCore) === null || _b === void 0 ? void 0 : _b.unloadAll)) return [3 /*break*/, 8];
-                        return [4 /*yield*/, this.ruvectorCore.unloadAll()];
-                    case 7:
-                        _d.sent();
-                        _d.label = 8;
-                    case 8:
-                        for (_i = 0, _c = this.models.values(); _i < _c.length; _i++) {
-                            info = _c[_i];
-                            info.loaded = false;
-                        }
-                        this.activeModel = null;
-                        this.kvCacheEntries = 0;
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async shutdown() {
+        if (this.ggufEngine) {
+            await this.ggufEngine.shutdown();
+            this.ggufEngine = null;
+        }
+        if (this.config.kvCachePath && this.ruvectorCore?.persistKvCache) {
+            try {
+                await this.ruvectorCore.persistKvCache(this.config.kvCachePath);
+            }
+            catch (e) {
+                if (this.config.verbose)
+                    console.warn('[ruvLLM] KV-cache persist failed:', e);
+            }
+        }
+        if (this.ruvectorCore?.unloadAll)
+            await this.ruvectorCore.unloadAll();
+        for (const info of this.models.values())
+            info.loaded = false;
+        this.activeModel = null;
+        this.kvCacheEntries = 0;
+    }
     // ── Private ───────────────────────────────────────────────
-    RuvllmBridge.prototype.scanModelsDir = function () {
-        return __awaiter(this, void 0, Promise, function () {
-            var entries, _i, entries_1, entry, fullPath, s, name, _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _b.trys.push([0, 6, , 7]);
-                        return [4 /*yield*/, readdir(this.config.modelsDir)];
-                    case 1:
-                        entries = _b.sent();
-                        _i = 0, entries_1 = entries;
-                        _b.label = 2;
-                    case 2:
-                        if (!(_i < entries_1.length)) return [3 /*break*/, 5];
-                        entry = entries_1[_i];
-                        if (extname(entry).toLowerCase() !== '.gguf')
-                            return [3 /*break*/, 4];
-                        fullPath = join(this.config.modelsDir, entry);
-                        return [4 /*yield*/, stat(fullPath)];
-                    case 3:
-                        s = _b.sent();
-                        if (!s.isFile())
-                            return [3 /*break*/, 4];
-                        name = basename(entry, '.gguf');
-                        this.models.set(name, {
-                            name: name,
-                            path: fullPath, format: 'gguf',
-                            quantization: inferQuantization(entry), size: s.size,
-                            parameters: inferParameters(entry), loaded: false
-                        });
-                        _b.label = 4;
-                    case 4:
-                        _i++;
-                        return [3 /*break*/, 2];
-                    case 5: return [3 /*break*/, 7];
-                    case 6:
-                        _a = _b.sent();
-                        return [3 /*break*/, 7];
-                    case 7: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    RuvllmBridge.prototype.tryImport = function (pkg) {
-        return __awaiter(this, void 0, Promise, function () {
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _b.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, import(pkg)];
-                    case 1: return [2 /*return*/, _b.sent()];
-                    case 2:
-                        _a = _b.sent();
-                        return [2 /*return*/, null];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async scanModelsDir() {
+        try {
+            const entries = await readdir(this.config.modelsDir);
+            for (const entry of entries) {
+                if (extname(entry).toLowerCase() !== '.gguf')
+                    continue;
+                const fullPath = join(this.config.modelsDir, entry);
+                const s = await stat(fullPath);
+                if (!s.isFile())
+                    continue;
+                const name = basename(entry, '.gguf');
+                this.models.set(name, {
+                    name, path: fullPath, format: 'gguf',
+                    quantization: inferQuantization(entry), size: s.size,
+                    parameters: inferParameters(entry), loaded: false,
+                });
+            }
+        }
+        catch {
+            // modelsDir may not exist -- tier 1 and tier 3 still work
+        }
+    }
+    async tryImport(pkg) {
+        try {
+            return await import(pkg);
+        }
+        catch {
+            return null;
+        }
+    }
     /** Tier-1 Agent Booster: handle trivial transforms without any LLM. */
-    RuvllmBridge.prototype.tryAgentBooster = function (prompt) {
-        var _a, _b;
-        var t = prompt.trim();
+    tryAgentBooster(prompt) {
+        const t = prompt.trim();
         if (t.length > 200)
             return null;
         if (/^(convert|change)\s+(var|let)\s+to\s+const$/i.test(t)) {
             return 'Use the Edit tool to replace `var`/`let` declarations with `const`.';
         }
         if (/^remove\s+console\.(log|warn|error|debug|info)$/i.test(t)) {
-            var m = (_b = (_a = t.toLowerCase().match(/console\.(\w+)/)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : 'log';
-            return "Use the Edit tool to remove all `console." + m + "` calls.";
+            const m = t.toLowerCase().match(/console\.(\w+)/)?.[1] ?? 'log';
+            return `Use the Edit tool to remove all \`console.${m}\` calls.`;
         }
         return null;
-    };
-    return RuvllmBridge;
-}());
-export { RuvllmBridge };
+    }
+}
 // ── Singleton accessor ──────────────────────────────────────
-var instance = null;
+let instance = null;
 /** Get or create the singleton RuvllmBridge. Config required on first call. */
 export function getRuvllmBridge(config) {
     if (!instance && config)
@@ -470,23 +280,13 @@ export function getRuvllmBridge(config) {
 /** Reset the singleton (useful for tests). */
 export function resetRuvllmBridge() { instance = null; }
 /** Check whether @ruvector/core is importable without loading the bridge. */
-export function isRuvllmAvailable() {
-    return __awaiter(this, void 0, Promise, function () {
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, import('@ruvector/core')];
-                case 1:
-                    _b.sent();
-                    return [2 /*return*/, true];
-                case 2:
-                    _a = _b.sent();
-                    return [2 /*return*/, false];
-                case 3: return [2 /*return*/];
-            }
-        });
-    });
+export async function isRuvllmAvailable() {
+    try {
+        await import('@ruvector/core');
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 //# sourceMappingURL=ruvllm-bridge.js.map