ruvector 0.2.23 → 0.2.25

package/dist/core/attention-fallbacks.js

@@ -0,0 +1,552 @@
+"use strict";
+/**
+ * Attention Fallbacks - Safe wrapper around @ruvector/attention with automatic array conversion
+ *
+ * This wrapper handles the array type conversion automatically, allowing users
+ * to pass either regular arrays or Float32Arrays.
+ *
+ * @ruvector/attention requires Float32Array inputs.
+ * This wrapper handles the conversion automatically.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdamOptimizer = exports.DotProductAttention = exports.DualSpaceAttention = exports.EdgeFeaturedAttention = exports.GraphRoPeAttention = exports.MoEAttention = exports.LocalGlobalAttention = exports.LinearAttention = exports.HyperbolicAttention = exports.FlashAttention = exports.MultiHeadAttention = void 0;
+exports.projectToPoincareBall = projectToPoincareBall;
+exports.poincareDistance = poincareDistance;
+exports.mobiusAddition = mobiusAddition;
+exports.expMap = expMap;
+exports.logMap = logMap;
+exports.isAttentionAvailable = isAttentionAvailable;
+exports.getAttentionVersion = getAttentionVersion;
+exports.parallelAttentionCompute = parallelAttentionCompute;
+exports.batchAttentionCompute = batchAttentionCompute;
+exports.computeFlashAttentionAsync = computeFlashAttentionAsync;
+exports.computeHyperbolicAttentionAsync = computeHyperbolicAttentionAsync;
+exports.infoNceLoss = infoNceLoss;
+exports.mineHardNegatives = mineHardNegatives;
+exports.benchmarkAttention = benchmarkAttention;
+// Lazy load to avoid import errors if not installed
+let attentionModule = null;
+let loadError = null;
+function getAttentionModule() {
+    if (attentionModule)
+        return attentionModule;
+    if (loadError)
+        throw loadError;
+    try {
+        attentionModule = require('@ruvector/attention');
+        return attentionModule;
+    }
+    catch (e) {
+        loadError = new Error(`@ruvector/attention is not installed or failed to load: ${e.message}\n` +
+            `Install with: npm install @ruvector/attention`);
+        throw loadError;
+    }
+}
+/**
+ * Convert any array-like input to Float32Array
+ */
+function toFloat32Array(input) {
+    if (input instanceof Float32Array) {
+        return input;
+    }
+    return new Float32Array(input);
+}
+/**
+ * Convert nested arrays to Float32Arrays
+ */
+function toFloat32Arrays(inputs) {
+    return inputs.map(arr => toFloat32Array(arr));
+}
+/**
+ * Convert Float32Array result back to regular array if needed
+ */
+function fromFloat32Array(input) {
+    return Array.from(input);
+}
+/**
+ * Multi-head attention mechanism
+ *
+ * This wrapper automatically converts array inputs to Float32Array.
+ */
+class MultiHeadAttention {
+    /**
+     * Create a new multi-head attention instance
+     *
+     * @param dim - Embedding dimension (must be divisible by numHeads)
+     * @param numHeads - Number of attention heads
+     */
+    constructor(dim, numHeads) {
+        const attention = getAttentionModule();
+        this.inner = new attention.MultiHeadAttention(dim, numHeads);
+        this.dim = dim;
+        this.numHeads = numHeads;
+    }
+    /**
+     * Compute multi-head attention
+     *
+     * @param query - Query vector
+     * @param keys - Array of key vectors
+     * @param values - Array of value vectors
+     * @returns Attention output
+     *
+     * @example
+     * ```typescript
+     * const mha = new MultiHeadAttention(64, 4);
+     *
+     * // Works with regular arrays
+     * const result1 = mha.compute([...64 values], [[...64], [...64]], [[...64], [...64]]);
+     *
+     * // Also works with Float32Array
+     * const q = new Float32Array(64);
+     * const k = [new Float32Array(64)];
+     * const v = [new Float32Array(64)];
+     * const result2 = mha.compute(q, k, v);
+     * ```
+     */
+    compute(query, keys, values) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values));
+        return {
+            values: fromFloat32Array(raw),
+            raw
+        };
+    }
+    /**
+     * Compute and return raw Float32Array (faster, no conversion)
+     */
+    computeRaw(query, keys, values) {
+        return this.inner.compute(query, keys, values);
+    }
+    get headDim() {
+        return this.dim / this.numHeads;
+    }
+}
+exports.MultiHeadAttention = MultiHeadAttention;
+/**
+ * Flash attention with tiled computation
+ */
+class FlashAttention {
+    /**
+     * Create a new flash attention instance
+     *
+     * @param dim - Embedding dimension
+     * @param blockSize - Block size for tiled computation (default: 512)
+     */
+    constructor(dim, blockSize = 512) {
+        const attention = getAttentionModule();
+        this.inner = new attention.FlashAttention(dim, blockSize);
+        this.dim = dim;
+        this.blockSize = blockSize;
+    }
+    /**
+     * Compute flash attention
+     */
+    compute(query, keys, values) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values));
+        return {
+            values: fromFloat32Array(raw),
+            raw
+        };
+    }
+    computeRaw(query, keys, values) {
+        return this.inner.compute(query, keys, values);
+    }
+}
+exports.FlashAttention = FlashAttention;
+/**
+ * Hyperbolic attention in Poincare ball model
+ */
+class HyperbolicAttention {
+    /**
+     * Create a new hyperbolic attention instance
+     *
+     * @param dim - Embedding dimension
+     * @param curvature - Hyperbolic curvature (typically 1.0)
+     */
+    constructor(dim, curvature = 1.0) {
+        const attention = getAttentionModule();
+        this.inner = new attention.HyperbolicAttention(dim, curvature);
+        this.dim = dim;
+        this.curvature = curvature;
+    }
+    /**
+     * Compute hyperbolic attention
+     */
+    compute(query, keys, values) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values));
+        return {
+            values: fromFloat32Array(raw),
+            raw
+        };
+    }
+    computeRaw(query, keys, values) {
+        return this.inner.compute(query, keys, values);
+    }
+}
+exports.HyperbolicAttention = HyperbolicAttention;
+/**
+ * Linear attention (Performer-style) with O(n) complexity
+ */
+class LinearAttention {
+    /**
+     * Create a new linear attention instance
+     *
+     * @param dim - Embedding dimension
+     * @param numFeatures - Number of random features
+     */
+    constructor(dim, numFeatures) {
+        const attention = getAttentionModule();
+        this.inner = new attention.LinearAttention(dim, numFeatures);
+        this.dim = dim;
+        this.numFeatures = numFeatures;
+    }
+    /**
+     * Compute linear attention
+     */
+    compute(query, keys, values) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values));
+        return {
+            values: fromFloat32Array(raw),
+            raw
+        };
+    }
+    computeRaw(query, keys, values) {
+        return this.inner.compute(query, keys, values);
+    }
+}
+exports.LinearAttention = LinearAttention;
+/**
+ * Local-global attention (Longformer-style)
+ */
+class LocalGlobalAttention {
+    /**
+     * Create a new local-global attention instance
+     *
+     * @param dim - Embedding dimension
+     * @param localWindow - Size of local attention window
+     * @param globalTokens - Number of global attention tokens
+     */
+    constructor(dim, localWindow, globalTokens) {
+        const attention = getAttentionModule();
+        this.inner = new attention.LocalGlobalAttention(dim, localWindow, globalTokens);
+        this.dim = dim;
+        this.localWindow = localWindow;
+        this.globalTokens = globalTokens;
+    }
+    /**
+     * Compute local-global attention
+     */
+    compute(query, keys, values) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values));
+        return {
+            values: fromFloat32Array(raw),
+            raw
+        };
+    }
+    computeRaw(query, keys, values) {
+        return this.inner.compute(query, keys, values);
+    }
+}
+exports.LocalGlobalAttention = LocalGlobalAttention;
+/**
+ * Mixture of Experts attention
+ */
+class MoEAttention {
+    /**
+     * Create a new MoE attention instance
+     *
+     * @param config - MoE configuration
+     */
+    constructor(config) {
+        const attention = getAttentionModule();
+        this.inner = new attention.MoEAttention({
+            dim: config.dim,
+            num_experts: config.numExperts,
+            top_k: config.topK,
+            expert_capacity: config.expertCapacity ?? 1.25,
+        });
+        this.config = config;
+    }
+    /**
+     * Create with simple parameters
+     */
+    static simple(dim, numExperts, topK) {
+        return new MoEAttention({ dim, numExperts, topK });
+    }
+    /**
+     * Compute MoE attention
+     */
+    compute(query, keys, values) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values));
+        return {
+            values: fromFloat32Array(raw),
+            raw
+        };
+    }
+    computeRaw(query, keys, values) {
+        return this.inner.compute(query, keys, values);
+    }
+}
+exports.MoEAttention = MoEAttention;
+// Hyperbolic math utilities
+/**
+ * Project a vector into the Poincare ball
+ */
+function projectToPoincareBall(vector, curvature = 1.0) {
+    const attention = getAttentionModule();
+    const result = attention.projectToPoincareBall(toFloat32Array(vector), curvature);
+    return fromFloat32Array(result);
+}
+/**
+ * Compute hyperbolic (Poincare) distance between two points
+ */
+function poincareDistance(a, b, curvature = 1.0) {
+    const attention = getAttentionModule();
+    return attention.poincareDistance(toFloat32Array(a), toFloat32Array(b), curvature);
+}
+/**
+ * Mobius addition in hyperbolic space
+ */
+function mobiusAddition(a, b, curvature = 1.0) {
+    const attention = getAttentionModule();
+    const result = attention.mobiusAddition(toFloat32Array(a), toFloat32Array(b), curvature);
+    return fromFloat32Array(result);
+}
+/**
+ * Exponential map from tangent space to hyperbolic space
+ */
+function expMap(base, tangent, curvature = 1.0) {
+    const attention = getAttentionModule();
+    const result = attention.expMap(toFloat32Array(base), toFloat32Array(tangent), curvature);
+    return fromFloat32Array(result);
+}
+/**
+ * Logarithmic map from hyperbolic space to tangent space
+ */
+function logMap(base, point, curvature = 1.0) {
+    const attention = getAttentionModule();
+    const result = attention.logMap(toFloat32Array(base), toFloat32Array(point), curvature);
+    return fromFloat32Array(result);
+}
+/**
+ * Check if attention module is available
+ */
+function isAttentionAvailable() {
+    try {
+        getAttentionModule();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get attention module version
+ */
+function getAttentionVersion() {
+    try {
+        const attention = getAttentionModule();
+        return attention.version?.() ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+// ============================================================================
+// Graph-based Attention (for code structure)
+// ============================================================================
+/**
+ * Graph attention with Rotary Position Embeddings
+ * Excellent for code AST and dependency graphs
+ */
+class GraphRoPeAttention {
+    constructor(dim, numHeads = 4, maxSeqLen = 4096) {
+        const attention = getAttentionModule();
+        this.inner = new attention.GraphRoPeAttention(dim, numHeads, maxSeqLen);
+        this.dim = dim;
+        this.numHeads = numHeads;
+        this.maxSeqLen = maxSeqLen;
+    }
+    compute(query, keys, values, positions) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values), positions ? new Int32Array(positions) : undefined);
+        return { values: fromFloat32Array(raw), raw };
+    }
+}
+exports.GraphRoPeAttention = GraphRoPeAttention;
+/**
+ * Edge-featured attention for graphs with edge attributes
+ * Useful for weighted dependency graphs
+ */
+class EdgeFeaturedAttention {
+    constructor(dim, edgeDim = 16) {
+        const attention = getAttentionModule();
+        this.inner = new attention.EdgeFeaturedAttention(dim, edgeDim);
+        this.dim = dim;
+        this.edgeDim = edgeDim;
+    }
+    compute(query, keys, values, edgeFeatures) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values), edgeFeatures ? toFloat32Arrays(edgeFeatures) : undefined);
+        return { values: fromFloat32Array(raw), raw };
+    }
+}
+exports.EdgeFeaturedAttention = EdgeFeaturedAttention;
+/**
+ * Dual-space attention (Euclidean + Hyperbolic)
+ * Best of both worlds for hierarchical + semantic similarity
+ */
+class DualSpaceAttention {
+    constructor(dim, curvature = 1.0, alpha = 0.5) {
+        const attention = getAttentionModule();
+        this.inner = new attention.DualSpaceAttention(dim, curvature, alpha);
+        this.dim = dim;
+        this.curvature = curvature;
+        this.alpha = alpha;
+    }
+    compute(query, keys, values) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values));
+        return { values: fromFloat32Array(raw), raw };
+    }
+}
+exports.DualSpaceAttention = DualSpaceAttention;
+/**
+ * Basic dot-product attention
+ */
+class DotProductAttention {
+    constructor(dim) {
+        const attention = getAttentionModule();
+        this.inner = new attention.DotProductAttention(dim);
+        this.dim = dim;
+    }
+    compute(query, keys, values) {
+        const raw = this.inner.compute(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values));
+        return { values: fromFloat32Array(raw), raw };
+    }
+}
+exports.DotProductAttention = DotProductAttention;
+// ============================================================================
+// Parallel/Batch Attention Compute
+// ============================================================================
+/**
+ * Compute attention in parallel across multiple queries
+ */
+async function parallelAttentionCompute(queries, keys, values, attentionType = 'multi-head') {
+    const attention = getAttentionModule();
+    const results = await attention.parallelAttentionCompute(toFloat32Arrays(queries), toFloat32Arrays(keys), toFloat32Arrays(values), attentionType);
+    return results.map((r) => fromFloat32Array(r));
+}
+/**
+ * Batch attention compute for multiple query-key-value sets
+ */
+async function batchAttentionCompute(batches, attentionType = 'multi-head') {
+    const attention = getAttentionModule();
+    const nativeBatches = batches.map(b => ({
+        query: toFloat32Array(b.query),
+        keys: toFloat32Arrays(b.keys),
+        values: toFloat32Arrays(b.values),
+    }));
+    const results = await attention.batchAttentionCompute(nativeBatches, attentionType);
+    return results.map((r) => fromFloat32Array(r));
+}
+/**
+ * Async flash attention with callback
+ */
+function computeFlashAttentionAsync(query, keys, values) {
+    const attention = getAttentionModule();
+    return new Promise((resolve, reject) => {
+        attention.computeFlashAttentionAsync(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values), (err, result) => {
+            if (err)
+                reject(err);
+            else
+                resolve(fromFloat32Array(result));
+        });
+    });
+}
+/**
+ * Async hyperbolic attention
+ */
+function computeHyperbolicAttentionAsync(query, keys, values, curvature = 1.0) {
+    const attention = getAttentionModule();
+    return new Promise((resolve, reject) => {
+        attention.computeHyperbolicAttentionAsync(toFloat32Array(query), toFloat32Arrays(keys), toFloat32Arrays(values), curvature, (err, result) => {
+            if (err)
+                reject(err);
+            else
+                resolve(fromFloat32Array(result));
+        });
+    });
+}
+// ============================================================================
+// Training Utilities (for SONA integration)
+// ============================================================================
+/**
+ * Adam optimizer for attention training
+ */
+class AdamOptimizer {
+    constructor(learningRate = 0.001, beta1 = 0.9, beta2 = 0.999) {
+        const attention = getAttentionModule();
+        this.inner = new attention.AdamOptimizer(learningRate, beta1, beta2);
+    }
+    step(gradients, params) {
+        const result = this.inner.step(toFloat32Array(gradients), toFloat32Array(params));
+        return fromFloat32Array(result);
+    }
+}
+exports.AdamOptimizer = AdamOptimizer;
+/**
+ * InfoNCE contrastive loss
+ */
+function infoNceLoss(anchor, positive, negatives, temperature = 0.07) {
+    const attention = getAttentionModule();
+    return attention.InfoNceLoss.compute(toFloat32Array(anchor), toFloat32Array(positive), toFloat32Arrays(negatives), temperature);
+}
+/**
+ * Hard negative mining for contrastive learning
+ */
+function mineHardNegatives(anchor, candidates, topK = 5) {
+    const attention = getAttentionModule();
+    const miner = new attention.HardNegativeMiner(topK);
+    const results = miner.mine(toFloat32Array(anchor), toFloat32Arrays(candidates));
+    return results.map((r) => fromFloat32Array(r));
+}
+// ============================================================================
+// Benchmarking
+// ============================================================================
+/**
+ * Benchmark attention implementations
+ */
+async function benchmarkAttention(dim, seqLen, iterations = 100) {
+    const attention = getAttentionModule();
+    return attention.benchmarkAttention(dim, seqLen, iterations);
+}
+exports.default = {
+    // Core attention types
+    DotProductAttention,
+    MultiHeadAttention,
+    FlashAttention,
+    HyperbolicAttention,
+    LinearAttention,
+    LocalGlobalAttention,
+    MoEAttention,
+    // Graph attention types
+    GraphRoPeAttention,
+    EdgeFeaturedAttention,
+    DualSpaceAttention,
+    // Parallel/batch compute
+    parallelAttentionCompute,
+    batchAttentionCompute,
+    computeFlashAttentionAsync,
+    computeHyperbolicAttentionAsync,
+    // Training utilities
+    AdamOptimizer,
+    infoNceLoss,
+    mineHardNegatives,
+    // Hyperbolic math
+    projectToPoincareBall,
+    poincareDistance,
+    mobiusAddition,
+    expMap,
+    logMap,
+    // Utilities
+    isAttentionAvailable,
+    getAttentionVersion,
+    benchmarkAttention,
+};

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

