ruvector 0.1.37 → 0.1.39

package/dist/core/gnn-wrapper.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * GNN Wrapper - Safe wrapper around @ruvector/gnn with automatic array conversion
+ *
+ * This wrapper handles the array type conversion automatically, allowing users
+ * to pass either regular arrays or Float32Arrays.
+ *
+ * The native @ruvector/gnn requires Float32Array for maximum performance.
+ * This wrapper converts any input type to Float32Array automatically.
+ *
+ * Performance Tips:
+ * - Pass Float32Array directly for zero-copy performance
+ * - Use toFloat32Array/toFloat32ArrayBatch for pre-conversion
+ * - Avoid repeated conversions in hot paths
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TensorCompress = exports.RuvectorLayer = void 0;
+exports.toFloat32Array = toFloat32Array;
+exports.toFloat32ArrayBatch = toFloat32ArrayBatch;
+exports.differentiableSearch = differentiableSearch;
+exports.hierarchicalForward = hierarchicalForward;
+exports.getCompressionLevel = getCompressionLevel;
+exports.isGnnAvailable = isGnnAvailable;
+// Lazy load to avoid import errors if not installed
+let gnnModule = null;
+let loadError = null;
+function getGnnModule() {
+    if (gnnModule)
+        return gnnModule;
+    if (loadError)
+        throw loadError;
+    try {
+        gnnModule = require('@ruvector/gnn');
+        return gnnModule;
+    }
+    catch (e) {
+        loadError = new Error(`@ruvector/gnn is not installed or failed to load: ${e.message}\n` +
+            `Install with: npm install @ruvector/gnn`);
+        throw loadError;
+    }
+}
+/**
+ * Convert any array-like input to Float32Array (native requires Float32Array)
+ * Optimized paths:
+ * - Float32Array: zero-copy return
+ * - Float64Array: efficient typed array copy
+ * - Array: direct Float32Array construction
+ */
+function toFloat32Array(input) {
+    if (input instanceof Float32Array)
+        return input;
+    if (input instanceof Float64Array)
+        return new Float32Array(input);
+    if (Array.isArray(input))
+        return new Float32Array(input);
+    return new Float32Array(Array.from(input));
+}
+/**
+ * Convert array of arrays to array of Float32Arrays
+ */
+function toFloat32ArrayBatch(input) {
+    const result = new Array(input.length);
+    for (let i = 0; i < input.length; i++) {
+        result[i] = toFloat32Array(input[i]);
+    }
+    return result;
+}
+/**
+ * Differentiable search using soft attention mechanism
+ *
+ * This wrapper automatically converts Float32Array inputs to regular arrays.
+ *
+ * @param query - Query vector (array or Float32Array)
+ * @param candidates - List of candidate vectors (arrays or Float32Arrays)
+ * @param k - Number of top results to return
+ * @param temperature - Temperature for softmax (lower = sharper, higher = smoother)
+ * @returns Search result with indices and soft weights
+ *
+ * @example
+ * ```typescript
+ * import { differentiableSearch } from 'ruvector/core/gnn-wrapper';
+ *
+ * // Works with regular arrays (auto-converted to Float32Array)
+ * const result1 = differentiableSearch([1, 0, 0], [[1, 0, 0], [0, 1, 0]], 2, 1.0);
+ *
+ * // For best performance, use Float32Array directly (zero-copy)
+ * const query = new Float32Array([1, 0, 0]);
+ * const candidates = [new Float32Array([1, 0, 0]), new Float32Array([0, 1, 0])];
+ * const result2 = differentiableSearch(query, candidates, 2, 1.0);
+ * ```
+ */
+function differentiableSearch(query, candidates, k, temperature = 1.0) {
+    const gnn = getGnnModule();
+    // Convert to Float32Array (native Rust expects Float32Array for performance)
+    const queryFloat32 = toFloat32Array(query);
+    const candidatesFloat32 = toFloat32ArrayBatch(candidates);
+    return gnn.differentiableSearch(queryFloat32, candidatesFloat32, k, temperature);
+}
+/**
+ * GNN Layer for HNSW topology
+ */
+class RuvectorLayer {
+    /**
+     * Create a new Ruvector GNN layer
+     *
+     * @param inputDim - Dimension of input node embeddings
+     * @param hiddenDim - Dimension of hidden representations
+     * @param heads - Number of attention heads
+     * @param dropout - Dropout rate (0.0 to 1.0)
+     */
+    constructor(inputDim, hiddenDim, heads, dropout = 0.1) {
+        const gnn = getGnnModule();
+        this.inner = new gnn.RuvectorLayer(inputDim, hiddenDim, heads, dropout);
+    }
+    /**
+     * Forward pass through the GNN layer
+     *
+     * @param nodeEmbedding - Current node's embedding
+     * @param neighborEmbeddings - Embeddings of neighbor nodes
+     * @param edgeWeights - Weights of edges to neighbors
+     * @returns Updated node embedding as Float32Array
+     */
+    forward(nodeEmbedding, neighborEmbeddings, edgeWeights) {
+        return this.inner.forward(toFloat32Array(nodeEmbedding), toFloat32ArrayBatch(neighborEmbeddings), toFloat32Array(edgeWeights));
+    }
+    /**
+     * Serialize the layer to JSON
+     */
+    toJson() {
+        return this.inner.toJson();
+    }
+    /**
+     * Deserialize the layer from JSON
+     */
+    static fromJson(json) {
+        const gnn = getGnnModule();
+        const layer = new RuvectorLayer(1, 1, 1, 0); // Dummy constructor
+        layer.inner = gnn.RuvectorLayer.fromJson(json);
+        return layer;
+    }
+}
+exports.RuvectorLayer = RuvectorLayer;
+/**
+ * Tensor compressor with adaptive level selection
+ */
+class TensorCompress {
+    constructor() {
+        const gnn = getGnnModule();
+        this.inner = new gnn.TensorCompress();
+    }
+    /**
+     * Compress an embedding based on access frequency
+     *
+     * @param embedding - Input embedding vector
+     * @param accessFreq - Access frequency (0.0 to 1.0)
+     * @returns Compressed tensor as JSON string
+     */
+    compress(embedding, accessFreq) {
+        return this.inner.compress(toFloat32Array(embedding), accessFreq);
+    }
+    /**
+     * Decompress a compressed tensor
+     *
+     * @param compressedJson - Compressed tensor JSON
+     * @returns Decompressed embedding
+     */
+    decompress(compressedJson) {
+        return this.inner.decompress(compressedJson);
+    }
+}
+exports.TensorCompress = TensorCompress;
+/**
+ * Hierarchical forward pass through GNN layers
+ *
+ * @param query - Query vector
+ * @param layerEmbeddings - Embeddings organized by layer
+ * @param gnnLayersJson - JSON array of serialized GNN layers
+ * @returns Final embedding after hierarchical processing as Float32Array
+ */
+function hierarchicalForward(query, layerEmbeddings, gnnLayersJson) {
+    const gnn = getGnnModule();
+    return gnn.hierarchicalForward(toFloat32Array(query), layerEmbeddings.map(layer => toFloat32ArrayBatch(layer)), gnnLayersJson);
+}
+/**
+ * Get compression level for a given access frequency
+ */
+function getCompressionLevel(accessFreq) {
+    const gnn = getGnnModule();
+    return gnn.getCompressionLevel(accessFreq);
+}
+/**
+ * Check if GNN module is available
+ */
+function isGnnAvailable() {
+    try {
+        getGnnModule();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+exports.default = {
+    differentiableSearch,
+    RuvectorLayer,
+    TensorCompress,
+    hierarchicalForward,
+    getCompressionLevel,
+    isGnnAvailable,
+    // Export conversion helpers for performance optimization
+    toFloat32Array,
+    toFloat32ArrayBatch,
+};

package/dist/core/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Core module exports
+ *
+ * These wrappers provide safe, type-flexible interfaces to the underlying
+ * native packages, handling array type conversions automatically.
+ */
+export * from './gnn-wrapper';
+export * from './attention-fallbacks';
+export * from './agentdb-fast';
+export * from './sona-wrapper';
+export { default as gnnWrapper } from './gnn-wrapper';
+export { default as attentionFallbacks } from './attention-fallbacks';
+export { default as agentdbFast } from './agentdb-fast';
+export { default as Sona } from './sona-wrapper';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAG/B,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/core/index.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Core module exports
+ *
+ * These wrappers provide safe, type-flexible interfaces to the underlying
+ * native packages, handling array type conversions automatically.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sona = exports.agentdbFast = exports.attentionFallbacks = exports.gnnWrapper = void 0;
+__exportStar(require("./gnn-wrapper"), exports);
+__exportStar(require("./attention-fallbacks"), exports);
+__exportStar(require("./agentdb-fast"), exports);
+__exportStar(require("./sona-wrapper"), exports);
+// Re-export default objects for convenience
+var gnn_wrapper_1 = require("./gnn-wrapper");
+Object.defineProperty(exports, "gnnWrapper", { enumerable: true, get: function () { return __importDefault(gnn_wrapper_1).default; } });
+var attention_fallbacks_1 = require("./attention-fallbacks");
+Object.defineProperty(exports, "attentionFallbacks", { enumerable: true, get: function () { return __importDefault(attention_fallbacks_1).default; } });
+var agentdb_fast_1 = require("./agentdb-fast");
+Object.defineProperty(exports, "agentdbFast", { enumerable: true, get: function () { return __importDefault(agentdb_fast_1).default; } });
+var sona_wrapper_1 = require("./sona-wrapper");
+Object.defineProperty(exports, "Sona", { enumerable: true, get: function () { return __importDefault(sona_wrapper_1).default; } });

package/dist/core/sona-wrapper.d.ts

@@ -0,0 +1,215 @@
+/**
+ * SONA Wrapper - Self-Optimizing Neural Architecture
+ *
+ * Provides a safe, flexible interface to @ruvector/sona with:
+ * - Automatic array type conversion (Array <-> Float64Array)
+ * - Graceful handling when sona is not installed
+ * - TypeScript types for all APIs
+ *
+ * SONA Features:
+ * - Micro-LoRA: Ultra-fast rank-1/2 adaptations (~0.1ms)
+ * - Base-LoRA: Deeper adaptations for complex patterns
+ * - EWC++: Elastic Weight Consolidation to prevent catastrophic forgetting
+ * - ReasoningBank: Pattern storage and retrieval
+ * - Trajectory tracking: Record and learn from execution paths
+ */
+/** Array input type - accepts both regular arrays and typed arrays */
+export type ArrayInput = number[] | Float32Array | Float64Array;
+/** SONA configuration options */
+export interface SonaConfig {
+    /** Hidden dimension size (required) */
+    hiddenDim: number;
+    /** Embedding dimension (defaults to hiddenDim) */
+    embeddingDim?: number;
+    /** Micro-LoRA rank (1-2, default: 1) */
+    microLoraRank?: number;
+    /** Base LoRA rank (default: 8) */
+    baseLoraRank?: number;
+    /** Micro-LoRA learning rate (default: 0.001) */
+    microLoraLr?: number;
+    /** Base LoRA learning rate (default: 0.0001) */
+    baseLoraLr?: number;
+    /** EWC lambda regularization (default: 1000.0) */
+    ewcLambda?: number;
+    /** Number of pattern clusters (default: 50) */
+    patternClusters?: number;
+    /** Trajectory buffer capacity (default: 10000) */
+    trajectoryCapacity?: number;
+    /** Background learning interval in ms (default: 3600000 = 1 hour) */
+    backgroundIntervalMs?: number;
+    /** Quality threshold for learning (default: 0.5) */
+    qualityThreshold?: number;
+    /** Enable SIMD optimizations (default: true) */
+    enableSimd?: boolean;
+}
+/** Learned pattern from ReasoningBank */
+export interface LearnedPattern {
+    /** Pattern identifier */
+    id: string;
+    /** Cluster centroid embedding */
+    centroid: number[];
+    /** Number of trajectories in cluster */
+    clusterSize: number;
+    /** Total weight of trajectories */
+    totalWeight: number;
+    /** Average quality of member trajectories */
+    avgQuality: number;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last access timestamp */
+    lastAccessed: string;
+    /** Total access count */
+    accessCount: number;
+    /** Pattern type */
+    patternType: string;
+}
+/** SONA engine statistics */
+export interface SonaStats {
+    trajectoriesRecorded: number;
+    patternsLearned: number;
+    microLoraUpdates: number;
+    baseLoraUpdates: number;
+    ewcConsolidations: number;
+    avgLearningTimeMs: number;
+}
+/** Check if sona is available */
+export declare function isSonaAvailable(): boolean;
+/**
+ * SONA Engine - Self-Optimizing Neural Architecture
+ *
+ * Provides runtime-adaptive learning with:
+ * - Micro-LoRA for instant adaptations
+ * - Base-LoRA for deeper learning
+ * - EWC++ for preventing forgetting
+ * - ReasoningBank for pattern storage
+ *
+ * @example
+ * ```typescript
+ * import { Sona } from 'ruvector';
+ *
+ * // Create engine with hidden dimension
+ * const engine = new Sona.Engine(256);
+ *
+ * // Or with custom config
+ * const engine = Sona.Engine.withConfig({
+ *   hiddenDim: 256,
+ *   microLoraRank: 2,
+ *   patternClusters: 100
+ * });
+ *
+ * // Record a trajectory
+ * const trajId = engine.beginTrajectory([0.1, 0.2, ...]);
+ * engine.addStep(trajId, activations, attentionWeights, 0.8);
+ * engine.endTrajectory(trajId, 0.9);
+ *
+ * // Apply learned adaptations
+ * const adapted = engine.applyMicroLora(input);
+ * ```
+ */
+export declare class SonaEngine {
+    private _native;
+    /**
+     * Create a new SONA engine
+     * @param hiddenDim Hidden dimension size (e.g., 256, 512, 768)
+     */
+    constructor(hiddenDim: number);
+    /**
+     * Create engine with custom configuration
+     * @param config SONA configuration options
+     */
+    static withConfig(config: SonaConfig): SonaEngine;
+    /**
+     * Begin recording a new trajectory
+     * @param queryEmbedding Initial query embedding
+     * @returns Trajectory ID for subsequent operations
+     */
+    beginTrajectory(queryEmbedding: ArrayInput): number;
+    /**
+     * Add a step to an active trajectory
+     * @param trajectoryId Trajectory ID from beginTrajectory
+     * @param activations Layer activations
+     * @param attentionWeights Attention weights
+     * @param reward Reward signal for this step (0.0 - 1.0)
+     */
+    addStep(trajectoryId: number, activations: ArrayInput, attentionWeights: ArrayInput, reward: number): void;
+    /**
+     * Alias for addStep for API compatibility
+     */
+    addTrajectoryStep(trajectoryId: number, activations: ArrayInput, attentionWeights: ArrayInput, reward: number): void;
+    /**
+     * Set the model route for a trajectory
+     * @param trajectoryId Trajectory ID
+     * @param route Model route identifier (e.g., "gpt-4", "claude-3")
+     */
+    setRoute(trajectoryId: number, route: string): void;
+    /**
+     * Add context to a trajectory
+     * @param trajectoryId Trajectory ID
+     * @param contextId Context identifier
+     */
+    addContext(trajectoryId: number, contextId: string): void;
+    /**
+     * Complete a trajectory and submit for learning
+     * @param trajectoryId Trajectory ID
+     * @param quality Final quality score (0.0 - 1.0)
+     */
+    endTrajectory(trajectoryId: number, quality: number): void;
+    /**
+     * Apply micro-LoRA transformation (ultra-fast, ~0.1ms)
+     * @param input Input vector
+     * @returns Transformed output vector
+     */
+    applyMicroLora(input: ArrayInput): number[];
+    /**
+     * Apply base-LoRA transformation to a specific layer
+     * @param layerIdx Layer index
+     * @param input Input vector
+     * @returns Transformed output vector
+     */
+    applyBaseLora(layerIdx: number, input: ArrayInput): number[];
+    /**
+     * Run background learning cycle if due
+     * Call this periodically (e.g., every few seconds)
+     * @returns Status message if learning occurred, null otherwise
+     */
+    tick(): string | null;
+    /**
+     * Force immediate background learning cycle
+     * @returns Status message with learning results
+     */
+    forceLearn(): string;
+    /**
+     * Flush pending instant loop updates
+     */
+    flush(): void;
+    /**
+     * Find similar learned patterns to a query
+     * @param queryEmbedding Query embedding
+     * @param k Number of patterns to return
+     * @returns Array of similar patterns
+     */
+    findPatterns(queryEmbedding: ArrayInput, k: number): LearnedPattern[];
+    /**
+     * Get engine statistics
+     * @returns Statistics object
+     */
+    getStats(): SonaStats;
+    /**
+     * Enable or disable the engine
+     * @param enabled Whether to enable
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Check if engine is enabled
+     */
+    isEnabled(): boolean;
+}
+/**
+ * SONA namespace with all exports
+ */
+export declare const Sona: {
+    Engine: typeof SonaEngine;
+    isAvailable: typeof isSonaAvailable;
+};
+export default Sona;
+//# sourceMappingURL=sona-wrapper.d.ts.map

package/dist/core/sona-wrapper.d.ts.map

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