agentic-qe 1.0.5 → 1.2.0

package/dist/core/embeddings/EmbeddingGenerator.d.ts

@@ -0,0 +1,224 @@
+/**
+ * Embedding Generator - Convert patterns into vector embeddings
+ *
+ * Features:
+ * - Phase 1 (Simple): Hash-based embeddings for quick start
+ * - Phase 2 (ML): Transformers.js for production embeddings
+ * - Caching for performance optimization
+ * - Batch processing support
+ * - Graceful fallback if ML models unavailable
+ *
+ * Models:
+ * - Text: "Xenova/all-MiniLM-L6-v2" (384 dimensions)
+ * - Code: "microsoft/codebert-base" (768 dimensions)
+ *
+ * Performance:
+ * - Hash-based: ~50µs per embedding
+ * - ML-based: ~5-10ms per embedding (cached)
+ * - Batch: ~2ms per embedding (10+ texts)
+ *
+ * @module EmbeddingGenerator
+ */
+/**
+ * Embedding generation options
+ */
+export interface EmbeddingOptions {
+    /** Use ML-based embeddings (default: true) */
+    useML?: boolean;
+    /** Cache embeddings for performance (default: true) */
+    useCache?: boolean;
+    /** Normalize embeddings to unit length (default: true) */
+    normalize?: boolean;
+    /** Language for code embeddings (e.g., 'typescript', 'python') */
+    language?: string;
+    /** Model to use ('text' | 'code') */
+    model?: 'text' | 'code';
+    /** Target dimension (for hash-based only) */
+    dimension?: number;
+}
+/**
+ * Embedding result
+ */
+export interface EmbeddingResult {
+    /** Vector embedding */
+    embedding: number[];
+    /** Embedding dimension */
+    dimension: number;
+    /** Method used ('hash' | 'ml') */
+    method: 'hash' | 'ml';
+    /** Generation time in milliseconds */
+    generationTime: number;
+    /** Whether result was cached */
+    cached: boolean;
+    /** Model name used */
+    model: string;
+}
+/**
+ * Batch embedding result
+ */
+export interface BatchEmbeddingResult {
+    /** Array of embeddings */
+    embeddings: number[][];
+    /** Total generation time */
+    totalTime: number;
+    /** Average time per embedding */
+    avgTime: number;
+    /** Number of cache hits */
+    cacheHits: number;
+    /** Method used */
+    method: 'hash' | 'ml';
+}
+/**
+ * Embedding Generator
+ *
+ * Provides both simple hash-based and ML-based embedding generation
+ * with intelligent fallback and caching.
+ */
+export declare class EmbeddingGenerator {
+    private cacheSize;
+    private autoInitML;
+    private cache;
+    private mlAvailable;
+    private pipeline;
+    private codePipeline;
+    private initPromise;
+    private readonly TEXT_MODEL;
+    private readonly CODE_MODEL;
+    private readonly TEXT_DIMENSION;
+    private readonly CODE_DIMENSION;
+    private readonly DEFAULT_HASH_DIMENSION;
+    /**
+     * Create a new embedding generator
+     *
+     * @param cacheSize - Maximum number of cached embeddings (default: 10000)
+     * @param autoInitML - Automatically initialize ML models (default: false)
+     */
+    constructor(cacheSize?: number, autoInitML?: boolean);
+    /**
+     * Initialize ML models
+     *
+     * Lazy-loads Transformers.js models for production embeddings.
+     * Falls back to hash-based if models unavailable.
+     */
+    initializeML(): Promise<void>;
+    /**
+     * Initialize code embedding model
+     *
+     * Separate initialization for code model to avoid loading if not needed.
+     */
+    initializeCodeModel(): Promise<void>;
+    /**
+     * Generate text embedding
+     *
+     * @param text - Text to embed
+     * @param options - Embedding options
+     * @returns Embedding result with vector and metadata
+     */
+    generateTextEmbedding(text: string, options?: EmbeddingOptions): Promise<EmbeddingResult>;
+    /**
+     * Generate code embedding
+     *
+     * @param code - Code to embed
+     * @param language - Programming language
+     * @param options - Embedding options
+     * @returns Embedding result
+     */
+    generateCodeEmbedding(code: string, language: string, options?: EmbeddingOptions): Promise<EmbeddingResult>;
+    /**
+     * Generate batch text embeddings
+     *
+     * More efficient than generating one at a time.
+     *
+     * @param texts - Array of texts to embed
+     * @param options - Embedding options
+     * @returns Batch embedding result
+     */
+    generateBatchTextEmbeddings(texts: string[], options?: EmbeddingOptions): Promise<BatchEmbeddingResult>;
+    /**
+     * Generate hash-based embedding
+     *
+     * Fast, deterministic embedding using cryptographic hashing.
+     * Suitable for testing and development.
+     *
+     * @param text - Text to embed
+     * @param dimension - Target dimension (default: 256)
+     * @param salt - Optional salt for different embeddings (default: '')
+     * @returns Vector embedding
+     */
+    generateHashEmbedding(text: string, dimension?: number, salt?: string): number[];
+    /**
+     * Generate ML-based text embedding
+     *
+     * Uses Transformers.js for production-quality embeddings.
+     *
+     * @param text - Text to embed
+     * @returns Vector embedding
+     */
+    private generateMLTextEmbedding;
+    /**
+     * Generate ML-based code embedding
+     *
+     * Uses CodeBERT for code-specific embeddings.
+     *
+     * @param code - Code to embed
+     * @param language - Programming language
+     * @returns Vector embedding
+     */
+    private generateMLCodeEmbedding;
+    /**
+     * Normalize embedding to unit length
+     *
+     * @param embedding - Vector to normalize
+     * @returns Normalized vector
+     */
+    private normalizeEmbedding;
+    /**
+     * Get cached embedding
+     *
+     * @param key - Cache key
+     * @param type - Embedding type ('text' | 'code')
+     * @returns Cached embedding or null
+     */
+    getCachedEmbedding(key: string, type?: 'text' | 'code'): number[] | null;
+    /**
+     * Cache embedding manually
+     *
+     * @param key - Cache key
+     * @param embedding - Vector embedding
+     * @param type - Embedding type
+     */
+    cacheEmbedding(key: string, embedding: number[], type?: 'text' | 'code'): void;
+    /**
+     * Clear cache
+     *
+     * @param type - Type to clear ('text' | 'code' | 'all')
+     */
+    clearCache(type?: 'text' | 'code' | 'all'): void;
+    /**
+     * Get cache statistics
+     *
+     * @returns Cache stats
+     */
+    getCacheStats(): import("./EmbeddingCache").CacheStats;
+    /**
+     * Check if ML models are available
+     *
+     * @returns True if ML models initialized
+     */
+    isMLAvailable(): boolean;
+    /**
+     * Get model information
+     *
+     * @returns Model info
+     */
+    getModelInfo(): {
+        textModel: string;
+        codeModel: string;
+        textDimension: number;
+        codeDimension: number;
+        hashDimension: number;
+        mlAvailable: boolean;
+        cacheSize: number;
+    };
+}
+//# sourceMappingURL=EmbeddingGenerator.d.ts.map

