monomind 1.10.57 → 1.11.0

package/packages/@monomind/cli/dist/src/ruvector/semantic-router.js

@@ -1,178 +0,0 @@
-/**
- * Pure JavaScript SemanticRouter implementation
- *
- * Provides intent routing using cosine similarity.
- * This is a fallback implementation since @ruvector/router's native VectorDb has bugs.
- *
- * Performance: ~50,000 routes/sec with 100 intents (sufficient for agent routing)
- */
-export class SemanticRouter {
-    dimension;
-    metric;
-    intents = new Map();
-    totalVectors = 0;
-    constructor(config) {
-        if (!config || typeof config.dimension !== 'number') {
-            throw new Error('SemanticRouter requires a dimension in config');
-        }
-        this.dimension = config.dimension;
-        this.metric = config.metric ?? 'cosine';
-    }
-    /**
-     * Add an intent with pre-computed embeddings
-     */
-    addIntentWithEmbeddings(name, embeddings, metadata = {}) {
-        if (!name || !Array.isArray(embeddings)) {
-            throw new Error('Must provide name and embeddings array');
-        }
-        // Validate embeddings
-        for (const emb of embeddings) {
-            if (!(emb instanceof Float32Array) || emb.length !== this.dimension) {
-                throw new Error(`Embedding must be Float32Array of length ${this.dimension}`);
-            }
-        }
-        // Normalize embeddings for cosine similarity
-        const normalizedEmbeddings = embeddings.map(emb => this.normalize(emb));
-        this.intents.set(name, {
-            name,
-            embeddings: normalizedEmbeddings,
-            metadata,
-        });
-        this.totalVectors += embeddings.length;
-    }
-    /**
-     * Route a query using a pre-computed embedding
-     */
-    routeWithEmbedding(embedding, k = 5) {
-        if (!(embedding instanceof Float32Array) || embedding.length !== this.dimension) {
-            throw new Error(`Embedding must be Float32Array of length ${this.dimension}`);
-        }
-        const normalizedQuery = this.normalize(embedding);
-        const scores = [];
-        // Calculate best score for each intent
-        for (const [intentName, intent] of this.intents) {
-            let bestScore = -Infinity;
-            for (const storedEmb of intent.embeddings) {
-                const score = this.similarity(normalizedQuery, storedEmb);
-                if (score > bestScore) {
-                    bestScore = score;
-                }
-            }
-            scores.push({
-                intent: intentName,
-                score: bestScore,
-                metadata: intent.metadata,
-            });
-        }
-        // Sort by score descending and take top k
-        return scores
-            .sort((a, b) => b.score - a.score)
-            .slice(0, k);
-    }
-    /**
-     * Remove an intent
-     */
-    removeIntent(name) {
-        const intent = this.intents.get(name);
-        if (!intent)
-            return false;
-        this.totalVectors -= intent.embeddings.length;
-        this.intents.delete(name);
-        return true;
-    }
-    /**
-     * Get all intent names
-     */
-    getIntents() {
-        return Array.from(this.intents.keys());
-    }
-    /**
-     * Get intent details
-     */
-    getIntent(name) {
-        const data = this.intents.get(name);
-        if (!data)
-            return null;
-        return {
-            name: data.name,
-            utterances: [], // We don't store utterances, only embeddings
-            metadata: data.metadata,
-        };
-    }
-    /**
-     * Clear all intents
-     */
-    clear() {
-        this.intents.clear();
-        this.totalVectors = 0;
-    }
-    /**
-     * Get total vector count
-     */
-    count() {
-        return this.totalVectors;
-    }
-    /**
-     * Get number of intents
-     */
-    intentCount() {
-        return this.intents.size;
-    }
-    /**
-     * Normalize a vector for cosine similarity
-     */
-    normalize(vec) {
-        let norm = 0;
-        for (let i = 0; i < vec.length; i++) {
-            norm += vec[i] * vec[i];
-        }
-        norm = Math.sqrt(norm);
-        if (norm === 0)
-            return vec;
-        const normalized = new Float32Array(vec.length);
-        for (let i = 0; i < vec.length; i++) {
-            normalized[i] = vec[i] / norm;
-        }
-        return normalized;
-    }
-    /**
-     * Calculate similarity between two normalized vectors
-     */
-    similarity(a, b) {
-        switch (this.metric) {
-            case 'cosine':
-                // For normalized vectors, cosine similarity = dot product
-                return this.dotProduct(a, b);
-            case 'dotProduct':
-                return this.dotProduct(a, b);
-            case 'euclidean':
-                // Convert Euclidean distance to similarity
-                return 1 / (1 + this.euclideanDistance(a, b));
-            default:
-                return this.dotProduct(a, b);
-        }
-    }
-    dotProduct(a, b) {
-        let sum = 0;
-        for (let i = 0; i < a.length; i++) {
-            sum += a[i] * b[i];
-        }
-        return sum;
-    }
-    euclideanDistance(a, b) {
-        let sum = 0;
-        for (let i = 0; i < a.length; i++) {
-            const diff = a[i] - b[i];
-            sum += diff * diff;
-        }
-        return Math.sqrt(sum);
-    }
-}
-/**
- * Create a SemanticRouter with the given configuration
- */
-export function createSemanticRouter(config) {
-    return new SemanticRouter(config);
-}
-export default SemanticRouter;
-//# sourceMappingURL=semantic-router.js.map