@@ -0,0 +1,148 @@
+/**
+ * Cluster Wrapper - Distributed coordination for multi-agent systems
+ *
+ * Wraps @ruvector/cluster for Raft consensus, auto-sharding,
+ * and distributed memory across agents.
+ */
+export declare function isClusterAvailable(): boolean;
+export interface ClusterNode {
+    id: string;
+    address: string;
+    role: 'leader' | 'follower' | 'candidate';
+    status: 'healthy' | 'unhealthy' | 'unknown';
+    lastHeartbeat: number;
+}
+export interface ShardInfo {
+    id: number;
+    range: [number, number];
+    node: string;
+    size: number;
+    status: 'active' | 'migrating' | 'offline';
+}
+export interface ClusterConfig {
+    nodeId: string;
+    address: string;
+    peers?: string[];
+    shards?: number;
+    replicationFactor?: number;
+}
+/**
+ * Distributed cluster for multi-agent coordination
+ */
+export declare class RuvectorCluster {
+    private inner;
+    private nodeId;
+    private isLeader;
+    constructor(config: ClusterConfig);
+    /**
+     * Start the cluster node
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the cluster node gracefully
+     */
+    stop(): Promise<void>;
+    /**
+     * Join an existing cluster
+     */
+    join(peerAddress: string): Promise<boolean>;
+    /**
+     * Leave the cluster
+     */
+    leave(): Promise<void>;
+    /**
+     * Get current node info
+     */
+    getNodeInfo(): ClusterNode;
+    /**
+     * Get all cluster nodes
+     */
+    getNodes(): ClusterNode[];
+    /**
+     * Check if this node is the leader
+     */
+    isClusterLeader(): boolean;
+    /**
+     * Get the current leader
+     */
+    getLeader(): ClusterNode | null;
+    /**
+     * Put a value in distributed storage
+     */
+    put(key: string, value: any): Promise<boolean>;
+    /**
+     * Get a value from distributed storage
+     */
+    get(key: string): Promise<any | null>;
+    /**
+     * Delete a value from distributed storage
+     */
+    delete(key: string): Promise<boolean>;
+    /**
+     * Atomic compare-and-swap
+     */
+    compareAndSwap(key: string, expected: any, newValue: any): Promise<boolean>;
+    /**
+     * Get shard information
+     */
+    getShards(): ShardInfo[];
+    /**
+     * Get the shard for a key
+     */
+    getShardForKey(key: string): ShardInfo;
+    /**
+     * Trigger shard rebalancing
+     */
+    rebalance(): Promise<void>;
+    /**
+     * Acquire a distributed lock
+     */
+    lock(name: string, timeout?: number): Promise<string | null>;
+    /**
+     * Release a distributed lock
+     */
+    unlock(name: string, token: string): Promise<boolean>;
+    /**
+     * Extend a lock's TTL
+     */
+    extendLock(name: string, token: string, extension?: number): Promise<boolean>;
+    /**
+     * Subscribe to a channel
+     */
+    subscribe(channel: string, callback: (message: any) => void): () => void;
+    /**
+     * Publish to a channel
+     */
+    publish(channel: string, message: any): Promise<number>;
+    /**
+     * Register an agent with the cluster
+     */
+    registerAgent(agentId: string, capabilities: string[]): Promise<boolean>;
+    /**
+     * Find agents with a capability
+     */
+    findAgents(capability: string): Promise<string[]>;
+    /**
+     * Assign a task to an agent
+     */
+    assignTask(taskId: string, agentId: string, task: any): Promise<boolean>;
+    /**
+     * Complete a task
+     */
+    completeTask(taskId: string, result: any): Promise<boolean>;
+    /**
+     * Get cluster statistics
+     */
+    stats(): {
+        nodes: number;
+        shards: number;
+        leader: string | null;
+        healthy: boolean;
+    };
+}
+/**
+ * Create a cluster node for agent coordination
+ */
+export declare function createCluster(config: ClusterConfig): RuvectorCluster;
+export default RuvectorCluster;
+//# sourceMappingURL=cluster-wrapper.d.ts.map

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

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