@ruvector/ruvllm 0.2.0

package/dist/cjs/engine.js

@@ -0,0 +1,301 @@
+"use strict";
+/**
+ * RuvLLM Engine - Main orchestrator for self-learning LLM
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuvLLM = void 0;
+const native_1 = require("./native");
+/**
+ * Convert JS config to native config format
+ */
+function toNativeConfig(config) {
+    if (!config)
+        return undefined;
+    return {
+        embedding_dim: config.embeddingDim,
+        router_hidden_dim: config.routerHiddenDim,
+        hnsw_m: config.hnswM,
+        hnsw_ef_construction: config.hnswEfConstruction,
+        hnsw_ef_search: config.hnswEfSearch,
+        learning_enabled: config.learningEnabled,
+        quality_threshold: config.qualityThreshold,
+        ewc_lambda: config.ewcLambda,
+    };
+}
+/**
+ * Convert JS generation config to native format
+ */
+function toNativeGenConfig(config) {
+    if (!config)
+        return undefined;
+    return {
+        max_tokens: config.maxTokens,
+        temperature: config.temperature,
+        top_p: config.topP,
+        top_k: config.topK,
+        repetition_penalty: config.repetitionPenalty,
+    };
+}
+/**
+ * RuvLLM - Self-learning LLM orchestrator
+ *
+ * Combines SONA adaptive learning with HNSW memory,
+ * FastGRNN routing, and SIMD-optimized inference.
+ *
+ * @example
+ * ```typescript
+ * import { RuvLLM } from '@ruvector/ruvllm';
+ *
+ * const llm = new RuvLLM({ embeddingDim: 768 });
+ *
+ * // Query with automatic routing
+ * const response = await llm.query('What is machine learning?');
+ * console.log(response.text);
+ *
+ * // Provide feedback for learning
+ * llm.feedback({ requestId: response.requestId, rating: 5 });
+ * ```
+ */
+class RuvLLM {
+    /**
+     * Create a new RuvLLM instance
+     */
+    constructor(config) {
+        this.native = null;
+        // Fallback state for when native module is not available
+        this.fallbackState = {
+            memory: new Map(),
+            nextId: 1,
+            queryCount: 0,
+        };
+        this.config = config ?? {};
+        const mod = (0, native_1.getNativeModule)();
+        if (mod) {
+            try {
+                this.native = new mod.RuvLLMEngine(toNativeConfig(config));
+            }
+            catch {
+                // Silently fall back to JS implementation
+            }
+        }
+    }
+    /**
+     * Query the LLM with automatic routing
+     */
+    query(text, config) {
+        if (this.native) {
+            const result = this.native.query(text, toNativeGenConfig(config));
+            return {
+                text: result.text,
+                confidence: result.confidence,
+                model: result.model,
+                contextSize: result.context_size,
+                latencyMs: result.latency_ms,
+                requestId: result.request_id,
+            };
+        }
+        // Fallback implementation
+        this.fallbackState.queryCount++;
+        return {
+            text: `[Fallback] Response to: ${text.slice(0, 50)}...`,
+            confidence: 0.5,
+            model: 'fallback',
+            contextSize: 512,
+            latencyMs: 1.0,
+            requestId: `fb-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+        };
+    }
+    /**
+     * Generate text with SIMD-optimized inference
+     */
+    generate(prompt, config) {
+        if (this.native) {
+            return this.native.generate(prompt, toNativeGenConfig(config));
+        }
+        // Fallback
+        return `[Fallback] Generated response for: ${prompt.slice(0, 50)}...`;
+    }
+    /**
+     * Get routing decision for a query
+     */
+    route(text) {
+        if (this.native) {
+            const result = this.native.route(text);
+            return {
+                model: result.model,
+                contextSize: result.context_size,
+                temperature: result.temperature,
+                topP: result.top_p,
+                confidence: result.confidence,
+            };
+        }
+        // Fallback
+        return {
+            model: 'M700',
+            contextSize: 512,
+            temperature: 0.7,
+            topP: 0.9,
+            confidence: 0.5,
+        };
+    }
+    /**
+     * Search memory for similar content
+     */
+    searchMemory(text, k = 10) {
+        if (this.native) {
+            const results = this.native.searchMemory(text, k);
+            return results.map(r => ({
+                id: r.id,
+                score: r.score,
+                content: r.content,
+                metadata: JSON.parse(r.metadata || '{}'),
+            }));
+        }
+        // Fallback - simple search
+        return Array.from(this.fallbackState.memory.entries())
+            .slice(0, k)
+            .map(([id, data]) => ({
+            id,
+            score: 0.5,
+            content: data.content,
+            metadata: data.metadata,
+        }));
+    }
+    /**
+     * Add content to memory
+     */
+    addMemory(content, metadata) {
+        if (this.native) {
+            return this.native.addMemory(content, metadata ? JSON.stringify(metadata) : undefined);
+        }
+        // Fallback
+        const id = this.fallbackState.nextId++;
+        this.fallbackState.memory.set(id, {
+            content,
+            embedding: this.embed(content),
+            metadata: metadata ?? {},
+        });
+        return id;
+    }
+    /**
+     * Provide feedback for learning
+     */
+    feedback(fb) {
+        if (this.native) {
+            return this.native.feedback(fb.requestId, fb.rating, fb.correction);
+        }
+        return false;
+    }
+    /**
+     * Get engine statistics
+     */
+    stats() {
+        if (this.native) {
+            const s = this.native.stats();
+            return {
+                totalQueries: s.total_queries,
+                memoryNodes: s.memory_nodes,
+                patternsLearned: s.patterns_learned,
+                avgLatencyMs: s.avg_latency_ms,
+                cacheHitRate: s.cache_hit_rate,
+                routerAccuracy: s.router_accuracy,
+            };
+        }
+        // Fallback
+        return {
+            totalQueries: this.fallbackState.queryCount,
+            memoryNodes: this.fallbackState.memory.size,
+            patternsLearned: 0,
+            avgLatencyMs: 1.0,
+            cacheHitRate: 0.0,
+            routerAccuracy: 0.5,
+        };
+    }
+    /**
+     * Force router learning cycle
+     */
+    forceLearn() {
+        if (this.native) {
+            return this.native.forceLearn();
+        }
+        return 'Learning not available in fallback mode';
+    }
+    /**
+     * Get embedding for text
+     */
+    embed(text) {
+        if (this.native) {
+            return this.native.embed(text);
+        }
+        // Fallback - simple hash-based embedding
+        const dim = this.config.embeddingDim ?? 768;
+        const embedding = new Array(dim).fill(0);
+        for (let i = 0; i < text.length; i++) {
+            const idx = (text.charCodeAt(i) * (i + 1)) % dim;
+            embedding[idx] += 0.1;
+        }
+        // Normalize
+        const norm = Math.sqrt(embedding.reduce((sum, x) => sum + x * x, 0)) || 1;
+        return embedding.map(x => x / norm);
+    }
+    /**
+     * Compute similarity between two texts
+     */
+    similarity(text1, text2) {
+        if (this.native) {
+            return this.native.similarity(text1, text2);
+        }
+        // Fallback - cosine similarity
+        const emb1 = this.embed(text1);
+        const emb2 = this.embed(text2);
+        let dot = 0;
+        let norm1 = 0;
+        let norm2 = 0;
+        for (let i = 0; i < emb1.length; i++) {
+            dot += emb1[i] * emb2[i];
+            norm1 += emb1[i] * emb1[i];
+            norm2 += emb2[i] * emb2[i];
+        }
+        const denom = Math.sqrt(norm1) * Math.sqrt(norm2);
+        const similarity = denom > 0 ? dot / denom : 0;
+        // Clamp to [0, 1] to handle floating point errors
+        return Math.max(0, Math.min(1, similarity));
+    }
+    /**
+     * Check if SIMD is available
+     */
+    hasSimd() {
+        if (this.native) {
+            return this.native.hasSimd();
+        }
+        return false;
+    }
+    /**
+     * Get SIMD capabilities
+     */
+    simdCapabilities() {
+        if (this.native) {
+            return this.native.simdCapabilities();
+        }
+        return ['Scalar (fallback)'];
+    }
+    /**
+     * Batch query multiple prompts
+     */
+    batchQuery(request) {
+        const start = Date.now();
+        const responses = request.queries.map(q => this.query(q, request.config));
+        return {
+            responses,
+            totalLatencyMs: Date.now() - start,
+        };
+    }
+    /**
+     * Check if native module is loaded
+     */
+    isNativeLoaded() {
+        return this.native !== null;
+    }
+}
+exports.RuvLLM = RuvLLM;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"engine.js","sourceRoot":"","sources":["../../src/engine.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAeH,qCAKkB;AAElB;;GAEG;AACH,SAAS,cAAc,CAAC,MAAqB;IAC3C,IAAI,CAAC,MAAM;QAAE,OAAO,SAAS,CAAC;IAE9B,OAAO;QACL,aAAa,EAAE,MAAM,CAAC,YAAY;QAClC,iBAAiB,EAAE,MAAM,CAAC,eAAe;QACzC,MAAM,EAAE,MAAM,CAAC,KAAK;QACpB,oBAAoB,EAAE,MAAM,CAAC,kBAAkB;QAC/C,cAAc,EAAE,MAAM,CAAC,YAAY;QACnC,gBAAgB,EAAE,MAAM,CAAC,eAAe;QACxC,iBAAiB,EAAE,MAAM,CAAC,gBAAgB;QAC1C,UAAU,EAAE,MAAM,CAAC,SAAS;KAC7B,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAS,iBAAiB,CAAC,MAAyB;IAClD,IAAI,CAAC,MAAM;QAAE,OAAO,SAAS,CAAC;IAE9B,OAAO;QACL,UAAU,EAAE,MAAM,CAAC,SAAS;QAC5B,WAAW,EAAE,MAAM,CAAC,WAAW;QAC/B,KAAK,EAAE,MAAM,CAAC,IAAI;QAClB,KAAK,EAAE,MAAM,CAAC,IAAI;QAClB,kBAAkB,EAAE,MAAM,CAAC,iBAAiB;KAC7C,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAa,MAAM;IAWjB;;OAEG;IACH,YAAY,MAAqB;QAbzB,WAAM,GAAwB,IAAI,CAAC;QAG3C,yDAAyD;QACjD,kBAAa,GAAG;YACtB,MAAM,EAAE,IAAI,GAAG,EAAuF;YACtG,MAAM,EAAE,CAAC;YACT,UAAU,EAAE,CAAC;SACd,CAAC;QAMA,IAAI,CAAC,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QAE3B,MAAM,GAAG,GAAG,IAAA,wBAAe,GAAE,CAAC;QAC9B,IAAI,GAAG,EAAE,CAAC;YACR,IAAI,CAAC;gBACH,IAAI,CAAC,MAAM,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC;YAC7D,CAAC;YAAC,MAAM,CAAC;gBACP,0CAA0C;YAC5C,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,IAAY,EAAE,MAAyB;QAC3C,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC;YAClE,OAAO;gBACL,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,UAAU,EAAE,MAAM,CAAC,UAAU;gBAC7B,KAAK,EAAE,MAAM,CAAC,KAAK;gBACnB,WAAW,EAAE,MAAM,CAAC,YAAY;gBAChC,SAAS,EAAE,MAAM,CAAC,UAAU;gBAC5B,SAAS,EAAE,MAAM,CAAC,UAAU;aAC7B,CAAC;QACJ,CAAC;QAED,0BAA0B;QAC1B,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,CAAC;QAChC,OAAO;YACL,IAAI,EAAE,2BAA2B,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK;YACvD,UAAU,EAAE,GAAG;YACf,KAAK,EAAE,UAAU;YACjB,WAAW,EAAE,GAAG;YAChB,SAAS,EAAE,GAAG;YACd,SAAS,EAAE,MAAM,IAAI,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;SACrE,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,QAAQ,CAAC,MAAc,EAAE,MAAyB;QAChD,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC;QACjE,CAAC;QAED,WAAW;QACX,OAAO,sCAAsC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC;IACxE,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,IAAY;QAChB,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACvC,OAAO;gBACL,KAAK,EAAE,MAAM,CAAC,KAAY;gBAC1B,WAAW,EAAE,MAAM,CAAC,YAAY;gBAChC,WAAW,EAAE,MAAM,CAAC,WAAW;gBAC/B,IAAI,EAAE,MAAM,CAAC,KAAK;gBAClB,UAAU,EAAE,MAAM,CAAC,UAAU;aAC9B,CAAC;QACJ,CAAC;QAED,WAAW;QACX,OAAO;YACL,KAAK,EAAE,MAAM;YACb,WAAW,EAAE,GAAG;YAChB,WAAW,EAAE,GAAG;YAChB,IAAI,EAAE,GAAG;YACT,UAAU,EAAE,GAAG;SAChB,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,YAAY,CAAC,IAAY,EAAE,CAAC,GAAG,EAAE;QAC/B,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;YAClD,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;gBACvB,EAAE,EAAE,CAAC,CAAC,EAAE;gBACR,KAAK,EAAE,CAAC,CAAC,KAAK;gBACd,OAAO,EAAE,CAAC,CAAC,OAAO;gBAClB,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,IAAI,IAAI,CAAC;aACzC,CAAC,CAAC,CAAC;QACN,CAAC;QAED,2BAA2B;QAC3B,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;aACnD,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;aACX,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;YACpB,EAAE;YACF,KAAK,EAAE,GAAG;YACV,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,QAAQ,EAAE,IAAI,CAAC,QAAQ;SACxB,CAAC,CAAC,CAAC;IACR,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,OAAe,EAAE,QAAkC;QAC3D,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QACzF,CAAC;QAED,WAAW;QACX,MAAM,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC;QACvC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE;YAChC,OAAO;YACP,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;YAC9B,QAAQ,EAAE,QAAQ,IAAI,EAAE;SACzB,CAAC,CAAC;QACH,OAAO,EAAE,CAAC;IACZ,CAAC;IAED;;OAEG;IACH,QAAQ,CAAC,EAAY;QACnB,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,SAAS,EAAE,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC;QACtE,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;OAEG;IACH,KAAK;QACH,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;YAC9B,OAAO;gBACL,YAAY,EAAE,CAAC,CAAC,aAAa;gBAC7B,WAAW,EAAE,CAAC,CAAC,YAAY;gBAC3B,eAAe,EAAE,CAAC,CAAC,gBAAgB;gBACnC,YAAY,EAAE,CAAC,CAAC,cAAc;gBAC9B,YAAY,EAAE,CAAC,CAAC,cAAc;gBAC9B,cAAc,EAAE,CAAC,CAAC,eAAe;aAClC,CAAC;QACJ,CAAC;QAED,WAAW;QACX,OAAO;YACL,YAAY,EAAE,IAAI,CAAC,aAAa,CAAC,UAAU;YAC3C,WAAW,EAAE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI;YAC3C,eAAe,EAAE,CAAC;YAClB,YAAY,EAAE,GAAG;YACjB,YAAY,EAAE,GAAG;YACjB,cAAc,EAAE,GAAG;SACpB,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,UAAU;QACR,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;QAClC,CAAC;QACD,OAAO,yCAAyC,CAAC;IACnD,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,IAAY;QAChB,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACjC,CAAC;QAED,yCAAyC;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,IAAI,GAAG,CAAC;QAC5C,MAAM,SAAS,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAEzC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACrC,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC;YACjD,SAAS,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC;QACxB,CAAC;QAED,YAAY;QACZ,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC1E,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IACtC,CAAC;IAED;;OAEG;IACH,UAAU,CAAC,KAAa,EAAE,KAAa;QACrC,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QAC9C,CAAC;QAED,+BAA+B;QAC/B,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC/B,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAE/B,IAAI,GAAG,GAAG,CAAC,CAAC;QACZ,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,KAAK,GAAG,CAAC,CAAC;QAEd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACrC,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;YACzB,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;YAC3B,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAC7B,CAAC;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAClD,MAAM,UAAU,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAC/C,kDAAkD;QAClD,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC;IAC9C,CAAC;IAED;;OAEG;IACH,OAAO;QACL,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QAC/B,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;OAEG;IACH,gBAAgB;QACd,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,OAAO,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;QACxC,CAAC;QACD,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAC/B,CAAC;IAED;;OAEG;IACH,UAAU,CAAC,OAA0B;QACnC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACzB,MAAM,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;QAC1E,OAAO;YACL,SAAS;YACT,cAAc,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK;SACnC,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,cAAc;QACZ,OAAO,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC;IAC9B,CAAC;CACF;AA9QD,wBA8QC","sourcesContent":["/**\n * RuvLLM Engine - Main orchestrator for self-learning LLM\n */\n\nimport {\n  RuvLLMConfig,\n  GenerationConfig,\n  QueryResponse,\n  RoutingDecision,\n  MemoryResult,\n  RuvLLMStats,\n  Feedback,\n  Embedding,\n  BatchQueryRequest,\n  BatchQueryResponse,\n} from './types';\n\nimport {\n  getNativeModule,\n  NativeEngine,\n  NativeConfig,\n  NativeGenConfig,\n} from './native';\n\n/**\n * Convert JS config to native config format\n */\nfunction toNativeConfig(config?: RuvLLMConfig): NativeConfig | undefined {\n  if (!config) return undefined;\n\n  return {\n    embedding_dim: config.embeddingDim,\n    router_hidden_dim: config.routerHiddenDim,\n    hnsw_m: config.hnswM,\n    hnsw_ef_construction: config.hnswEfConstruction,\n    hnsw_ef_search: config.hnswEfSearch,\n    learning_enabled: config.learningEnabled,\n    quality_threshold: config.qualityThreshold,\n    ewc_lambda: config.ewcLambda,\n  };\n}\n\n/**\n * Convert JS generation config to native format\n */\nfunction toNativeGenConfig(config?: GenerationConfig): NativeGenConfig | undefined {\n  if (!config) return undefined;\n\n  return {\n    max_tokens: config.maxTokens,\n    temperature: config.temperature,\n    top_p: config.topP,\n    top_k: config.topK,\n    repetition_penalty: config.repetitionPenalty,\n  };\n}\n\n/**\n * RuvLLM - Self-learning LLM orchestrator\n *\n * Combines SONA adaptive learning with HNSW memory,\n * FastGRNN routing, and SIMD-optimized inference.\n *\n * @example\n * ```typescript\n * import { RuvLLM } from '@ruvector/ruvllm';\n *\n * const llm = new RuvLLM({ embeddingDim: 768 });\n *\n * // Query with automatic routing\n * const response = await llm.query('What is machine learning?');\n * console.log(response.text);\n *\n * // Provide feedback for learning\n * llm.feedback({ requestId: response.requestId, rating: 5 });\n * ```\n */\nexport class RuvLLM {\n  private native: NativeEngine | null = null;\n  private config: RuvLLMConfig;\n\n  // Fallback state for when native module is not available\n  private fallbackState = {\n    memory: new Map<number, { content: string; embedding: number[]; metadata: Record<string, unknown> }>(),\n    nextId: 1,\n    queryCount: 0,\n  };\n\n  /**\n   * Create a new RuvLLM instance\n   */\n  constructor(config?: RuvLLMConfig) {\n    this.config = config ?? {};\n\n    const mod = getNativeModule();\n    if (mod) {\n      try {\n        this.native = new mod.RuvLLMEngine(toNativeConfig(config));\n      } catch {\n        // Silently fall back to JS implementation\n      }\n    }\n  }\n\n  /**\n   * Query the LLM with automatic routing\n   */\n  query(text: string, config?: GenerationConfig): QueryResponse {\n    if (this.native) {\n      const result = this.native.query(text, toNativeGenConfig(config));\n      return {\n        text: result.text,\n        confidence: result.confidence,\n        model: result.model,\n        contextSize: result.context_size,\n        latencyMs: result.latency_ms,\n        requestId: result.request_id,\n      };\n    }\n\n    // Fallback implementation\n    this.fallbackState.queryCount++;\n    return {\n      text: `[Fallback] Response to: ${text.slice(0, 50)}...`,\n      confidence: 0.5,\n      model: 'fallback',\n      contextSize: 512,\n      latencyMs: 1.0,\n      requestId: `fb-${Date.now()}-${Math.random().toString(36).slice(2)}`,\n    };\n  }\n\n  /**\n   * Generate text with SIMD-optimized inference\n   */\n  generate(prompt: string, config?: GenerationConfig): string {\n    if (this.native) {\n      return this.native.generate(prompt, toNativeGenConfig(config));\n    }\n\n    // Fallback\n    return `[Fallback] Generated response for: ${prompt.slice(0, 50)}...`;\n  }\n\n  /**\n   * Get routing decision for a query\n   */\n  route(text: string): RoutingDecision {\n    if (this.native) {\n      const result = this.native.route(text);\n      return {\n        model: result.model as any,\n        contextSize: result.context_size,\n        temperature: result.temperature,\n        topP: result.top_p,\n        confidence: result.confidence,\n      };\n    }\n\n    // Fallback\n    return {\n      model: 'M700',\n      contextSize: 512,\n      temperature: 0.7,\n      topP: 0.9,\n      confidence: 0.5,\n    };\n  }\n\n  /**\n   * Search memory for similar content\n   */\n  searchMemory(text: string, k = 10): MemoryResult[] {\n    if (this.native) {\n      const results = this.native.searchMemory(text, k);\n      return results.map(r => ({\n        id: r.id,\n        score: r.score,\n        content: r.content,\n        metadata: JSON.parse(r.metadata || '{}'),\n      }));\n    }\n\n    // Fallback - simple search\n    return Array.from(this.fallbackState.memory.entries())\n      .slice(0, k)\n      .map(([id, data]) => ({\n        id,\n        score: 0.5,\n        content: data.content,\n        metadata: data.metadata,\n      }));\n  }\n\n  /**\n   * Add content to memory\n   */\n  addMemory(content: string, metadata?: Record<string, unknown>): number {\n    if (this.native) {\n      return this.native.addMemory(content, metadata ? JSON.stringify(metadata) : undefined);\n    }\n\n    // Fallback\n    const id = this.fallbackState.nextId++;\n    this.fallbackState.memory.set(id, {\n      content,\n      embedding: this.embed(content),\n      metadata: metadata ?? {},\n    });\n    return id;\n  }\n\n  /**\n   * Provide feedback for learning\n   */\n  feedback(fb: Feedback): boolean {\n    if (this.native) {\n      return this.native.feedback(fb.requestId, fb.rating, fb.correction);\n    }\n    return false;\n  }\n\n  /**\n   * Get engine statistics\n   */\n  stats(): RuvLLMStats {\n    if (this.native) {\n      const s = this.native.stats();\n      return {\n        totalQueries: s.total_queries,\n        memoryNodes: s.memory_nodes,\n        patternsLearned: s.patterns_learned,\n        avgLatencyMs: s.avg_latency_ms,\n        cacheHitRate: s.cache_hit_rate,\n        routerAccuracy: s.router_accuracy,\n      };\n    }\n\n    // Fallback\n    return {\n      totalQueries: this.fallbackState.queryCount,\n      memoryNodes: this.fallbackState.memory.size,\n      patternsLearned: 0,\n      avgLatencyMs: 1.0,\n      cacheHitRate: 0.0,\n      routerAccuracy: 0.5,\n    };\n  }\n\n  /**\n   * Force router learning cycle\n   */\n  forceLearn(): string {\n    if (this.native) {\n      return this.native.forceLearn();\n    }\n    return 'Learning not available in fallback mode';\n  }\n\n  /**\n   * Get embedding for text\n   */\n  embed(text: string): Embedding {\n    if (this.native) {\n      return this.native.embed(text);\n    }\n\n    // Fallback - simple hash-based embedding\n    const dim = this.config.embeddingDim ?? 768;\n    const embedding = new Array(dim).fill(0);\n\n    for (let i = 0; i < text.length; i++) {\n      const idx = (text.charCodeAt(i) * (i + 1)) % dim;\n      embedding[idx] += 0.1;\n    }\n\n    // Normalize\n    const norm = Math.sqrt(embedding.reduce((sum, x) => sum + x * x, 0)) || 1;\n    return embedding.map(x => x / norm);\n  }\n\n  /**\n   * Compute similarity between two texts\n   */\n  similarity(text1: string, text2: string): number {\n    if (this.native) {\n      return this.native.similarity(text1, text2);\n    }\n\n    // Fallback - cosine similarity\n    const emb1 = this.embed(text1);\n    const emb2 = this.embed(text2);\n\n    let dot = 0;\n    let norm1 = 0;\n    let norm2 = 0;\n\n    for (let i = 0; i < emb1.length; i++) {\n      dot += emb1[i] * emb2[i];\n      norm1 += emb1[i] * emb1[i];\n      norm2 += emb2[i] * emb2[i];\n    }\n\n    const denom = Math.sqrt(norm1) * Math.sqrt(norm2);\n    const similarity = denom > 0 ? dot / denom : 0;\n    // Clamp to [0, 1] to handle floating point errors\n    return Math.max(0, Math.min(1, similarity));\n  }\n\n  /**\n   * Check if SIMD is available\n   */\n  hasSimd(): boolean {\n    if (this.native) {\n      return this.native.hasSimd();\n    }\n    return false;\n  }\n\n  /**\n   * Get SIMD capabilities\n   */\n  simdCapabilities(): string[] {\n    if (this.native) {\n      return this.native.simdCapabilities();\n    }\n    return ['Scalar (fallback)'];\n  }\n\n  /**\n   * Batch query multiple prompts\n   */\n  batchQuery(request: BatchQueryRequest): BatchQueryResponse {\n    const start = Date.now();\n    const responses = request.queries.map(q => this.query(q, request.config));\n    return {\n      responses,\n      totalLatencyMs: Date.now() - start,\n    };\n  }\n\n  /**\n   * Check if native module is loaded\n   */\n  isNativeLoaded(): boolean {\n    return this.native !== null;\n  }\n}\n"]}

package/dist/cjs/export.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Export/Serialization for SONA Models
+ *
+ * Support for SafeTensors, JSON, and other export formats.
+ *
+ * @example
+ * ```typescript
+ * import { ModelExporter, SafeTensorsWriter } from '@ruvector/ruvllm';
+ *
+ * // Export model to SafeTensors format
+ * const exporter = new ModelExporter();
+ * const buffer = exporter.toSafeTensors({
+ *   weights: loraAdapter.getWeights(),
+ *   config: loraAdapter.getConfig(),
+ * });
+ *
+ * // Save to file
+ * fs.writeFileSync('model.safetensors', buffer);
+ * ```
+ */
+import { LoRAConfig, LearnedPattern, EwcStats, Embedding, ModelMetadata } from './types';
+import { LoraWeights } from './lora';
+/**
+ * Exportable model data
+ */
+export interface ExportableModel {
+    /** Model metadata */
+    metadata: ModelMetadata;
+    /** LoRA weights (if applicable) */
+    loraWeights?: LoraWeights;
+    /** LoRA config */
+    loraConfig?: LoRAConfig;
+    /** Learned patterns */
+    patterns?: LearnedPattern[];
+    /** EWC statistics */
+    ewcStats?: EwcStats;
+    /** Raw tensors */
+    tensors?: Map<string, Float32Array>;
+}
+/**
+ * SafeTensors Writer
+ *
+ * Writes tensors in SafeTensors format for compatibility with
+ * HuggingFace ecosystem.
+ */
+export declare class SafeTensorsWriter {
+    private tensors;
+    private metadata;
+    /**
+     * Add a tensor
+     */
+    addTensor(name: string, data: Float32Array, shape: number[]): this;
+    /**
+     * Add 2D tensor from number array
+     */
+    add2D(name: string, data: number[][]): this;
+    /**
+     * Add 1D tensor from number array
+     */
+    add1D(name: string, data: number[]): this;
+    /**
+     * Add metadata
+     */
+    addMetadata(key: string, value: string): this;
+    /**
+     * Build SafeTensors buffer
+     */
+    build(): Uint8Array;
+    /**
+     * Clear all tensors and metadata
+     */
+    clear(): void;
+}
+/**
+ * SafeTensors Reader
+ *
+ * Reads tensors from SafeTensors format.
+ */
+export declare class SafeTensorsReader {
+    private buffer;
+    private header;
+    private dataOffset;
+    constructor(buffer: Uint8Array);
+    /**
+     * Get tensor names
+     */
+    getTensorNames(): string[];
+    /**
+     * Get tensor by name
+     */
+    getTensor(name: string): {
+        data: Float32Array;
+        shape: number[];
+    } | null;
+    /**
+     * Get tensor as 2D array
+     */
+    getTensor2D(name: string): number[][] | null;
+    /**
+     * Get tensor as 1D array
+     */
+    getTensor1D(name: string): number[] | null;
+    /**
+     * Get metadata
+     */
+    getMetadata(): Record<string, string>;
+    private parseHeader;
+}
+/**
+ * Model Exporter
+ *
+ * Unified export interface for SONA models.
+ */
+export declare class ModelExporter {
+    /**
+     * Export to SafeTensors format
+     */
+    toSafeTensors(model: ExportableModel): Uint8Array;
+    /**
+     * Export to JSON format
+     */
+    toJSON(model: ExportableModel): string;
+    /**
+     * Export to compact binary format
+     */
+    toBinary(model: ExportableModel): Uint8Array;
+    /**
+     * Export for HuggingFace Hub compatibility
+     */
+    toHuggingFace(model: ExportableModel): {
+        safetensors: Uint8Array;
+        config: string;
+        readme: string;
+    };
+}
+/**
+ * Model Importer
+ *
+ * Import models from various formats.
+ */
+export declare class ModelImporter {
+    /**
+     * Import from SafeTensors format
+     */
+    fromSafeTensors(buffer: Uint8Array): Partial<ExportableModel>;
+    /**
+     * Import from JSON format
+     */
+    fromJSON(json: string): Partial<ExportableModel>;
+    /**
+     * Import from binary format
+     */
+    fromBinary(buffer: Uint8Array): Partial<ExportableModel>;
+}
+/**
+ * Dataset Exporter
+ *
+ * Export training data in various formats.
+ */
+export declare class DatasetExporter {
+    /**
+     * Export to JSONL format (one JSON per line)
+     */
+    toJSONL(data: Array<{
+        input: Embedding;
+        output: Embedding;
+        quality: number;
+    }>): string;
+    /**
+     * Export to CSV format
+     */
+    toCSV(data: Array<{
+        input: Embedding;
+        output: Embedding;
+        quality: number;
+    }>): string;
+    /**
+     * Export patterns for pre-training
+     */
+    toPretrain(patterns: LearnedPattern[]): string;
+}
+//# sourceMappingURL=export.d.ts.map

package/dist/cjs/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../src/export.ts"],"names":[],"mappings":"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"}