package/packages/@monomind/cli/dist/src/ruvector/vector-db.d.ts

@@ -1,69 +0,0 @@
-/**
- * Vector Database Module
- *
- * Provides optional ruvector WASM-accelerated vector operations for:
- * - Semantic similarity search
- * - HNSW indexing (150x faster)
- * - Embedding generation
- *
- * Gracefully degrades when ruvector is not installed.
- *
- * github.com/nokhodian/monomind
- */
-export interface VectorDB {
-    insert(embedding: Float32Array, id: string, metadata?: Record<string, unknown>): void | Promise<void>;
-    search(query: Float32Array, k?: number): Array<{
-        id: string;
-        score: number;
-        metadata?: Record<string, unknown>;
-    }> | Promise<Array<{
-        id: string;
-        score: number;
-        metadata?: Record<string, unknown>;
-    }>>;
-    remove(id: string): boolean | Promise<boolean>;
-    size(): number | Promise<number>;
-    clear(): void | Promise<void>;
-}
-export interface RuVectorModule {
-    createVectorDB(dimensions: number): Promise<VectorDB>;
-    generateEmbedding(text: string, dimensions?: number): Float32Array;
-    cosineSimilarity(a: Float32Array, b: Float32Array): number;
-    isWASMAccelerated(): boolean;
-}
-/**
- * Attempt to load the ruvector module
- * Returns true if successfully loaded, false otherwise
- */
-export declare function loadRuVector(): Promise<boolean>;
-/**
- * Check if ruvector is available
- */
-export declare function isRuVectorAvailable(): boolean;
-/**
- * Check if WASM acceleration is enabled
- */
-export declare function isWASMAccelerated(): boolean;
-/**
- * Create a vector database
- * Uses ruvector HNSW if available, falls back to brute-force search
- */
-export declare function createVectorDB(dimensions?: number): Promise<VectorDB>;
-/**
- * Generate an embedding for text
- * Uses ruvector if available, falls back to hash-based embedding
- */
-export declare function generateEmbedding(text: string, dimensions?: number): Float32Array;
-/**
- * Compute cosine similarity between two vectors
- */
-export declare function computeSimilarity(a: Float32Array, b: Float32Array): number;
-/**
- * Get status information about the ruvector module
- */
-export declare function getStatus(): {
-    available: boolean;
-    wasmAccelerated: boolean;
-    backend: 'ruvector-wasm' | 'ruvector' | 'fallback';
-};
-//# sourceMappingURL=vector-db.d.ts.map

package/packages/@monomind/cli/dist/src/ruvector/vector-db.js