package/dist/core/embeddings/EmbeddingGenerator.d.ts.map

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

package/dist/core/embeddings/EmbeddingGenerator.js

@@ -0,0 +1,459 @@
+"use strict";
+/**
+ * Embedding Generator - Convert patterns into vector embeddings
+ *
+ * Features:
+ * - Phase 1 (Simple): Hash-based embeddings for quick start
+ * - Phase 2 (ML): Transformers.js for production embeddings
+ * - Caching for performance optimization
+ * - Batch processing support
+ * - Graceful fallback if ML models unavailable
+ *
+ * Models:
+ * - Text: "Xenova/all-MiniLM-L6-v2" (384 dimensions)
+ * - Code: "microsoft/codebert-base" (768 dimensions)
+ *
+ * Performance:
+ * - Hash-based: ~50µs per embedding
+ * - ML-based: ~5-10ms per embedding (cached)
+ * - Batch: ~2ms per embedding (10+ texts)
+ *
+ * @module EmbeddingGenerator
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbeddingGenerator = void 0;
+const crypto_1 = require("crypto");
+const EmbeddingCache_1 = require("./EmbeddingCache");
+/**
+ * Embedding Generator
+ *
+ * Provides both simple hash-based and ML-based embedding generation
+ * with intelligent fallback and caching.
+ */
+class EmbeddingGenerator {
+    /**
+     * Create a new embedding generator
+     *
+     * @param cacheSize - Maximum number of cached embeddings (default: 10000)
+     * @param autoInitML - Automatically initialize ML models (default: false)
+     */
+    constructor(cacheSize = 10000, autoInitML = false) {
+        this.cacheSize = cacheSize;
+        this.autoInitML = autoInitML;
+        this.mlAvailable = false;
+        this.pipeline = null;
+        this.codePipeline = null;
+        this.initPromise = null;
+        // Model configurations
+        this.TEXT_MODEL = 'Xenova/all-MiniLM-L6-v2';
+        this.CODE_MODEL = 'microsoft/codebert-base';
+        this.TEXT_DIMENSION = 384;
+        this.CODE_DIMENSION = 768;
+        this.DEFAULT_HASH_DIMENSION = 256;
+        this.cache = new EmbeddingCache_1.EmbeddingCache(cacheSize);
+        // Auto-initialize ML models if requested
+        if (autoInitML) {
+            this.initPromise = this.initializeML().catch((error) => {
+                console.warn('ML initialization failed, falling back to hash-based:', error.message);
+                this.mlAvailable = false;
+            });
+        }
+    }
+    /**
+     * Initialize ML models
+     *
+     * Lazy-loads Transformers.js models for production embeddings.
+     * Falls back to hash-based if models unavailable.
+     */
+    async initializeML() {
+        if (this.mlAvailable) {
+            return;
+        }
+        try {
+            // Dynamic import to avoid bundling if not needed
+            const { pipeline } = await Promise.resolve().then(() => __importStar(require('@xenova/transformers')));
+            // Initialize text embedding pipeline
+            this.pipeline = await pipeline('feature-extraction', this.TEXT_MODEL);
+            console.log(`✓ ML text model loaded: ${this.TEXT_MODEL} (${this.TEXT_DIMENSION}D)`);
+            this.mlAvailable = true;
+        }
+        catch (error) {
+            console.warn('ML models not available, using hash-based embeddings:', error.message);
+            this.mlAvailable = false;
+            throw error;
+        }
+    }
+    /**
+     * Initialize code embedding model
+     *
+     * Separate initialization for code model to avoid loading if not needed.
+     */
+    async initializeCodeModel() {
+        if (this.codePipeline) {
+            return;
+        }
+        try {
+            const { pipeline } = await Promise.resolve().then(() => __importStar(require('@xenova/transformers')));
+            this.codePipeline = await pipeline('feature-extraction', this.CODE_MODEL);
+            console.log(`✓ ML code model loaded: ${this.CODE_MODEL} (${this.CODE_DIMENSION}D)`);
+        }
+        catch (error) {
+            console.warn('Code model not available:', error.message);
+            throw error;
+        }
+    }
+    /**
+     * Generate text embedding
+     *
+     * @param text - Text to embed
+     * @param options - Embedding options
+     * @returns Embedding result with vector and metadata
+     */
+    async generateTextEmbedding(text, options = {}) {
+        const startTime = Date.now();
+        const { useML = true, useCache = true, normalize = true, dimension = this.DEFAULT_HASH_DIMENSION } = options;
+        // Check cache first
+        if (useCache) {
+            const cached = this.cache.get(text, 'text');
+            if (cached) {
+                return {
+                    embedding: cached,
+                    dimension: cached.length,
+                    method: cached.length === dimension ? 'hash' : 'ml',
+                    generationTime: Date.now() - startTime,
+                    cached: true,
+                    model: cached.length === this.TEXT_DIMENSION ? this.TEXT_MODEL : 'hash'
+                };
+            }
+        }
+        let embedding;
+        let method;
+        let modelName;
+        // Try ML-based embedding first if available
+        if (useML && this.mlAvailable && this.pipeline) {
+            try {
+                embedding = await this.generateMLTextEmbedding(text);
+                method = 'ml';
+                modelName = this.TEXT_MODEL;
+            }
+            catch (error) {
+                console.warn('ML embedding failed, falling back to hash:', error);
+                embedding = this.generateHashEmbedding(text, dimension);
+                method = 'hash';
+                modelName = 'hash';
+            }
+        }
+        else {
+            // Use hash-based embedding
+            embedding = this.generateHashEmbedding(text, dimension);
+            method = 'hash';
+            modelName = 'hash';
+        }
+        // Normalize if requested
+        if (normalize && method === 'hash') {
+            embedding = this.normalizeEmbedding(embedding);
+        }
+        // Cache result
+        if (useCache) {
+            this.cache.set(text, embedding, 'text');
+        }
+        return {
+            embedding,
+            dimension: embedding.length,
+            method,
+            generationTime: Date.now() - startTime,
+            cached: false,
+            model: modelName
+        };
+    }
+    /**
+     * Generate code embedding
+     *
+     * @param code - Code to embed
+     * @param language - Programming language
+     * @param options - Embedding options
+     * @returns Embedding result
+     */
+    async generateCodeEmbedding(code, language, options = {}) {
+        const startTime = Date.now();
+        const { useML = true, useCache = true, normalize = true, dimension = this.DEFAULT_HASH_DIMENSION } = options;
+        // Cache key includes language
+        const cacheKey = `${language}:${code}`;
+        // Check cache first
+        if (useCache) {
+            const cached = this.cache.get(cacheKey, 'code');
+            if (cached) {
+                return {
+                    embedding: cached,
+                    dimension: cached.length,
+                    method: cached.length === dimension ? 'hash' : 'ml',
+                    generationTime: Date.now() - startTime,
+                    cached: true,
+                    model: cached.length === this.CODE_DIMENSION ? this.CODE_MODEL : 'hash'
+                };
+            }
+        }
+        let embedding;
+        let method;
+        let modelName;
+        // Try ML-based code embedding
+        if (useML && this.mlAvailable) {
+            try {
+                if (!this.codePipeline) {
+                    await this.initializeCodeModel();
+                }
+                embedding = await this.generateMLCodeEmbedding(code, language);
+                method = 'ml';
+                modelName = this.CODE_MODEL;
+            }
+            catch (error) {
+                console.warn('ML code embedding failed, falling back to hash:', error);
+                embedding = this.generateHashEmbedding(code, dimension);
+                method = 'hash';
+                modelName = 'hash';
+            }
+        }
+        else {
+            // Use hash-based embedding with language as salt for differentiation
+            embedding = this.generateHashEmbedding(code, dimension, language);
+            method = 'hash';
+            modelName = 'hash';
+        }
+        // Normalize if requested
+        if (normalize && method === 'hash') {
+            embedding = this.normalizeEmbedding(embedding);
+        }
+        // Cache result
+        if (useCache) {
+            this.cache.set(cacheKey, embedding, 'code');
+        }
+        return {
+            embedding,
+            dimension: embedding.length,
+            method,
+            generationTime: Date.now() - startTime,
+            cached: false,
+            model: modelName
+        };
+    }
+    /**
+     * Generate batch text embeddings
+     *
+     * More efficient than generating one at a time.
+     *
+     * @param texts - Array of texts to embed
+     * @param options - Embedding options
+     * @returns Batch embedding result
+     */
+    async generateBatchTextEmbeddings(texts, options = {}) {
+        const startTime = Date.now();
+        const { useML = true, useCache = true } = options;
+        const embeddings = [];
+        let cacheHits = 0;
+        let method = 'hash';
+        // Process each text
+        for (const text of texts) {
+            const result = await this.generateTextEmbedding(text, {
+                ...options,
+                useML,
+                useCache
+            });
+            embeddings.push(result.embedding);
+            if (result.cached) {
+                cacheHits++;
+            }
+            if (result.method === 'ml') {
+                method = 'ml';
+            }
+        }
+        const totalTime = Date.now() - startTime;
+        return {
+            embeddings,
+            totalTime,
+            avgTime: texts.length > 0 ? totalTime / texts.length : 0,
+            cacheHits,
+            method
+        };
+    }
+    /**
+     * Generate hash-based embedding
+     *
+     * Fast, deterministic embedding using cryptographic hashing.
+     * Suitable for testing and development.
+     *
+     * @param text - Text to embed
+     * @param dimension - Target dimension (default: 256)
+     * @param salt - Optional salt for different embeddings (default: '')
+     * @returns Vector embedding
+     */
+    generateHashEmbedding(text, dimension = this.DEFAULT_HASH_DIMENSION, salt = '') {
+        const embedding = new Array(dimension);
+        // Use multiple hash passes for better distribution
+        const passes = Math.ceil(dimension / 32); // SHA-256 produces 32 bytes
+        for (let pass = 0; pass < passes; pass++) {
+            const hash = (0, crypto_1.createHash)('sha256')
+                .update(`${salt}:${pass}:${text}`)
+                .digest();
+            const startIdx = pass * 32;
+            const endIdx = Math.min(startIdx + 32, dimension);
+            for (let i = startIdx; i < endIdx; i++) {
+                // Convert byte to [-1, 1] range
+                embedding[i] = (hash[i - startIdx] / 127.5) - 1;
+            }
+        }
+        return embedding;
+    }
+    /**
+     * Generate ML-based text embedding
+     *
+     * Uses Transformers.js for production-quality embeddings.
+     *
+     * @param text - Text to embed
+     * @returns Vector embedding
+     */
+    async generateMLTextEmbedding(text) {
+        if (!this.pipeline) {
+            throw new Error('ML pipeline not initialized');
+        }
+        // Wait for initialization if in progress
+        if (this.initPromise) {
+            await this.initPromise;
+        }
+        // Generate embedding using transformer
+        const result = await this.pipeline(text, {
+            pooling: 'mean',
+            normalize: true
+        });
+        // Convert to regular array
+        return Array.from(result.data);
+    }
+    /**
+     * Generate ML-based code embedding
+     *
+     * Uses CodeBERT for code-specific embeddings.
+     *
+     * @param code - Code to embed
+     * @param language - Programming language
+     * @returns Vector embedding
+     */
+    async generateMLCodeEmbedding(code, language) {
+        if (!this.codePipeline) {
+            throw new Error('Code pipeline not initialized');
+        }
+        // Prepend language token for context
+        const input = `[${language}] ${code}`;
+        const result = await this.codePipeline(input, {
+            pooling: 'mean',
+            normalize: true
+        });
+        return Array.from(result.data);
+    }
+    /**
+     * Normalize embedding to unit length
+     *
+     * @param embedding - Vector to normalize
+     * @returns Normalized vector
+     */
+    normalizeEmbedding(embedding) {
+        const magnitude = Math.sqrt(embedding.reduce((sum, val) => sum + val * val, 0));
+        if (magnitude === 0) {
+            return embedding;
+        }
+        return embedding.map(val => val / magnitude);
+    }
+    /**
+     * Get cached embedding
+     *
+     * @param key - Cache key
+     * @param type - Embedding type ('text' | 'code')
+     * @returns Cached embedding or null
+     */
+    getCachedEmbedding(key, type = 'text') {
+        return this.cache.get(key, type);
+    }
+    /**
+     * Cache embedding manually
+     *
+     * @param key - Cache key
+     * @param embedding - Vector embedding
+     * @param type - Embedding type
+     */
+    cacheEmbedding(key, embedding, type = 'text') {
+        this.cache.set(key, embedding, type);
+    }
+    /**
+     * Clear cache
+     *
+     * @param type - Type to clear ('text' | 'code' | 'all')
+     */
+    clearCache(type = 'all') {
+        this.cache.clear(type);
+    }
+    /**
+     * Get cache statistics
+     *
+     * @returns Cache stats
+     */
+    getCacheStats() {
+        return this.cache.getStats();
+    }
+    /**
+     * Check if ML models are available
+     *
+     * @returns True if ML models initialized
+     */
+    isMLAvailable() {
+        return this.mlAvailable;
+    }
+    /**
+     * Get model information
+     *
+     * @returns Model info
+     */
+    getModelInfo() {
+        return {
+            textModel: this.TEXT_MODEL,
+            codeModel: this.CODE_MODEL,
+            textDimension: this.TEXT_DIMENSION,
+            codeDimension: this.CODE_DIMENSION,
+            hashDimension: this.DEFAULT_HASH_DIMENSION,
+            mlAvailable: this.mlAvailable,
+            cacheSize: this.cacheSize
+        };
+    }
+}
+exports.EmbeddingGenerator = EmbeddingGenerator;
+//# sourceMappingURL=EmbeddingGenerator.js.map