ruvector 0.1.26 → 0.1.28

package/.claude-flow/metrics/performance.json

@@ -1,7 +1,7 @@
 {
-  "startTime": 1764543814799,
-  "sessionId": "session-1764543814799",
-  "lastActivity": 1764543814799,
+  "startTime": 1764781064465,
+  "sessionId": "session-1764781064465",
+  "lastActivity": 1764781064465,
   "sessionDuration": 0,
   "totalTasks": 1,
   "successfulTasks": 1,

package/.claude-flow/metrics/task-metrics.json

@@ -1,10 +1,10 @@
 [
   {
-    "id": "cmd-hooks-1764543814926",
+    "id": "cmd-hooks-1764781064566",
     "type": "hooks",
     "success": true,
-    "duration": 11.31845599999997,
-    "timestamp": 1764543814938,
+    "duration": 6.678244999999947,
+    "timestamp": 1764781064573,
     "metadata": {}
   }
 ]

package/dist/core/agentdb-fast.d.ts

@@ -0,0 +1,149 @@
+/**
+ * AgentDB Fast - High-performance in-process alternative to AgentDB CLI
+ *
+ * The AgentDB CLI has ~2.3s startup overhead due to npx initialization.
+ * This module provides 50-200x faster operations by using in-process calls.
+ *
+ * Features:
+ * - In-memory episode storage with LRU eviction
+ * - Vector similarity search using @ruvector/core
+ * - Compatible API with AgentDB's episode/trajectory interfaces
+ */
+/**
+ * Episode entry for trajectory storage
+ */
+export interface Episode {
+    id: string;
+    state: number[];
+    action: string | number;
+    reward: number;
+    nextState: number[];
+    done: boolean;
+    metadata?: Record<string, any>;
+    timestamp?: number;
+}
+/**
+ * Trajectory (sequence of episodes)
+ */
+export interface Trajectory {
+    id: string;
+    episodes: Episode[];
+    totalReward: number;
+    metadata?: Record<string, any>;
+}
+/**
+ * Search result for episode queries
+ */
+export interface EpisodeSearchResult {
+    episode: Episode;
+    similarity: number;
+    trajectoryId?: string;
+}
+/**
+ * Fast in-memory AgentDB implementation
+ */
+export declare class FastAgentDB {
+    private episodes;
+    private trajectories;
+    private vectorDb;
+    private dimensions;
+    private maxEpisodes;
+    private episodeOrder;
+    /**
+     * Create a new FastAgentDB instance
+     *
+     * @param dimensions - Vector dimensions for state embeddings
+     * @param maxEpisodes - Maximum episodes to store (LRU eviction)
+     */
+    constructor(dimensions?: number, maxEpisodes?: number);
+    /**
+     * Initialize the vector database
+     */
+    private initVectorDb;
+    /**
+     * Store an episode
+     *
+     * @param episode - Episode to store
+     * @returns Episode ID
+     */
+    storeEpisode(episode: Omit<Episode, 'id'> & {
+        id?: string;
+    }): Promise<string>;
+    /**
+     * Store multiple episodes in batch
+     */
+    storeEpisodes(episodes: (Omit<Episode, 'id'> & {
+        id?: string;
+    })[]): Promise<string[]>;
+    /**
+     * Retrieve an episode by ID
+     */
+    getEpisode(id: string): Promise<Episode | null>;
+    /**
+     * Search for similar episodes by state
+     *
+     * @param queryState - State vector to search for
+     * @param k - Number of results to return
+     * @returns Similar episodes sorted by similarity
+     */
+    searchByState(queryState: number[] | Float32Array, k?: number): Promise<EpisodeSearchResult[]>;
+    /**
+     * Fallback similarity search using brute-force cosine similarity
+     */
+    private fallbackSearch;
+    /**
+     * Compute cosine similarity between two vectors
+     */
+    private cosineSimilarity;
+    /**
+     * Store a trajectory (sequence of episodes)
+     */
+    storeTrajectory(episodes: (Omit<Episode, 'id'> & {
+        id?: string;
+    })[], metadata?: Record<string, any>): Promise<string>;
+    /**
+     * Get a trajectory by ID
+     */
+    getTrajectory(id: string): Promise<Trajectory | null>;
+    /**
+     * Get top trajectories by total reward
+     */
+    getTopTrajectories(k?: number): Promise<Trajectory[]>;
+    /**
+     * Sample random episodes (for experience replay)
+     */
+    sampleEpisodes(n: number): Promise<Episode[]>;
+    /**
+     * Get database statistics
+     */
+    getStats(): {
+        episodeCount: number;
+        trajectoryCount: number;
+        dimensions: number;
+        maxEpisodes: number;
+        vectorDbAvailable: boolean;
+    };
+    /**
+     * Clear all data
+     */
+    clear(): void;
+    /**
+     * Generate a unique ID
+     */
+    private generateId;
+}
+/**
+ * Create a fast AgentDB instance
+ */
+export declare function createFastAgentDB(dimensions?: number, maxEpisodes?: number): FastAgentDB;
+/**
+ * Get the default FastAgentDB instance
+ */
+export declare function getDefaultAgentDB(): FastAgentDB;
+declare const _default: {
+    FastAgentDB: typeof FastAgentDB;
+    createFastAgentDB: typeof createFastAgentDB;
+    getDefaultAgentDB: typeof getDefaultAgentDB;
+};
+export default _default;
+//# sourceMappingURL=agentdb-fast.d.ts.map

package/dist/core/agentdb-fast.d.ts.map

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

package/dist/core/agentdb-fast.js

@@ -0,0 +1,301 @@
+"use strict";
+/**
+ * AgentDB Fast - High-performance in-process alternative to AgentDB CLI
+ *
+ * The AgentDB CLI has ~2.3s startup overhead due to npx initialization.
+ * This module provides 50-200x faster operations by using in-process calls.
+ *
+ * Features:
+ * - In-memory episode storage with LRU eviction
+ * - Vector similarity search using @ruvector/core
+ * - Compatible API with AgentDB's episode/trajectory interfaces
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastAgentDB = void 0;
+exports.createFastAgentDB = createFastAgentDB;
+exports.getDefaultAgentDB = getDefaultAgentDB;
+// Lazy load ruvector core
+let coreModule = null;
+function getCoreModule() {
+    if (coreModule)
+        return coreModule;
+    try {
+        coreModule = require('@ruvector/core');
+        return coreModule;
+    }
+    catch {
+        // Fallback to ruvector if core not available
+        try {
+            coreModule = require('ruvector');
+            return coreModule;
+        }
+        catch (e) {
+            throw new Error(`Neither @ruvector/core nor ruvector is available: ${e.message}`);
+        }
+    }
+}
+/**
+ * Fast in-memory AgentDB implementation
+ */
+class FastAgentDB {
+    /**
+     * Create a new FastAgentDB instance
+     *
+     * @param dimensions - Vector dimensions for state embeddings
+     * @param maxEpisodes - Maximum episodes to store (LRU eviction)
+     */
+    constructor(dimensions = 128, maxEpisodes = 100000) {
+        this.episodes = new Map();
+        this.trajectories = new Map();
+        this.vectorDb = null;
+        this.episodeOrder = []; // For LRU eviction
+        this.dimensions = dimensions;
+        this.maxEpisodes = maxEpisodes;
+    }
+    /**
+     * Initialize the vector database
+     */
+    async initVectorDb() {
+        if (this.vectorDb)
+            return;
+        try {
+            const core = getCoreModule();
+            this.vectorDb = new core.VectorDB({
+                dimensions: this.dimensions,
+                distanceMetric: 'Cosine',
+            });
+        }
+        catch (e) {
+            // Vector DB not available, use fallback similarity
+            console.warn(`VectorDB not available, using fallback similarity: ${e.message}`);
+        }
+    }
+    /**
+     * Store an episode
+     *
+     * @param episode - Episode to store
+     * @returns Episode ID
+     */
+    async storeEpisode(episode) {
+        await this.initVectorDb();
+        const id = episode.id ?? this.generateId();
+        const fullEpisode = {
+            ...episode,
+            id,
+            timestamp: episode.timestamp ?? Date.now(),
+        };
+        // LRU eviction if needed
+        if (this.episodes.size >= this.maxEpisodes) {
+            const oldestId = this.episodeOrder.shift();
+            if (oldestId) {
+                this.episodes.delete(oldestId);
+            }
+        }
+        this.episodes.set(id, fullEpisode);
+        this.episodeOrder.push(id);
+        // Index in vector DB if available
+        if (this.vectorDb && fullEpisode.state.length === this.dimensions) {
+            try {
+                await this.vectorDb.insert({
+                    id,
+                    vector: new Float32Array(fullEpisode.state),
+                });
+            }
+            catch {
+                // Ignore indexing errors
+            }
+        }
+        return id;
+    }
+    /**
+     * Store multiple episodes in batch
+     */
+    async storeEpisodes(episodes) {
+        const ids = [];
+        for (const episode of episodes) {
+            const id = await this.storeEpisode(episode);
+            ids.push(id);
+        }
+        return ids;
+    }
+    /**
+     * Retrieve an episode by ID
+     */
+    async getEpisode(id) {
+        const episode = this.episodes.get(id);
+        if (episode) {
+            // Update LRU order
+            const idx = this.episodeOrder.indexOf(id);
+            if (idx > -1) {
+                this.episodeOrder.splice(idx, 1);
+                this.episodeOrder.push(id);
+            }
+        }
+        return episode ?? null;
+    }
+    /**
+     * Search for similar episodes by state
+     *
+     * @param queryState - State vector to search for
+     * @param k - Number of results to return
+     * @returns Similar episodes sorted by similarity
+     */
+    async searchByState(queryState, k = 10) {
+        await this.initVectorDb();
+        const query = Array.isArray(queryState) ? queryState : Array.from(queryState);
+        // Use vector DB if available
+        if (this.vectorDb && query.length === this.dimensions) {
+            try {
+                const results = await this.vectorDb.search({
+                    vector: new Float32Array(query),
+                    k,
+                });
+                return results
+                    .map((r) => {
+                    const episode = this.episodes.get(r.id);
+                    if (!episode)
+                        return null;
+                    return {
+                        episode,
+                        similarity: 1 - r.score, // Convert distance to similarity
+                    };
+                })
+                    .filter((r) => r !== null);
+            }
+            catch {
+                // Fall through to fallback
+            }
+        }
+        // Fallback: brute-force cosine similarity
+        return this.fallbackSearch(query, k);
+    }
+    /**
+     * Fallback similarity search using brute-force cosine similarity
+     */
+    fallbackSearch(query, k) {
+        const results = [];
+        for (const episode of this.episodes.values()) {
+            if (episode.state.length !== query.length)
+                continue;
+            const similarity = this.cosineSimilarity(query, episode.state);
+            results.push({ episode, similarity });
+        }
+        return results
+            .sort((a, b) => b.similarity - a.similarity)
+            .slice(0, k);
+    }
+    /**
+     * Compute cosine similarity between two vectors
+     */
+    cosineSimilarity(a, b) {
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        const denom = Math.sqrt(normA) * Math.sqrt(normB);
+        return denom === 0 ? 0 : dotProduct / denom;
+    }
+    /**
+     * Store a trajectory (sequence of episodes)
+     */
+    async storeTrajectory(episodes, metadata) {
+        const trajectoryId = this.generateId();
+        const storedEpisodes = [];
+        let totalReward = 0;
+        for (const episode of episodes) {
+            const id = await this.storeEpisode(episode);
+            const stored = await this.getEpisode(id);
+            if (stored) {
+                storedEpisodes.push(stored);
+                totalReward += stored.reward;
+            }
+        }
+        const trajectory = {
+            id: trajectoryId,
+            episodes: storedEpisodes,
+            totalReward,
+            metadata,
+        };
+        this.trajectories.set(trajectoryId, trajectory);
+        return trajectoryId;
+    }
+    /**
+     * Get a trajectory by ID
+     */
+    async getTrajectory(id) {
+        return this.trajectories.get(id) ?? null;
+    }
+    /**
+     * Get top trajectories by total reward
+     */
+    async getTopTrajectories(k = 10) {
+        return Array.from(this.trajectories.values())
+            .sort((a, b) => b.totalReward - a.totalReward)
+            .slice(0, k);
+    }
+    /**
+     * Sample random episodes (for experience replay)
+     */
+    async sampleEpisodes(n) {
+        const allEpisodes = Array.from(this.episodes.values());
+        const sampled = [];
+        for (let i = 0; i < Math.min(n, allEpisodes.length); i++) {
+            const idx = Math.floor(Math.random() * allEpisodes.length);
+            sampled.push(allEpisodes[idx]);
+        }
+        return sampled;
+    }
+    /**
+     * Get database statistics
+     */
+    getStats() {
+        return {
+            episodeCount: this.episodes.size,
+            trajectoryCount: this.trajectories.size,
+            dimensions: this.dimensions,
+            maxEpisodes: this.maxEpisodes,
+            vectorDbAvailable: this.vectorDb !== null,
+        };
+    }
+    /**
+     * Clear all data
+     */
+    clear() {
+        this.episodes.clear();
+        this.trajectories.clear();
+        this.episodeOrder = [];
+    }
+    /**
+     * Generate a unique ID
+     */
+    generateId() {
+        return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+}
+exports.FastAgentDB = FastAgentDB;
+/**
+ * Create a fast AgentDB instance
+ */
+function createFastAgentDB(dimensions = 128, maxEpisodes = 100000) {
+    return new FastAgentDB(dimensions, maxEpisodes);
+}
+// Singleton instance for convenience
+let defaultInstance = null;
+/**
+ * Get the default FastAgentDB instance
+ */
+function getDefaultAgentDB() {
+    if (!defaultInstance) {
+        defaultInstance = new FastAgentDB();
+    }
+    return defaultInstance;
+}
+exports.default = {
+    FastAgentDB,
+    createFastAgentDB,
+    getDefaultAgentDB,
+};

package/dist/core/attention-fallbacks.d.ts

@@ -0,0 +1,221 @@
+/**
+ * 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.
+ */
+/**
+ * Attention output interface
+ */
+export interface AttentionOutput {
+    /** Output vector as regular array */
+    values: number[];
+    /** Output as Float32Array for performance-critical code */
+    raw: Float32Array;
+}
+/**
+ * Multi-head attention mechanism
+ *
+ * This wrapper automatically converts array inputs to Float32Array.
+ */
+export declare class MultiHeadAttention {
+    private inner;
+    readonly dim: number;
+    readonly numHeads: number;
+    /**
+     * Create a new multi-head attention instance
+     *
+     * @param dim - Embedding dimension (must be divisible by numHeads)
+     * @param numHeads - Number of attention heads
+     */
+    constructor(dim: number, numHeads: number);
+    /**
+     * 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: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[]): AttentionOutput;
+    /**
+     * Compute and return raw Float32Array (faster, no conversion)
+     */
+    computeRaw(query: Float32Array, keys: Float32Array[], values: Float32Array[]): Float32Array;
+    get headDim(): number;
+}
+/**
+ * Flash attention with tiled computation
+ */
+export declare class FlashAttention {
+    private inner;
+    readonly dim: number;
+    readonly blockSize: number;
+    /**
+     * Create a new flash attention instance
+     *
+     * @param dim - Embedding dimension
+     * @param blockSize - Block size for tiled computation (default: 512)
+     */
+    constructor(dim: number, blockSize?: number);
+    /**
+     * Compute flash attention
+     */
+    compute(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[]): AttentionOutput;
+    computeRaw(query: Float32Array, keys: Float32Array[], values: Float32Array[]): Float32Array;
+}
+/**
+ * Hyperbolic attention in Poincare ball model
+ */
+export declare class HyperbolicAttention {
+    private inner;
+    readonly dim: number;
+    readonly curvature: number;
+    /**
+     * Create a new hyperbolic attention instance
+     *
+     * @param dim - Embedding dimension
+     * @param curvature - Hyperbolic curvature (typically 1.0)
+     */
+    constructor(dim: number, curvature?: number);
+    /**
+     * Compute hyperbolic attention
+     */
+    compute(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[]): AttentionOutput;
+    computeRaw(query: Float32Array, keys: Float32Array[], values: Float32Array[]): Float32Array;
+}
+/**
+ * Linear attention (Performer-style) with O(n) complexity
+ */
+export declare class LinearAttention {
+    private inner;
+    readonly dim: number;
+    readonly numFeatures: number;
+    /**
+     * Create a new linear attention instance
+     *
+     * @param dim - Embedding dimension
+     * @param numFeatures - Number of random features
+     */
+    constructor(dim: number, numFeatures: number);
+    /**
+     * Compute linear attention
+     */
+    compute(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[]): AttentionOutput;
+    computeRaw(query: Float32Array, keys: Float32Array[], values: Float32Array[]): Float32Array;
+}
+/**
+ * Local-global attention (Longformer-style)
+ */
+export declare class LocalGlobalAttention {
+    private inner;
+    readonly dim: number;
+    readonly localWindow: number;
+    readonly globalTokens: number;
+    /**
+     * 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: number, localWindow: number, globalTokens: number);
+    /**
+     * Compute local-global attention
+     */
+    compute(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[]): AttentionOutput;
+    computeRaw(query: Float32Array, keys: Float32Array[], values: Float32Array[]): Float32Array;
+}
+/**
+ * MoE configuration
+ */
+export interface MoEConfig {
+    dim: number;
+    numExperts: number;
+    topK: number;
+    expertCapacity?: number;
+}
+/**
+ * Mixture of Experts attention
+ */
+export declare class MoEAttention {
+    private inner;
+    readonly config: MoEConfig;
+    /**
+     * Create a new MoE attention instance
+     *
+     * @param config - MoE configuration
+     */
+    constructor(config: MoEConfig);
+    /**
+     * Create with simple parameters
+     */
+    static simple(dim: number, numExperts: number, topK: number): MoEAttention;
+    /**
+     * Compute MoE attention
+     */
+    compute(query: number[] | Float32Array, keys: (number[] | Float32Array)[], values: (number[] | Float32Array)[]): AttentionOutput;
+    computeRaw(query: Float32Array, keys: Float32Array[], values: Float32Array[]): Float32Array;
+}
+/**
+ * Project a vector into the Poincare ball
+ */
+export declare function projectToPoincareBall(vector: number[] | Float32Array, curvature?: number): number[];
+/**
+ * Compute hyperbolic (Poincare) distance between two points
+ */
+export declare function poincareDistance(a: number[] | Float32Array, b: number[] | Float32Array, curvature?: number): number;
+/**
+ * Mobius addition in hyperbolic space
+ */
+export declare function mobiusAddition(a: number[] | Float32Array, b: number[] | Float32Array, curvature?: number): number[];
+/**
+ * Exponential map from tangent space to hyperbolic space
+ */
+export declare function expMap(base: number[] | Float32Array, tangent: number[] | Float32Array, curvature?: number): number[];
+/**
+ * Logarithmic map from hyperbolic space to tangent space
+ */
+export declare function logMap(base: number[] | Float32Array, point: number[] | Float32Array, curvature?: number): number[];
+/**
+ * Check if attention module is available
+ */
+export declare function isAttentionAvailable(): boolean;
+/**
+ * Get attention module version
+ */
+export declare function getAttentionVersion(): string | null;
+declare const _default: {
+    MultiHeadAttention: typeof MultiHeadAttention;
+    FlashAttention: typeof FlashAttention;
+    HyperbolicAttention: typeof HyperbolicAttention;
+    LinearAttention: typeof LinearAttention;
+    LocalGlobalAttention: typeof LocalGlobalAttention;
+    MoEAttention: typeof MoEAttention;
+    projectToPoincareBall: typeof projectToPoincareBall;
+    poincareDistance: typeof poincareDistance;
+    mobiusAddition: typeof mobiusAddition;
+    expMap: typeof expMap;
+    logMap: typeof logMap;
+    isAttentionAvailable: typeof isAttentionAvailable;
+    getAttentionVersion: typeof getAttentionVersion;
+};
+export default _default;
+//# sourceMappingURL=attention-fallbacks.d.ts.map