agentic-flow 2.0.1-alpha.13 → 2.0.1-alpha.15

package/dist/intelligence/EmbeddingService.d.ts

@@ -0,0 +1,168 @@
+/**
+ * EmbeddingService - Unified embedding interface for agentic-flow
+ *
+ * Uses ruvector@0.1.61+ for ONNX embeddings with:
+ * - SIMD128 acceleration (6x faster)
+ * - Parallel worker threads (7 workers)
+ * - all-MiniLM-L6-v2 model (384 dimensions)
+ *
+ * Configure via:
+ * - AGENTIC_FLOW_EMBEDDINGS=simple|onnx|auto (default: auto)
+ * - AGENTIC_FLOW_EMBEDDING_MODEL=all-MiniLM-L6-v2 (default)
+ */
+export type EmbeddingBackend = 'simple' | 'onnx' | 'auto';
+export interface EmbeddingStats {
+    backend: EmbeddingBackend;
+    effectiveBackend: EmbeddingBackend;
+    dimension: number;
+    totalEmbeddings: number;
+    totalLatencyMs: number;
+    avgLatencyMs: number;
+    cacheHits: number;
+    modelLoaded: boolean;
+    modelName?: string;
+    simdAvailable?: boolean;
+    parallelWorkers?: number;
+}
+export interface SimilarityResult {
+    similarity: number;
+    timeMs: number;
+}
+export interface SearchResult {
+    text: string;
+    index: number;
+    similarity: number;
+}
+export interface DuplicateGroup {
+    indices: number[];
+    texts: string[];
+    similarity: number;
+}
+export declare class EmbeddingService {
+    private static instance;
+    private backend;
+    private effectiveBackend;
+    private dimension;
+    private modelName;
+    private modelLoaded;
+    private loadingPromise;
+    private totalEmbeddings;
+    private totalLatencyMs;
+    private cacheHits;
+    private cache;
+    private cacheEnabled;
+    private corpus;
+    private constructor();
+    static getInstance(): EmbeddingService;
+    /**
+     * Resolve the effective backend based on ONNX detection
+     */
+    private resolveBackend;
+    /**
+     * Get configured backend (may be 'auto')
+     */
+    getBackend(): EmbeddingBackend;
+    /**
+     * Get effective backend after detection
+     */
+    getEffectiveBackend(): EmbeddingBackend;
+    /**
+     * Get embedding dimension
+     */
+    getDimension(): number;
+    /**
+     * Check if ONNX model is loaded
+     */
+    isModelLoaded(): boolean;
+    /**
+     * Generate embedding for text
+     * Auto-detects ONNX and uses it if available (default behavior)
+     */
+    embed(text: string): Promise<Float32Array>;
+    /**
+     * Generate embeddings for multiple texts (batch processing with parallel workers)
+     * Batch processing provides significant speedup with parallel ONNX workers
+     */
+    embedBatch(texts: string[]): Promise<Float32Array[]>;
+    /**
+     * Compute similarity between two texts
+     */
+    similarity(text1: string, text2: string): Promise<number>;
+    /**
+     * Compute NxN similarity matrix for a list of texts
+     * Uses parallel workers for ONNX backend
+     */
+    similarityMatrix(texts: string[]): Promise<number[][]>;
+    /**
+     * Build a corpus for semantic search
+     */
+    buildCorpus(texts: string[]): Promise<void>;
+    /**
+     * Semantic search against the corpus
+     * Returns top-k most similar texts
+     */
+    semanticSearch(query: string, topK?: number): Promise<SearchResult[]>;
+    /**
+     * Find near-duplicate texts in a list
+     * Groups texts with similarity above threshold
+     */
+    findDuplicates(texts: string[], threshold?: number): Promise<DuplicateGroup[]>;
+    /**
+     * K-means clustering of texts
+     * Returns cluster assignments and centroids
+     */
+    clusterTexts(texts: string[], k?: number, maxIterations?: number): Promise<{
+        clusters: number[];
+        centroids: Float32Array[];
+    }>;
+    /**
+     * Stream embeddings for large batches (memory efficient)
+     * Yields embeddings one at a time
+     */
+    streamEmbed(texts: string[], batchSize?: number): AsyncGenerator<{
+        index: number;
+        text: string;
+        embedding: Float32Array;
+    }>;
+    /**
+     * Simple hash-based embedding (fast, not semantic)
+     */
+    simpleEmbed(text: string, dim?: number): Float32Array;
+    /**
+     * Compute cosine similarity between two embeddings
+     */
+    cosineSimilarity(a: Float32Array, b: Float32Array): number;
+    /**
+     * Get statistics
+     */
+    getStats(): EmbeddingStats;
+    /**
+     * Clear cache
+     */
+    clearCache(): void;
+    /**
+     * Clear corpus
+     */
+    clearCorpus(): void;
+    /**
+     * Shutdown (cleanup workers)
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Reset instance (for testing)
+     */
+    static reset(): Promise<void>;
+}
+export declare function getEmbeddingService(): EmbeddingService;
+export declare function embed(text: string): Promise<Float32Array>;
+export declare function embedBatch(texts: string[]): Promise<Float32Array[]>;
+export declare function textSimilarity(text1: string, text2: string): Promise<number>;
+export declare function simpleEmbed(text: string, dim?: number): Float32Array;
+export declare function similarityMatrix(texts: string[]): Promise<number[][]>;
+export declare function semanticSearch(query: string, topK?: number): Promise<SearchResult[]>;
+export declare function findDuplicates(texts: string[], threshold?: number): Promise<DuplicateGroup[]>;
+export declare function clusterTexts(texts: string[], k?: number): Promise<{
+    clusters: number[];
+    centroids: Float32Array[];
+}>;
+//# sourceMappingURL=EmbeddingService.d.ts.map

