kynjal-cli 4.0.0 → 4.0.1

package/dist/src/ruvector/lora-adapter.js

@@ -17,53 +17,6 @@
  *
  * @module lora-adapter
  */
-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';
 // ============================================================================
@@ -72,23 +25,23 @@ import { dirname, join } from 'path';
 /**
  * Default LoRA rank (determines memory/quality tradeoff)
  */
-export var DEFAULT_RANK = 8;
+export const DEFAULT_RANK = 8;
 /**
  * Input dimension (384 from ONNX MiniLM-L6-v2)
  */
-export var INPUT_DIM = 384;
+export const INPUT_DIM = 384;
 /**
  * Default output dimension (same as input for adapter)
  */
-export var OUTPUT_DIM = 384;
+export const OUTPUT_DIM = 384;
 /**
  * Default alpha scaling factor
  */
-export var DEFAULT_ALPHA = 16;
+export const DEFAULT_ALPHA = 16;
 // ============================================================================
 // Default Configuration
 // ============================================================================
-var DEFAULT_CONFIG = {
+const DEFAULT_CONFIG = {
     rank: DEFAULT_RANK,
     alpha: DEFAULT_ALPHA,
     inputDim: INPUT_DIM,
@@ -97,7 +50,7 @@ var DEFAULT_CONFIG = {
     weightsPath: join(process.cwd(), '.swarm', 'lora-weights.json'),
     enableDropout: true,
     dropoutProb: 0.1,
-    autoSaveInterval: 50
+    autoSaveInterval: 50,
 };
 // ============================================================================
 // LoRA Adapter Class
@@ -105,74 +58,71 @@ var DEFAULT_CONFIG = {
 /**
  * Low-Rank Adaptation module for efficient embedding fine-tuning
  */
-var LoRAAdapter = /** @class */ (function () {
-    function LoRAAdapter(config) {
-        this.totalAdaptations = 0;
-        this.totalUpdates = 0;
-        this.adaptationNormSum = 0;
-        this.lastUpdate = null;
-        this.updatesSinceLastSave = 0;
-        this.config = __assign(__assign({}, DEFAULT_CONFIG), config);
+export class LoRAAdapter {
+    config;
+    weights;
+    totalAdaptations = 0;
+    totalUpdates = 0;
+    adaptationNormSum = 0;
+    lastUpdate = null;
+    updatesSinceLastSave = 0;
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
         this.weights = this.initializeWeights();
     }
     /**
      * Initialize weights with Kaiming/He initialization
      */
-    LoRAAdapter.prototype.initializeWeights = function () {
-        var _a = this.config, rank = _a.rank, inputDim = _a.inputDim, outputDim = _a.outputDim, alpha = _a.alpha;
+    initializeWeights() {
+        const { rank, inputDim, outputDim, alpha } = this.config;
         // A: rank × inputDim, initialized with Kaiming normal
-        var A = new Float32Array(rank * inputDim);
-        var stdA = Math.sqrt(2.0 / inputDim);
-        for (var i = 0; i < A.length; i++) {
+        const A = new Float32Array(rank * inputDim);
+        const stdA = Math.sqrt(2.0 / inputDim);
+        for (let i = 0; i < A.length; i++) {
             A[i] = this.gaussianRandom() * stdA;
         }
         // B: outputDim × rank, initialized to zero (standard LoRA init)
-        var B = new Float32Array(outputDim * rank);
+        const B = new Float32Array(outputDim * rank);
         // B starts at zero so initial adaptation is zero
         return {
-            A: A,
-            B: B,
-            scaling: alpha / rank
+            A,
+            B,
+            scaling: alpha / rank,
         };
-    };
+    }
     /**
      * Box-Muller transform for Gaussian random numbers
      */
-    LoRAAdapter.prototype.gaussianRandom = function () {
-        var u = 0, v = 0;
+    gaussianRandom() {
+        let u = 0, v = 0;
         while (u === 0)
             u = Math.random();
         while (v === 0)
             v = Math.random();
         return Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
-    };
+    }
     /**
      * Initialize adapter and load persisted weights
      */
-    LoRAAdapter.prototype.initialize = function () {
-        return __awaiter(this, void 0, Promise, function () {
-            var loaded;
-            return __generator(this, function (_a) {
-                loaded = this.loadWeights();
-                return [2 /*return*/, { success: true, weightsLoaded: loaded }];
-            });
-        });
-    };
+    async initialize() {
+        const loaded = this.loadWeights();
+        return { success: true, weightsLoaded: loaded };
+    }
     /**
      * Apply LoRA adaptation to an embedding
      * output = input + scaling * (B @ A @ input)
      */
-    LoRAAdapter.prototype.adapt = function (input) {
-        var startTime = performance.now();
-        var _a = this.config, rank = _a.rank, inputDim = _a.inputDim, outputDim = _a.outputDim;
-        var _b = this.weights, A = _b.A, B = _b.B, scaling = _b.scaling;
+    adapt(input) {
+        const startTime = performance.now();
+        const { rank, inputDim, outputDim } = this.config;
+        const { A, B, scaling } = this.weights;
         // Step 1: Compute A @ input (rank-dimensional)
-        var hidden = new Float32Array(rank);
-        for (var r = 0; r < rank; r++) {
-            var sum = 0;
-            var rowOffset = r * inputDim;
+        const hidden = new Float32Array(rank);
+        for (let r = 0; r < rank; r++) {
+            let sum = 0;
+            const rowOffset = r * inputDim;
             // Unroll by 4 for SIMD-friendly access
-            var i = 0;
+            let i = 0;
             for (; i + 3 < inputDim; i += 4) {
                 sum += A[rowOffset + i] * input[i];
                 sum += A[rowOffset + i + 1] * input[i + 1];
@@ -187,19 +137,19 @@ var LoRAAdapter = /** @class */ (function () {
         // Optional dropout (during training inference, skip)
         // In LoRA inference, we don't apply dropout
         // Step 2: Compute B @ hidden (outputDim-dimensional)
-        var delta = new Float32Array(outputDim);
-        for (var o = 0; o < outputDim; o++) {
-            var sum = 0;
-            var rowOffset = o * rank;
-            for (var r = 0; r < rank; r++) {
+        const delta = new Float32Array(outputDim);
+        for (let o = 0; o < outputDim; o++) {
+            let sum = 0;
+            const rowOffset = o * rank;
+            for (let r = 0; r < rank; r++) {
                 sum += B[rowOffset + r] * hidden[r];
             }
             delta[o] = sum * scaling;
         }
         // Step 3: Add adaptation to input
-        var adapted = new Float32Array(outputDim);
-        var adaptationNorm = 0;
-        for (var i = 0; i < outputDim; i++) {
+        const adapted = new Float32Array(outputDim);
+        let adaptationNorm = 0;
+        for (let i = 0; i < outputDim; i++) {
             adapted[i] = input[i] + delta[i];
             adaptationNorm += delta[i] * delta[i];
         }
@@ -207,54 +157,53 @@ var LoRAAdapter = /** @class */ (function () {
         // Update stats
         this.totalAdaptations++;
         this.adaptationNormSum += adaptationNorm;
-        var timeMs = performance.now() - startTime;
-        return { adapted: adapted, adaptationNorm: adaptationNorm, timeMs: timeMs };
-    };
+        const timeMs = performance.now() - startTime;
+        return { adapted, adaptationNorm, timeMs };
+    }
     /**
      * Train the adapter with a gradient signal
      * Uses simplified update: A += lr * hidden^T @ grad, B += lr * grad @ hidden^T
      */
-    LoRAAdapter.prototype.train = function (input, gradOutput, reward) {
-        if (reward === void 0) { reward = 1.0; }
-        var _a = this.config, rank = _a.rank, inputDim = _a.inputDim, outputDim = _a.outputDim, learningRate = _a.learningRate;
-        var _b = this.weights, A = _b.A, B = _b.B, scaling = _b.scaling;
+    train(input, gradOutput, reward = 1.0) {
+        const { rank, inputDim, outputDim, learningRate } = this.config;
+        const { A, B, scaling } = this.weights;
         // Forward pass to get hidden states
-        var hidden = new Float32Array(rank);
-        for (var r = 0; r < rank; r++) {
-            var sum = 0;
-            var rowOffset = r * inputDim;
-            for (var i = 0; i < inputDim; i++) {
+        const hidden = new Float32Array(rank);
+        for (let r = 0; r < rank; r++) {
+            let sum = 0;
+            const rowOffset = r * inputDim;
+            for (let i = 0; i < inputDim; i++) {
                 sum += A[rowOffset + i] * input[i];
             }
             hidden[r] = sum;
         }
         // Compute gradient for B: grad_B = gradOutput @ hidden^T
-        var scaledLr = learningRate * reward * scaling;
-        for (var o = 0; o < outputDim; o++) {
-            var rowOffset = o * rank;
-            for (var r = 0; r < rank; r++) {
+        const scaledLr = learningRate * reward * scaling;
+        for (let o = 0; o < outputDim; o++) {
+            const rowOffset = o * rank;
+            for (let r = 0; r < rank; r++) {
                 B[rowOffset + r] += scaledLr * gradOutput[o] * hidden[r];
             }
         }
         // Compute gradient for hidden: grad_hidden = B^T @ gradOutput
-        var gradHidden = new Float32Array(rank);
-        for (var r = 0; r < rank; r++) {
-            var sum = 0;
-            for (var o = 0; o < outputDim; o++) {
+        const gradHidden = new Float32Array(rank);
+        for (let r = 0; r < rank; r++) {
+            let sum = 0;
+            for (let o = 0; o < outputDim; o++) {
                 sum += B[o * rank + r] * gradOutput[o];
             }
             gradHidden[r] = sum;
         }
         // Compute gradient for A: grad_A = gradHidden @ input^T
-        for (var r = 0; r < rank; r++) {
-            var rowOffset = r * inputDim;
-            for (var i = 0; i < inputDim; i++) {
+        for (let r = 0; r < rank; r++) {
+            const rowOffset = r * inputDim;
+            for (let i = 0; i < inputDim; i++) {
                 A[rowOffset + i] += scaledLr * gradHidden[r] * input[i];
             }
         }
         // Compute loss (L2 norm of gradient)
-        var loss = 0;
-        for (var i = 0; i < gradOutput.length; i++) {
+        let loss = 0;
+        for (let i = 0; i < gradOutput.length; i++) {
             loss += gradOutput[i] * gradOutput[i];
         }
         loss = Math.sqrt(loss);
@@ -267,35 +216,35 @@ var LoRAAdapter = /** @class */ (function () {
             this.saveWeights();
             this.updatesSinceLastSave = 0;
         }
-        return { updated: true, loss: loss };
-    };
+        return { updated: true, loss };
+    }
     /**
      * Merge LoRA weights into base weights (for deployment)
      * Returns: W' = W + scaling * B @ A
      */
-    LoRAAdapter.prototype.merge = function (baseWeights) {
-        var _a = this.config, rank = _a.rank, inputDim = _a.inputDim, outputDim = _a.outputDim;
-        var _b = this.weights, A = _b.A, B = _b.B, scaling = _b.scaling;
+    merge(baseWeights) {
+        const { rank, inputDim, outputDim } = this.config;
+        const { A, B, scaling } = this.weights;
         // Compute BA product
-        var merged = new Float32Array(baseWeights);
-        for (var o = 0; o < outputDim; o++) {
-            for (var i = 0; i < inputDim; i++) {
-                var sum = 0;
-                for (var r = 0; r < rank; r++) {
+        const merged = new Float32Array(baseWeights);
+        for (let o = 0; o < outputDim; o++) {
+            for (let i = 0; i < inputDim; i++) {
+                let sum = 0;
+                for (let r = 0; r < rank; r++) {
                     sum += B[o * rank + r] * A[r * inputDim + i];
                 }
                 merged[o * inputDim + i] += scaling * sum;
             }
         }
         return merged;
-    };
+    }
     /**
      * Get current statistics
      */
-    LoRAAdapter.prototype.getStats = function () {
-        var _a = this.config, rank = _a.rank, inputDim = _a.inputDim, outputDim = _a.outputDim;
-        var originalParams = inputDim * outputDim;
-        var loraParams = rank * (inputDim + outputDim);
+    getStats() {
+        const { rank, inputDim, outputDim } = this.config;
+        const originalParams = inputDim * outputDim;
+        const loraParams = rank * (inputDim + outputDim);
         return {
             totalAdaptations: this.totalAdaptations,
             totalUpdates: this.totalUpdates,
@@ -304,72 +253,72 @@ var LoRAAdapter = /** @class */ (function () {
             avgAdaptationNorm: this.totalAdaptations > 0
                 ? this.adaptationNormSum / this.totalAdaptations
                 : 0,
-            lastUpdate: this.lastUpdate
+            lastUpdate: this.lastUpdate,
         };
-    };
+    }
     /**
      * Reset adapter to initial state
      */
-    LoRAAdapter.prototype.reset = function () {
+    reset() {
         this.weights = this.initializeWeights();
         this.totalAdaptations = 0;
         this.totalUpdates = 0;
         this.adaptationNormSum = 0;
         this.lastUpdate = null;
         this.updatesSinceLastSave = 0;
-    };
+    }
     /**
      * Save weights to disk
      */
-    LoRAAdapter.prototype.saveWeights = function () {
+    saveWeights() {
         try {
-            var dir = dirname(this.config.weightsPath);
+            const dir = dirname(this.config.weightsPath);
             if (!existsSync(dir)) {
                 mkdirSync(dir, { recursive: true });
             }
-            var data = {
+            const data = {
                 version: 1,
                 config: {
                     rank: this.config.rank,
                     alpha: this.config.alpha,
                     inputDim: this.config.inputDim,
-                    outputDim: this.config.outputDim
+                    outputDim: this.config.outputDim,
                 },
                 weights: {
                     A: Array.from(this.weights.A),
                     B: Array.from(this.weights.B),
-                    scaling: this.weights.scaling
+                    scaling: this.weights.scaling,
                 },
                 stats: {
                     totalAdaptations: this.totalAdaptations,
                     totalUpdates: this.totalUpdates,
                     adaptationNormSum: this.adaptationNormSum,
-                    lastUpdate: this.lastUpdate
+                    lastUpdate: this.lastUpdate,
                 },
-                savedAt: new Date().toISOString()
+                savedAt: new Date().toISOString(),
             };
             writeFileSync(this.config.weightsPath, JSON.stringify(data, null, 2));
             return true;
         }
-        catch (_a) {
+        catch {
             return false;
         }
-    };
+    }
     /**
      * Load weights from disk
      */
-    LoRAAdapter.prototype.loadWeights = function () {
+    loadWeights() {
         try {
             if (!existsSync(this.config.weightsPath)) {
                 return false;
             }
-            var content = readFileSync(this.config.weightsPath, 'utf-8');
-            var data = JSON.parse(content);
+            const content = readFileSync(this.config.weightsPath, 'utf-8');
+            const data = JSON.parse(content);
             if (data.version !== 1) {
                 return false;
             }
             // Verify dimensions match
-            var _a = data.config, rank = _a.rank, inputDim = _a.inputDim, outputDim = _a.outputDim;
+            const { rank, inputDim, outputDim } = data.config;
             if (rank !== this.config.rank ||
                 inputDim !== this.config.inputDim ||
                 outputDim !== this.config.outputDim) {
@@ -379,7 +328,7 @@ var LoRAAdapter = /** @class */ (function () {
             this.weights = {
                 A: new Float32Array(data.weights.A),
                 B: new Float32Array(data.weights.B),
-                scaling: data.weights.scaling
+                scaling: data.weights.scaling,
             };
             // Load stats
             this.totalAdaptations = data.stats.totalAdaptations || 0;
@@ -388,14 +337,14 @@ var LoRAAdapter = /** @class */ (function () {
             this.lastUpdate = data.stats.lastUpdate || null;
             return true;
         }
-        catch (_b) {
+        catch {
             return false;
         }
-    };
+    }
     /**
      * Export weights as JSON
      */
-    LoRAAdapter.prototype.exportWeights = function () {
+    exportWeights() {
         return {
             A: Array.from(this.weights.A),
             B: Array.from(this.weights.B),
@@ -404,16 +353,16 @@ var LoRAAdapter = /** @class */ (function () {
                 rank: this.config.rank,
                 alpha: this.config.alpha,
                 inputDim: this.config.inputDim,
-                outputDim: this.config.outputDim
-            }
+                outputDim: this.config.outputDim,
+            },
         };
-    };
+    }
     /**
      * Import weights from JSON
      */
-    LoRAAdapter.prototype.importWeights = function (data) {
+    importWeights(data) {
         try {
-            var _a = this.config, rank = _a.rank, inputDim = _a.inputDim, outputDim = _a.outputDim;
+            const { rank, inputDim, outputDim } = this.config;
             if (data.A.length !== rank * inputDim ||
                 data.B.length !== outputDim * rank) {
                 return false;
@@ -421,52 +370,37 @@ var LoRAAdapter = /** @class */ (function () {
             this.weights = {
                 A: new Float32Array(data.A),
                 B: new Float32Array(data.B),
-                scaling: data.scaling
+                scaling: data.scaling,
             };
             return true;
         }
-        catch (_b) {
+        catch {
             return false;
         }
-    };
-    return LoRAAdapter;
-}());
-export { LoRAAdapter };
+    }
+}
 // ============================================================================
 // Singleton & Factory Functions
 // ============================================================================
-var loraInstance = null;
-var initPromise = null;
+let loraInstance = null;
+let initPromise = null;
 /**
  * Get or create singleton LoRA adapter instance
  */
-export function getLoRAAdapter() {
-    return __awaiter(this, void 0, Promise, function () {
-        var _this = this;
-        return __generator(this, function (_a) {
-            if (loraInstance) {
-                return [2 /*return*/, loraInstance];
-            }
-            if (initPromise) {
-                return [2 /*return*/, initPromise];
-            }
-            initPromise = (function () { return __awaiter(_this, void 0, void 0, function () {
-                var adapter;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            adapter = new LoRAAdapter();
-                            return [4 /*yield*/, adapter.initialize()];
-                        case 1:
-                            _a.sent();
-                            loraInstance = adapter;
-                            return [2 /*return*/, adapter];
-                    }
-                });
-            }); })();
-            return [2 /*return*/, initPromise];
-        });
-    });
+export async function getLoRAAdapter() {
+    if (loraInstance) {
+        return loraInstance;
+    }
+    if (initPromise) {
+        return initPromise;
+    }
+    initPromise = (async () => {
+        const adapter = new LoRAAdapter();
+        await adapter.initialize();
+        loraInstance = adapter;
+        return adapter;
+    })();
+    return initPromise;
 }
 /**
  * Reset singleton instance (for testing)
@@ -487,62 +421,35 @@ export function createLoRAAdapter(config) {
 /**
  * Quick adaptation (convenience function)
  */
-export function adaptEmbedding(input) {
-    return __awaiter(this, void 0, Promise, function () {
-        var adapter;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getLoRAAdapter()];
-                case 1:
-                    adapter = _a.sent();
-                    return [2 /*return*/, adapter.adapt(input)];
-            }
-        });
-    });
+export async function adaptEmbedding(input) {
+    const adapter = await getLoRAAdapter();
+    return adapter.adapt(input);
 }
 /**
  * Quick training (convenience function)
  */
-export function trainLoRA(input, gradOutput, reward) {
-    return __awaiter(this, void 0, Promise, function () {
-        var adapter;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getLoRAAdapter()];
-                case 1:
-                    adapter = _a.sent();
-                    return [2 /*return*/, adapter.train(input, gradOutput, reward)];
-            }
-        });
-    });
+export async function trainLoRA(input, gradOutput, reward) {
+    const adapter = await getLoRAAdapter();
+    return adapter.train(input, gradOutput, reward);
 }
 /**
  * Get LoRA statistics (convenience function)
  */
-export function getLoRAStats() {
-    return __awaiter(this, void 0, Promise, function () {
-        var adapter;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getLoRAAdapter()];
-                case 1:
-                    adapter = _a.sent();
-                    return [2 /*return*/, adapter.getStats()];
-            }
-        });
-    });
+export async function getLoRAStats() {
+    const adapter = await getLoRAAdapter();
+    return adapter.getStats();
 }
 export default {
-    LoRAAdapter: LoRAAdapter,
-    getLoRAAdapter: getLoRAAdapter,
-    resetLoRAAdapter: resetLoRAAdapter,
-    createLoRAAdapter: createLoRAAdapter,
-    adaptEmbedding: adaptEmbedding,
-    trainLoRA: trainLoRA,
-    getLoRAStats: getLoRAStats,
-    DEFAULT_RANK: DEFAULT_RANK,
-    DEFAULT_ALPHA: DEFAULT_ALPHA,
-    INPUT_DIM: INPUT_DIM,
-    OUTPUT_DIM: OUTPUT_DIM
+    LoRAAdapter,
+    getLoRAAdapter,
+    resetLoRAAdapter,
+    createLoRAAdapter,
+    adaptEmbedding,
+    trainLoRA,
+    getLoRAStats,
+    DEFAULT_RANK,
+    DEFAULT_ALPHA,
+    INPUT_DIM,
+    OUTPUT_DIM,
 };
 //# sourceMappingURL=lora-adapter.js.map