@@ -1,243 +0,0 @@
-/**
- * Vector Database Module
- *
- * Provides optional ruvector WASM-accelerated vector operations for:
- * - Semantic similarity search
- * - HNSW indexing (150x faster)
- * - Embedding generation
- *
- * Gracefully degrades when ruvector is not installed.
- *
- * github.com/nokhodian/monomind
- */
-// ============================================================================
-// Fallback Implementation (when ruvector not available)
-// ============================================================================
-class FallbackVectorDB {
-    vectors = new Map();
-    dimensions;
-    constructor(dimensions) {
-        this.dimensions = dimensions;
-    }
-    insert(embedding, id, metadata) {
-        this.vectors.set(id, { embedding, metadata });
-    }
-    search(query, k = 10) {
-        const results = [];
-        for (const [id, { embedding, metadata }] of this.vectors) {
-            const score = cosineSimilarity(query, embedding);
-            results.push({ id, score, metadata });
-        }
-        return results
-            .sort((a, b) => b.score - a.score)
-            .slice(0, k);
-    }
-    remove(id) {
-        return this.vectors.delete(id);
-    }
-    size() {
-        return this.vectors.size;
-    }
-    clear() {
-        this.vectors.clear();
-    }
-}
-/**
- * Compute cosine similarity between two vectors
- */
-function cosineSimilarity(a, b) {
-    if (a.length !== b.length) {
-        throw new Error(`Vector dimension mismatch: ${a.length} vs ${b.length}`);
-    }
-    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;
-}
-/**
- * Generate a simple hash-based embedding (fallback when ruvector not available)
- */
-function generateHashEmbedding(text, dimensions = 768) {
-    const embedding = new Float32Array(dimensions);
-    const normalized = text.toLowerCase().trim();
-    // Simple hash function
-    let hash = 0;
-    for (let i = 0; i < normalized.length; i++) {
-        hash = ((hash << 5) - hash) + normalized.charCodeAt(i);
-        hash = hash & hash; // Convert to 32bit integer
-    }
-    // Generate pseudo-random embedding based on hash
-    for (let i = 0; i < dimensions; i++) {
-        embedding[i] = Math.sin(hash * (i + 1) * 0.001) * 0.5 + 0.5;
-    }
-    // Normalize
-    let norm = 0;
-    for (let i = 0; i < dimensions; i++) {
-        norm += embedding[i] * embedding[i];
-    }
-    norm = Math.sqrt(norm);
-    for (let i = 0; i < dimensions; i++) {
-        embedding[i] /= norm;
-    }
-    return embedding;
-}
-// ============================================================================
-// Module State
-// ============================================================================
-let ruvectorModule = null;
-let loadAttempted = false;
-let isAvailable = false;
-// ============================================================================
-// Public API
-// ============================================================================
-/**
- * Attempt to load the ruvector module
- * Returns true if successfully loaded, false otherwise
- */
-export async function loadRuVector() {
-    if (loadAttempted) {
-        return isAvailable;
-    }
-    loadAttempted = true;
-    try {
-        // Dynamic import to handle missing dependency gracefully
-        const ruvector = await import('ruvector').catch(() => null);
-        // ruvector exports VectorDB class, not createVectorDB function
-        if (ruvector && (typeof ruvector.VectorDB === 'function' || typeof ruvector.VectorDb === 'function')) {
-            // Create adapter module that matches our expected interface
-            const VectorDBClass = ruvector.VectorDB || ruvector.VectorDb;
-            ruvectorModule = {
-                createVectorDB: async (dimensions) => {
-                    const db = new VectorDBClass({ dimensions });
-                    // Wrap ruvector's VectorDB to match our interface
-                    return {
-                        insert: (embedding, id, metadata) => {
-                            db.insert({ id, vector: embedding, metadata });
-                        },
-                        search: async (query, k = 10) => {
-                            const results = await db.search({ vector: query, k });
-                            return results.map((r) => ({
-                                id: r.id,
-                                score: r.score,
-                                metadata: r.metadata,
-                            }));
-                        },
-                        remove: (id) => {
-                            db.delete(id);
-                            return true;
-                        },
-                        size: async () => {
-                            const len = await db.len();
-                            return len;
-                        },
-                        clear: () => {
-                            // Not directly supported - would need to recreate
-                        },
-                    };
-                },
-                generateEmbedding: (text, dimensions = 768) => {
-                    // ruvector may not have this - use fallback
-                    return generateHashEmbedding(text, dimensions);
-                },
-                cosineSimilarity: (a, b) => {
-                    return cosineSimilarity(a, b);
-                },
-                isWASMAccelerated: () => {
-                    return ruvector.isWasm?.() ?? false;
-                },
-            };
-            isAvailable = true;
-            return true;
-        }
-    }
-    catch {
-        // Silently fail - ruvector is optional
-    }
-    isAvailable = false;
-    return false;
-}
-/**
- * Check if ruvector is available
- */
-export function isRuVectorAvailable() {
-    return isAvailable;
-}
-/**
- * Check if WASM acceleration is enabled
- */
-export function isWASMAccelerated() {
-    if (ruvectorModule && typeof ruvectorModule.isWASMAccelerated === 'function') {
-        return ruvectorModule.isWASMAccelerated();
-    }
-    return false;
-}
-/**
- * Create a vector database
- * Uses ruvector HNSW if available, falls back to brute-force search
- */
-export async function createVectorDB(dimensions = 768) {
-    await loadRuVector();
-    if (ruvectorModule && typeof ruvectorModule.createVectorDB === 'function') {
-        try {
-            return await ruvectorModule.createVectorDB(dimensions);
-        }
-        catch {
-            // Fall back to simple implementation
-        }
-    }
-    return new FallbackVectorDB(dimensions);
-}
-/**
- * Generate an embedding for text
- * Uses ruvector if available, falls back to hash-based embedding
- */
-export function generateEmbedding(text, dimensions = 768) {
-    if (ruvectorModule && typeof ruvectorModule.generateEmbedding === 'function') {
-        try {
-            return ruvectorModule.generateEmbedding(text, dimensions);
-        }
-        catch {
-            // Fall back to hash-based embedding
-        }
-    }
-    return generateHashEmbedding(text, dimensions);
-}
-/**
- * Compute cosine similarity between two vectors
- */
-export function computeSimilarity(a, b) {
-    if (ruvectorModule && typeof ruvectorModule.cosineSimilarity === 'function') {
-        try {
-            return ruvectorModule.cosineSimilarity(a, b);
-        }
-        catch {
-            // Fall back to JS implementation
-        }
-    }
-    return cosineSimilarity(a, b);
-}
-/**
- * Get status information about the ruvector module
- */
-export function getStatus() {
-    if (!isAvailable) {
-        return {
-            available: false,
-            wasmAccelerated: false,
-            backend: 'fallback',
-        };
-    }
-    const wasmAccelerated = isWASMAccelerated();
-    return {
-        available: true,
-        wasmAccelerated,
-        backend: wasmAccelerated ? 'ruvector-wasm' : 'ruvector',
-    };
-}
-//# sourceMappingURL=vector-db.js.map