package/dist/intelligence/EmbeddingService.d.ts.map

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

package/dist/intelligence/EmbeddingService.js

@@ -0,0 +1,526 @@
+/**
+ * EmbeddingService - Unified embedding interface for agentic-flow
+ *
+ * Uses ruvector@0.1.61+ for ONNX embeddings with:
+ * - SIMD128 acceleration (6x faster)
+ * - Parallel worker threads (7 workers)
+ * - all-MiniLM-L6-v2 model (384 dimensions)
+ *
+ * Configure via:
+ * - AGENTIC_FLOW_EMBEDDINGS=simple|onnx|auto (default: auto)
+ * - AGENTIC_FLOW_EMBEDDING_MODEL=all-MiniLM-L6-v2 (default)
+ */
+// ONNX availability cache
+let onnxAvailable = null;
+let ruvectorModule = null;
+/**
+ * Detect ONNX/SIMD support by loading ruvector
+ */
+async function detectOnnx() {
+    if (onnxAvailable !== null) {
+        return onnxAvailable;
+    }
+    try {
+        const mod = await import('ruvector');
+        ruvectorModule = mod;
+        onnxAvailable = mod.isOnnxAvailable?.() ?? false;
+        return onnxAvailable;
+    }
+    catch (error) {
+        // Ruvector loading failed - fall back to simple embeddings
+        onnxAvailable = false;
+        return false;
+    }
+}
+// Simple LRU cache for embeddings
+class EmbeddingCache {
+    cache = new Map();
+    maxSize;
+    constructor(maxSize = 1000) {
+        this.maxSize = maxSize;
+    }
+    get(key) {
+        const value = this.cache.get(key);
+        if (value) {
+            // Move to end (most recently used)
+            this.cache.delete(key);
+            this.cache.set(key, value);
+        }
+        return value;
+    }
+    set(key, value) {
+        if (this.cache.size >= this.maxSize) {
+            // Delete oldest (first) entry
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey) {
+                this.cache.delete(firstKey);
+            }
+        }
+        this.cache.set(key, value);
+    }
+    clear() {
+        this.cache.clear();
+    }
+    get size() {
+        return this.cache.size;
+    }
+}
+export class EmbeddingService {
+    static instance = null;
+    backend;
+    effectiveBackend = null;
+    dimension;
+    modelName;
+    // ONNX state
+    modelLoaded = false;
+    loadingPromise = null;
+    // Stats
+    totalEmbeddings = 0;
+    totalLatencyMs = 0;
+    cacheHits = 0;
+    // Cache
+    cache;
+    cacheEnabled;
+    // Corpus for search operations
+    corpus = { texts: [], embeddings: [] };
+    constructor() {
+        // Default to 'auto' which will detect ONNX and use it if available
+        this.backend = process.env.AGENTIC_FLOW_EMBEDDINGS || 'auto';
+        this.modelName = process.env.AGENTIC_FLOW_EMBEDDING_MODEL || 'all-MiniLM-L6-v2';
+        this.dimension = 256; // Will be updated when ONNX loads (384)
+        this.cacheEnabled = process.env.AGENTIC_FLOW_EMBEDDING_CACHE !== 'false';
+        this.cache = new EmbeddingCache(1000);
+    }
+    static getInstance() {
+        if (!EmbeddingService.instance) {
+            EmbeddingService.instance = new EmbeddingService();
+        }
+        return EmbeddingService.instance;
+    }
+    /**
+     * Resolve the effective backend based on ONNX detection
+     */
+    async resolveBackend() {
+        if (this.effectiveBackend) {
+            return this.effectiveBackend;
+        }
+        if (this.backend === 'auto') {
+            const hasOnnx = await detectOnnx();
+            this.effectiveBackend = hasOnnx ? 'onnx' : 'simple';
+            if (hasOnnx) {
+                this.dimension = 384; // all-MiniLM-L6-v2 dimension
+            }
+        }
+        else {
+            this.effectiveBackend = this.backend;
+            if (this.backend === 'onnx') {
+                await detectOnnx(); // Ensure module is loaded
+                this.dimension = 384;
+            }
+        }
+        return this.effectiveBackend;
+    }
+    /**
+     * Get configured backend (may be 'auto')
+     */
+    getBackend() {
+        return this.backend;
+    }
+    /**
+     * Get effective backend after detection
+     */
+    getEffectiveBackend() {
+        return this.effectiveBackend || this.backend;
+    }
+    /**
+     * Get embedding dimension
+     */
+    getDimension() {
+        return this.dimension;
+    }
+    /**
+     * Check if ONNX model is loaded
+     */
+    isModelLoaded() {
+        return this.modelLoaded;
+    }
+    /**
+     * Generate embedding for text
+     * Auto-detects ONNX and uses it if available (default behavior)
+     */
+    async embed(text) {
+        const startTime = performance.now();
+        // Check cache
+        if (this.cacheEnabled) {
+            const cached = this.cache.get(text);
+            if (cached) {
+                this.cacheHits++;
+                return cached;
+            }
+        }
+        // Resolve backend (handles 'auto' mode)
+        const effectiveBackend = await this.resolveBackend();
+        let embedding;
+        if (effectiveBackend === 'onnx' && ruvectorModule) {
+            const result = await ruvectorModule.embed(text);
+            if (result?.embedding) {
+                embedding = result.embedding;
+                this.modelLoaded = true;
+            }
+            else {
+                embedding = this.simpleEmbed(text);
+            }
+        }
+        else {
+            embedding = this.simpleEmbed(text);
+        }
+        // Update stats
+        this.totalEmbeddings++;
+        this.totalLatencyMs += performance.now() - startTime;
+        // Cache result
+        if (this.cacheEnabled) {
+            this.cache.set(text, embedding);
+        }
+        return embedding;
+    }
+    /**
+     * Generate embeddings for multiple texts (batch processing with parallel workers)
+     * Batch processing provides significant speedup with parallel ONNX workers
+     */
+    async embedBatch(texts) {
+        const startTime = performance.now();
+        // Check cache for all texts first
+        if (this.cacheEnabled) {
+            const cachedResults = texts.map(t => this.cache.get(t) || null);
+            const allCached = cachedResults.every(r => r !== null);
+            if (allCached) {
+                this.cacheHits += texts.length;
+                return cachedResults;
+            }
+        }
+        // Resolve backend
+        const effectiveBackend = await this.resolveBackend();
+        if (effectiveBackend === 'onnx' && ruvectorModule) {
+            const result = await ruvectorModule.embedBatch(texts);
+            if (result?.embeddings && result.embeddings.length === texts.length) {
+                const embeddings = result.embeddings;
+                // Cache individual embeddings
+                if (this.cacheEnabled) {
+                    for (let i = 0; i < texts.length; i++) {
+                        this.cache.set(texts[i], embeddings[i]);
+                    }
+                }
+                // Update stats
+                this.totalEmbeddings += texts.length;
+                this.totalLatencyMs += performance.now() - startTime;
+                this.modelLoaded = true;
+                return embeddings;
+            }
+        }
+        // Fall back to sequential for simple backend
+        return Promise.all(texts.map(t => this.embed(t)));
+    }
+    /**
+     * Compute similarity between two texts
+     */
+    async similarity(text1, text2) {
+        const effectiveBackend = await this.resolveBackend();
+        if (effectiveBackend === 'onnx' && ruvectorModule) {
+            const result = await ruvectorModule.similarity(text1, text2);
+            return result.similarity;
+        }
+        // Fall back to embedding + cosine
+        const [e1, e2] = await Promise.all([this.embed(text1), this.embed(text2)]);
+        return this.cosineSimilarity(e1, e2);
+    }
+    /**
+     * Compute NxN similarity matrix for a list of texts
+     * Uses parallel workers for ONNX backend
+     */
+    async similarityMatrix(texts) {
+        const embeddings = await this.embedBatch(texts);
+        const n = texts.length;
+        const matrix = Array(n).fill(null).map(() => Array(n).fill(0));
+        for (let i = 0; i < n; i++) {
+            matrix[i][i] = 1.0; // Self-similarity
+            for (let j = i + 1; j < n; j++) {
+                const sim = this.cosineSimilarity(embeddings[i], embeddings[j]);
+                matrix[i][j] = sim;
+                matrix[j][i] = sim; // Symmetric
+            }
+        }
+        return matrix;
+    }
+    /**
+     * Build a corpus for semantic search
+     */
+    async buildCorpus(texts) {
+        this.corpus.texts = texts;
+        this.corpus.embeddings = await this.embedBatch(texts);
+    }
+    /**
+     * Semantic search against the corpus
+     * Returns top-k most similar texts
+     */
+    async semanticSearch(query, topK = 5) {
+        if (this.corpus.texts.length === 0) {
+            throw new Error('Corpus not built. Call buildCorpus() first.');
+        }
+        const queryEmbedding = await this.embed(query);
+        const results = [];
+        for (let i = 0; i < this.corpus.texts.length; i++) {
+            const sim = this.cosineSimilarity(queryEmbedding, this.corpus.embeddings[i]);
+            results.push({
+                text: this.corpus.texts[i],
+                index: i,
+                similarity: sim,
+            });
+        }
+        // Sort by similarity (descending) and return top-k
+        results.sort((a, b) => b.similarity - a.similarity);
+        return results.slice(0, topK);
+    }
+    /**
+     * Find near-duplicate texts in a list
+     * Groups texts with similarity above threshold
+     */
+    async findDuplicates(texts, threshold = 0.9) {
+        const embeddings = await this.embedBatch(texts);
+        const n = texts.length;
+        const visited = new Set();
+        const groups = [];
+        for (let i = 0; i < n; i++) {
+            if (visited.has(i))
+                continue;
+            const group = {
+                indices: [i],
+                texts: [texts[i]],
+                similarity: 1.0,
+            };
+            for (let j = i + 1; j < n; j++) {
+                if (visited.has(j))
+                    continue;
+                const sim = this.cosineSimilarity(embeddings[i], embeddings[j]);
+                if (sim >= threshold) {
+                    group.indices.push(j);
+                    group.texts.push(texts[j]);
+                    group.similarity = Math.min(group.similarity, sim);
+                    visited.add(j);
+                }
+            }
+            if (group.indices.length > 1) {
+                visited.add(i);
+                groups.push(group);
+            }
+        }
+        return groups;
+    }
+    /**
+     * K-means clustering of texts
+     * Returns cluster assignments and centroids
+     */
+    async clusterTexts(texts, k = 3, maxIterations = 100) {
+        const embeddings = await this.embedBatch(texts);
+        const n = texts.length;
+        const dim = this.dimension;
+        // Initialize centroids randomly (copy to new ArrayBuffer for consistent typing)
+        const centroidIndices = new Set();
+        while (centroidIndices.size < k && centroidIndices.size < n) {
+            centroidIndices.add(Math.floor(Math.random() * n));
+        }
+        let centroids = Array.from(centroidIndices).map(i => {
+            const copy = new Float32Array(dim);
+            copy.set(embeddings[i]);
+            return copy;
+        });
+        let clusters = new Array(n).fill(0);
+        for (let iter = 0; iter < maxIterations; iter++) {
+            // Assign points to nearest centroid
+            const newClusters = embeddings.map(emb => {
+                let bestCluster = 0;
+                let bestSim = -Infinity;
+                for (let c = 0; c < k; c++) {
+                    const sim = this.cosineSimilarity(emb, centroids[c]);
+                    if (sim > bestSim) {
+                        bestSim = sim;
+                        bestCluster = c;
+                    }
+                }
+                return bestCluster;
+            });
+            // Check convergence
+            const changed = newClusters.some((c, i) => c !== clusters[i]);
+            clusters = newClusters;
+            if (!changed)
+                break;
+            // Update centroids
+            const newCentroids = [];
+            for (let c = 0; c < k; c++) {
+                newCentroids.push(new Float32Array(dim));
+            }
+            const counts = new Array(k).fill(0);
+            for (let i = 0; i < n; i++) {
+                const c = clusters[i];
+                counts[c]++;
+                for (let d = 0; d < dim; d++) {
+                    newCentroids[c][d] += embeddings[i][d];
+                }
+            }
+            // Normalize centroids
+            for (let c = 0; c < k; c++) {
+                if (counts[c] > 0) {
+                    let norm = 0;
+                    for (let d = 0; d < dim; d++) {
+                        newCentroids[c][d] /= counts[c];
+                        norm += newCentroids[c][d] * newCentroids[c][d];
+                    }
+                    norm = Math.sqrt(norm) || 1;
+                    for (let d = 0; d < dim; d++) {
+                        newCentroids[c][d] /= norm;
+                    }
+                }
+            }
+            centroids = newCentroids;
+        }
+        return { clusters, centroids };
+    }
+    /**
+     * Stream embeddings for large batches (memory efficient)
+     * Yields embeddings one at a time
+     */
+    async *streamEmbed(texts, batchSize = 32) {
+        for (let i = 0; i < texts.length; i += batchSize) {
+            const batch = texts.slice(i, i + batchSize);
+            const embeddings = await this.embedBatch(batch);
+            for (let j = 0; j < batch.length; j++) {
+                yield {
+                    index: i + j,
+                    text: batch[j],
+                    embedding: embeddings[j],
+                };
+            }
+        }
+    }
+    /**
+     * Simple hash-based embedding (fast, not semantic)
+     */
+    simpleEmbed(text, dim = 256) {
+        const embedding = new Float32Array(dim);
+        // Multi-pass hash for better distribution
+        for (let i = 0; i < text.length; i++) {
+            const code = text.charCodeAt(i);
+            embedding[i % dim] += code / 255;
+            embedding[(i * 7) % dim] += (code * 0.3) / 255;
+            embedding[(i * 13) % dim] += (code * 0.2) / 255;
+        }
+        // Normalize
+        let norm = 0;
+        for (let i = 0; i < dim; i++) {
+            norm += embedding[i] * embedding[i];
+        }
+        norm = Math.sqrt(norm) || 1;
+        for (let i = 0; i < dim; i++) {
+            embedding[i] /= norm;
+        }
+        return embedding;
+    }
+    /**
+     * Compute cosine similarity between two embeddings
+     */
+    cosineSimilarity(a, b) {
+        if (ruvectorModule?.cosineSimilarity) {
+            return ruvectorModule.cosineSimilarity(a, b);
+        }
+        // JS fallback
+        let dot = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dot += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        return dot / (Math.sqrt(normA) * Math.sqrt(normB) || 1);
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        const effective = this.effectiveBackend || this.backend;
+        const ruvectorStats = ruvectorModule?.getStats?.() || {};
+        return {
+            backend: this.backend,
+            effectiveBackend: effective,
+            dimension: this.dimension,
+            totalEmbeddings: this.totalEmbeddings,
+            totalLatencyMs: this.totalLatencyMs,
+            avgLatencyMs: this.totalEmbeddings > 0 ? this.totalLatencyMs / this.totalEmbeddings : 0,
+            cacheHits: this.cacheHits,
+            modelLoaded: this.modelLoaded,
+            modelName: effective === 'onnx' ? this.modelName : undefined,
+            simdAvailable: ruvectorStats.simdAvailable ?? onnxAvailable,
+            parallelWorkers: ruvectorStats.workerCount ?? undefined,
+        };
+    }
+    /**
+     * Clear cache
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    /**
+     * Clear corpus
+     */
+    clearCorpus() {
+        this.corpus = { texts: [], embeddings: [] };
+    }
+    /**
+     * Shutdown (cleanup workers)
+     */
+    async shutdown() {
+        if (ruvectorModule?.shutdown) {
+            await ruvectorModule.shutdown();
+        }
+    }
+    /**
+     * Reset instance (for testing)
+     */
+    static async reset() {
+        if (EmbeddingService.instance) {
+            await EmbeddingService.instance.shutdown();
+        }
+        EmbeddingService.instance = null;
+        onnxAvailable = null;
+        ruvectorModule = null;
+    }
+}
+// Export singleton getter
+export function getEmbeddingService() {
+    return EmbeddingService.getInstance();
+}
+// Export convenience functions
+export async function embed(text) {
+    return getEmbeddingService().embed(text);
+}
+export async function embedBatch(texts) {
+    return getEmbeddingService().embedBatch(texts);
+}
+export async function textSimilarity(text1, text2) {
+    return getEmbeddingService().similarity(text1, text2);
+}
+export function simpleEmbed(text, dim = 256) {
+    return getEmbeddingService().simpleEmbed(text, dim);
+}
+export async function similarityMatrix(texts) {
+    return getEmbeddingService().similarityMatrix(texts);
+}
+export async function semanticSearch(query, topK = 5) {
+    return getEmbeddingService().semanticSearch(query, topK);
+}
+export async function findDuplicates(texts, threshold = 0.9) {
+    return getEmbeddingService().findDuplicates(texts, threshold);
+}
+export async function clusterTexts(texts, k = 3) {
+    return getEmbeddingService().clusterTexts(texts, k);
+}
+//# sourceMappingURL=EmbeddingService.js.map