ruvector 0.2.21 → 0.2.23

package/dist/core/attention-fallbacks.js

@@ -1,552 +0,0 @@
-"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

@@ -1,148 +0,0 @@
-/**
- * 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

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