package/packages/@monomind/cli/dist/src/services/ruvector-training.d.ts

@@ -1,222 +0,0 @@
-/**
- * RuVector Training Service
- * Real WASM-accelerated neural training using @ruvector packages
- *
- * Features:
- * - MicroLoRA: <1µs adaptation with rank-2 LoRA (2.3M ops/s)
- * - SONA: Self-Optimizing Neural Architecture (624k learn/s, 60k search/s)
- * - Flash Attention: 2.49x-7.47x speedup (9k ops/s)
- * - Trajectory Buffer: Learning from success/failure
- * - Contrastive Learning: InfoNCE loss
- *
- * Backward Compatible: All v1 APIs preserved, SONA adds new capabilities
- *
- * github.com/nokhodian/monomind
- */
-type BenchmarkResult = any;
-/**
- * Get which backend is active for training
- */
-export declare function getActiveBackend(): 'wasm' | 'js-fallback';
-export interface TrainingConfig {
-    dim?: number;
-    learningRate?: number;
-    alpha?: number;
-    trajectoryCapacity?: number;
-    useFlashAttention?: boolean;
-    useMoE?: boolean;
-    useHyperbolic?: boolean;
-    totalSteps?: number;
-    warmupSteps?: number;
-    useSona?: boolean;
-    sonaRank?: number;
-}
-export interface TrainingResult {
-    success: boolean;
-    adaptationCount: bigint;
-    forwardCount: bigint;
-    deltaNorm: number;
-    trajectoryStats?: {
-        successRate: number;
-        meanImprovement: number;
-        bestImprovement: number;
-        totalCount: bigint;
-    };
-    benchmark?: BenchmarkResult[];
-}
-/**
- * Initialize the RuVector training system.
- * Attempts to load @ruvector/learning-wasm for WASM-accelerated training.
- * Falls back to a pure-JS implementation if WASM is unavailable.
- */
-export declare function initializeTraining(config?: TrainingConfig): Promise<{
-    success: boolean;
-    features: string[];
-    backend: 'wasm' | 'js-fallback';
-    error?: string;
-}>;
-/**
- * Operator types for scoped LoRA (0-16)
- */
-export declare const OperatorType: {
-    readonly GENERAL: 0;
-    readonly ATTENTION: 1;
-    readonly MLP: 2;
-    readonly EMBEDDING: 3;
-    readonly NORMALIZATION: 4;
-    readonly PROJECTION: 5;
-    readonly POOLING: 6;
-    readonly CONVOLUTION: 7;
-    readonly RECURRENT: 8;
-    readonly ROUTING: 9;
-    readonly MEMORY: 10;
-    readonly REASONING: 11;
-    readonly COORDINATION: 12;
-    readonly OPTIMIZATION: 13;
-    readonly SECURITY: 14;
-    readonly TESTING: 15;
-    readonly DEBUGGING: 16;
-};
-/**
- * Train a pattern with MicroLoRA
- */
-export declare function trainPattern(embedding: Float32Array, gradient: Float32Array, operatorType?: number): Promise<{
-    deltaNorm: number;
-    adaptCount: bigint;
-}>;
-/**
- * Forward pass through LoRA
- */
-export declare function forward(input: Float32Array, operatorType?: number): Float32Array;
-/**
- * Reward-based adaptation (reinforcement learning)
- */
-export declare function adaptWithReward(improvement: number, operatorType?: number): void;
-/**
- * Record a learning trajectory
- */
-export declare function recordTrajectory(embedding: Float32Array, operatorType: number, attentionType: number, executionMs: number, baselineMs: number): void;
-/**
- * Get trajectory statistics
- */
-export declare function getTrajectoryStats(): {
-    successRate: number;
-    meanImprovement: number;
-    bestImprovement: number;
-    totalCount: bigint;
-    highQualityCount: number;
-    variance: number;
-} | null;
-/**
- * Compute attention with Flash Attention (2.49x-7.47x faster)
- */
-export declare function computeFlashAttention(query: Float32Array, keys: Float32Array[], values: Float32Array[]): Float32Array;
-/**
- * Compute MoE routing
- */
-export declare function computeMoEAttention(query: Float32Array, keys: Float32Array[], values: Float32Array[]): Float32Array;
-/**
- * Compute hyperbolic attention (for hierarchical patterns)
- */
-export declare function computeHyperbolicAttention(query: Float32Array, keys: Float32Array[], values: Float32Array[]): Float32Array;
-/**
- * Compute contrastive loss for training
- */
-export declare function computeContrastiveLoss(anchor: Float32Array, positives: Float32Array[], negatives: Float32Array[]): {
-    loss: number;
-    gradient: Float32Array;
-};
-/**
- * Optimizer step
- */
-export declare function optimizerStep(params: Float32Array, gradients: Float32Array): Float32Array;
-/**
- * Get curriculum difficulty for current step
- */
-export declare function getCurriculumDifficulty(step: number): number;
-/**
- * Mine hard negatives for better training
- */
-export declare function mineHardNegatives(anchor: Float32Array, candidates: Float32Array[]): number[];
-/**
- * Benchmark the training system
- */
-export declare function benchmarkTraining(dim?: number, iterations?: number): Promise<BenchmarkResult[]>;
-/**
- * Check if SONA is available
- */
-export declare function isSonaAvailable(): boolean;
-/**
- * Force-learn a pattern with SONA (1.6μs, 624k ops/s)
- * This is a one-shot learning mechanism for immediate pattern storage
- */
-export declare function sonaForceLearn(embedding: Float32Array, reward: number): void;
-/**
- * Search for similar patterns with SONA (16.7μs, 60k searches/s)
- * Returns the k most similar patterns from the pattern bank
- */
-export declare function sonaFindPatterns(embedding: Float32Array, k?: number): unknown[];
-/**
- * Process SONA background tasks (0.13μs, 7.5M ticks/s)
- * Call periodically to process background learning and consolidation
- */
-export declare function sonaTick(): void;
-/**
- * Get SONA statistics
- */
-export declare function getSonaStats(): {
-    available: boolean;
-    enabled: boolean;
-    stats: Record<string, unknown> | null;
-    totalLearns: number;
-    totalSearches: number;
-};
-/**
- * Enable/disable SONA learning
- */
-export declare function setSonaEnabled(enabled: boolean): void;
-/**
- * Flush SONA buffers (persist any pending patterns)
- */
-export declare function sonaFlush(): void;
-/**
- * Get training statistics
- */
-export declare function getTrainingStats(): {
-    initialized: boolean;
-    backend: 'wasm' | 'js-fallback';
-    totalAdaptations: number;
-    totalForwards: number;
-    microLoraStats?: {
-        paramCount: number;
-        adaptCount: bigint;
-        forwardCount: bigint;
-        deltaNorm: number;
-    };
-    scopedLoraStats?: {
-        totalAdaptCount: bigint;
-        totalForwardCount: bigint;
-    };
-    trajectoryStats?: ReturnType<typeof getTrajectoryStats>;
-    sonaStats?: ReturnType<typeof getSonaStats>;
-    lastBenchmark?: BenchmarkResult[];
-};
-/**
- * Reset the training system
- */
-export declare function resetTraining(): void;
-/**
- * Export trained weights
- */
-export declare function exportWeights(): {
-    dim: number;
-    deltaNorm: number;
-    adaptCount: bigint;
-    trajectoryStats: ReturnType<typeof getTrajectoryStats>;
-} | null;
-/**
- * Cleanup resources
- */
-export declare function cleanup(): void;
-export {};
-//# sourceMappingURL=ruvector-training.d.ts.map