kynjal-cli 3.1.3 → 4.0.0

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

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