ruvector 0.2.16 → 0.2.17

package/dist/core/core/agentdb-fast.js

@@ -1,301 +0,0 @@
-"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/core/intelligence-engine.d.ts

@@ -1,257 +0,0 @@
-/**
- * IntelligenceEngine - Full RuVector Intelligence Stack
- *
- * Integrates all RuVector capabilities for self-learning hooks:
- * - VectorDB with HNSW for semantic memory (150x faster)
- * - SONA for continual learning (Micro-LoRA, EWC++)
- * - FastAgentDB for episode/trajectory storage
- * - Attention mechanisms for pattern recognition
- * - ReasoningBank for pattern clustering
- *
- * Replaces the simple Q-learning approach with real ML-powered intelligence.
- */
-import { EpisodeSearchResult } from './agentdb-fast';
-import { SonaConfig, LearnedPattern } from './sona-wrapper';
-import { ParallelConfig, BatchEpisode } from './parallel-intelligence';
-export interface MemoryEntry {
-    id: string;
-    content: string;
-    type: string;
-    embedding: number[];
-    created: string;
-    accessed: number;
-    score?: number;
-}
-export interface AgentRoute {
-    agent: string;
-    confidence: number;
-    reason: string;
-    patterns?: LearnedPattern[];
-    alternates?: Array<{
-        agent: string;
-        confidence: number;
-    }>;
-}
-export interface LearningStats {
-    totalMemories: number;
-    memoryDimensions: number;
-    totalEpisodes: number;
-    totalTrajectories: number;
-    avgReward: number;
-    sonaEnabled: boolean;
-    trajectoriesRecorded: number;
-    patternsLearned: number;
-    microLoraUpdates: number;
-    baseLoraUpdates: number;
-    ewcConsolidations: number;
-    routingPatterns: number;
-    errorPatterns: number;
-    coEditPatterns: number;
-    workerTriggers: number;
-    attentionEnabled: boolean;
-    onnxEnabled: boolean;
-    parallelEnabled: boolean;
-    parallelWorkers: number;
-    parallelBusy: number;
-    parallelQueued: number;
-}
-export interface IntelligenceConfig {
-    /** Embedding dimension for vectors (default: 256, 384 for ONNX) */
-    embeddingDim?: number;
-    /** Maximum memories to store (default: 100000) */
-    maxMemories?: number;
-    /** Maximum episodes for trajectory storage (default: 50000) */
-    maxEpisodes?: number;
-    /** Enable SONA continual learning (default: true if available) */
-    enableSona?: boolean;
-    /** Enable attention mechanisms (default: true if available) */
-    enableAttention?: boolean;
-    /** Enable ONNX semantic embeddings (default: false, opt-in for quality) */
-    enableOnnx?: boolean;
-    /** SONA configuration */
-    sonaConfig?: Partial<SonaConfig>;
-    /** Storage path for persistence */
-    storagePath?: string;
-    /** Learning rate for pattern updates (default: 0.1) */
-    learningRate?: number;
-    /**
-     * Enable parallel workers for batch operations
-     * Auto-enabled for MCP servers, disabled for CLI hooks
-     */
-    parallelConfig?: Partial<ParallelConfig>;
-}
-/**
- * Full-stack intelligence engine using all RuVector capabilities
- */
-export declare class IntelligenceEngine {
-    private config;
-    private vectorDb;
-    private agentDb;
-    private sona;
-    private attention;
-    private onnxEmbedder;
-    private onnxReady;
-    private parallel;
-    private memories;
-    private routingPatterns;
-    private errorPatterns;
-    private coEditPatterns;
-    private agentMappings;
-    private workerTriggerMappings;
-    private currentTrajectoryId;
-    private sessionStart;
-    private learningEnabled;
-    private episodeBatchQueue;
-    constructor(config?: IntelligenceConfig);
-    private initOnnx;
-    private initVectorDb;
-    private initParallel;
-    /**
-     * Generate embedding using ONNX, attention, or hash (in order of preference)
-     */
-    embed(text: string): number[];
-    /**
-     * Async embedding with ONNX support (recommended for semantic quality)
-     */
-    embedAsync(text: string): Promise<number[]>;
-    /**
-     * Attention-based embedding using Flash or Multi-head attention
-     */
-    private attentionEmbed;
-    /**
-     * Improved hash-based embedding with positional encoding
-     */
-    private hashEmbed;
-    private tokenize;
-    private tokenEmbed;
-    private meanPool;
-    /**
-     * Store content in vector memory (uses ONNX if available)
-     */
-    remember(content: string, type?: string): Promise<MemoryEntry>;
-    /**
-     * Semantic search of memories (uses ONNX if available)
-     */
-    recall(query: string, topK?: number): Promise<MemoryEntry[]>;
-    private cosineSimilarity;
-    /**
-     * Route a task to the best agent using learned patterns
-     */
-    route(task: string, file?: string): Promise<AgentRoute>;
-    private getExtension;
-    private getState;
-    private getAlternates;
-    /**
-     * Begin recording a trajectory (before edit/command)
-     */
-    beginTrajectory(context: string, file?: string): void;
-    /**
-     * Add a step to the current trajectory
-     */
-    addTrajectoryStep(activations: number[], reward: number): void;
-    /**
-     * End the current trajectory with a quality score
-     */
-    endTrajectory(success: boolean, quality?: number): void;
-    /**
-     * Set the agent route for current trajectory
-     */
-    setTrajectoryRoute(agent: string): void;
-    /**
-     * Record an episode for learning
-     */
-    recordEpisode(state: string, action: string, reward: number, nextState: string, done: boolean, metadata?: Record<string, any>): Promise<void>;
-    /**
-     * Queue episode for batch processing (3-4x faster with workers)
-     */
-    queueEpisode(episode: BatchEpisode): void;
-    /**
-     * Process queued episodes in parallel batch
-     */
-    flushEpisodeBatch(): Promise<number>;
-    /**
-     * Learn from similar past episodes
-     */
-    learnFromSimilar(state: string, k?: number): Promise<EpisodeSearchResult[]>;
-    /**
-     * Register worker trigger to agent mappings
-     */
-    registerWorkerTrigger(trigger: string, priority: string, agents: string[]): void;
-    /**
-     * Get agents for a worker trigger
-     */
-    getAgentsForTrigger(trigger: string): {
-        priority: string;
-        agents: string[];
-    } | undefined;
-    /**
-     * Route a task using worker trigger patterns first, then fall back to regular routing
-     */
-    routeWithWorkers(task: string, file?: string): Promise<AgentRoute>;
-    /**
-     * Initialize default worker trigger mappings
-     */
-    initDefaultWorkerMappings(): void;
-    /**
-     * Record a co-edit pattern
-     */
-    recordCoEdit(file1: string, file2: string): void;
-    /**
-     * Get likely next files to edit
-     */
-    getLikelyNextFiles(file: string, topK?: number): Array<{
-        file: string;
-        count: number;
-    }>;
-    /**
-     * Record an error pattern with fixes
-     */
-    recordErrorFix(errorPattern: string, fix: string): void;
-    /**
-     * Get suggested fixes for an error
-     */
-    getSuggestedFixes(error: string): string[];
-    /**
-     * Run background learning cycle
-     */
-    tick(): string | null;
-    /**
-     * Force immediate learning
-     */
-    forceLearn(): string | null;
-    /**
-     * Get comprehensive learning statistics
-     */
-    getStats(): LearningStats;
-    /**
-     * Export all data for persistence
-     */
-    export(): Record<string, any>;
-    /**
-     * Import data from persistence
-     */
-    import(data: Record<string, any>, merge?: boolean): void;
-    /**
-     * Clear all data
-     */
-    clear(): void;
-    /** Legacy: patterns object */
-    get patterns(): Record<string, Record<string, number>>;
-    /** Legacy: file_sequences array */
-    get file_sequences(): string[][];
-    /** Legacy: errors object */
-    get errors(): Record<string, string[]>;
-}
-/**
- * Create a new IntelligenceEngine with default settings
- */
-export declare function createIntelligenceEngine(config?: IntelligenceConfig): IntelligenceEngine;
-/**
- * Create a high-performance engine with all features enabled
- */
-export declare function createHighPerformanceEngine(): IntelligenceEngine;
-/**
- * Create a lightweight engine for fast startup
- */
-export declare function createLightweightEngine(): IntelligenceEngine;
-export default IntelligenceEngine;