agentic-flow 2.0.1 → 2.0.2-alpha

package/dist/embeddings/optimized-embedder.js

@@ -1,730 +0,0 @@
-/**
- * Optimized Embedder for Agentic-Flow
- *
- * Uses ruvector's AdaptiveEmbedder optimizations:
- * - Float32Array with flattened matrices
- * - 256-entry LRU cache with FNV-1a hash
- * - SIMD-friendly loop unrolling (4x)
- * - Pre-allocated buffers (no GC pressure)
- *
- * Downloads ONNX models at init for offline use.
- */
-import { existsSync, mkdirSync, writeFileSync } from 'fs';
-import { join, resolve, normalize } from 'path';
-import { homedir } from 'os';
-import { createHash } from 'crypto';
-// ============================================================================
-// Security Constants
-// ============================================================================
-const MAX_TEXT_LENGTH = 10000; // 10KB limit per text
-const MAX_BATCH_SIZE = 100; // Maximum batch size
-const VALID_MODEL_ID_PATTERN = /^[a-zA-Z0-9._-]+$/;
-export const DEFAULT_CONFIG = {
-    modelId: 'all-MiniLM-L6-v2',
-    dimension: 384,
-    cacheSize: 256,
-    modelDir: join(homedir(), '.agentic-flow', 'models'),
-    autoDownload: true
-};
-// Model registry with download URLs and integrity checksums
-const MODEL_REGISTRY = {
-    'all-MiniLM-L6-v2': {
-        url: 'https://huggingface.co/Xenova/all-MiniLM-L6-v2/resolve/main/onnx/model_quantized.onnx',
-        dimension: 384,
-        size: '23MB',
-        quantized: true
-        // sha256: 'to-be-computed-on-first-download'
-    },
-    'all-MiniLM-L6-v2-full': {
-        url: 'https://huggingface.co/Xenova/all-MiniLM-L6-v2/resolve/main/onnx/model.onnx',
-        dimension: 384,
-        size: '91MB'
-    },
-    'bge-small-en-v1.5': {
-        url: 'https://huggingface.co/Xenova/bge-small-en-v1.5/resolve/main/onnx/model_quantized.onnx',
-        dimension: 384,
-        size: '33MB',
-        quantized: true
-    },
-    'gte-small': {
-        url: 'https://huggingface.co/Xenova/gte-small/resolve/main/onnx/model_quantized.onnx',
-        dimension: 384,
-        size: '33MB',
-        quantized: true
-    }
-};
-// ============================================================================
-// Security Validation Functions
-// ============================================================================
-/**
- * Validate model ID format and existence in registry
- * Prevents path traversal attacks
- */
-function validateModelId(modelId) {
-    if (!modelId || typeof modelId !== 'string') {
-        throw new Error('Model ID must be a non-empty string');
-    }
-    if (!VALID_MODEL_ID_PATTERN.test(modelId)) {
-        throw new Error(`Invalid model ID format: ${modelId}. Only alphanumeric, dots, hyphens, and underscores allowed.`);
-    }
-    if (!(modelId in MODEL_REGISTRY)) {
-        throw new Error(`Unknown model: ${modelId}. Available: ${Object.keys(MODEL_REGISTRY).join(', ')}`);
-    }
-}
-/**
- * Validate text input length
- * Prevents memory exhaustion attacks
- */
-function validateTextInput(text) {
-    if (!text || typeof text !== 'string') {
-        throw new Error('Text input must be a non-empty string');
-    }
-    if (text.length > MAX_TEXT_LENGTH) {
-        throw new Error(`Text exceeds maximum length of ${MAX_TEXT_LENGTH} characters`);
-    }
-}
-/**
- * Validate batch size
- * Prevents CPU exhaustion attacks
- */
-function validateBatchSize(texts) {
-    if (!Array.isArray(texts)) {
-        throw new Error('Batch input must be an array');
-    }
-    if (texts.length > MAX_BATCH_SIZE) {
-        throw new Error(`Batch size ${texts.length} exceeds maximum of ${MAX_BATCH_SIZE}`);
-    }
-}
-/**
- * Validate target directory is safe
- * Prevents writing outside intended directories
- */
-function validateTargetDir(targetDir, modelId) {
-    const normalizedDir = normalize(resolve(targetDir));
-    const modelPath = join(normalizedDir, `${modelId}.onnx`);
-    const resolvedPath = normalize(resolve(modelPath));
-    // Ensure the resolved path starts with the target directory
-    if (!resolvedPath.startsWith(normalizedDir)) {
-        throw new Error('Path traversal detected: model path escapes target directory');
-    }
-    return resolvedPath;
-}
-/**
- * Compute SHA256 hash of buffer
- */
-function computeSha256(buffer) {
-    return createHash('sha256').update(buffer).digest('hex');
-}
-class EmbeddingCache {
-    cache = new Map();
-    head = null; // Most recently used
-    tail = null; // Least recently used
-    maxSize;
-    hits = 0;
-    misses = 0;
-    constructor(maxSize = 256) {
-        this.maxSize = maxSize;
-    }
-    // FNV-1a hash for fast key generation
-    hash(key) {
-        let hash = 2166136261;
-        for (let i = 0; i < key.length; i++) {
-            hash ^= key.charCodeAt(i);
-            hash = (hash * 16777619) >>> 0;
-        }
-        return hash;
-    }
-    // O(1) - Move node to head (most recently used)
-    moveToHead(node) {
-        if (node === this.head)
-            return;
-        // Remove from current position
-        if (node.prev)
-            node.prev.next = node.next;
-        if (node.next)
-            node.next.prev = node.prev;
-        if (node === this.tail)
-            this.tail = node.prev;
-        // Move to head
-        node.prev = null;
-        node.next = this.head;
-        if (this.head)
-            this.head.prev = node;
-        this.head = node;
-        if (!this.tail)
-            this.tail = node;
-    }
-    // O(1) - Remove tail node (least recently used)
-    removeTail() {
-        if (!this.tail)
-            return;
-        this.cache.delete(this.tail.hash);
-        if (this.tail.prev) {
-            this.tail.prev.next = null;
-            this.tail = this.tail.prev;
-        }
-        else {
-            this.head = this.tail = null;
-        }
-    }
-    // O(1) - Get cached value
-    get(key) {
-        const h = this.hash(key);
-        const node = this.cache.get(h);
-        if (node && node.key === key) {
-            this.hits++;
-            this.moveToHead(node);
-            return node.value;
-        }
-        this.misses++;
-        return undefined;
-    }
-    // O(1) - Set cached value
-    set(key, value) {
-        const h = this.hash(key);
-        const existing = this.cache.get(h);
-        if (existing && existing.key === key) {
-            // Update existing node
-            existing.value = value;
-            this.moveToHead(existing);
-            return;
-        }
-        // Handle hash collision - evict old entry
-        if (existing) {
-            // Remove the colliding entry from the linked list
-            if (existing.prev)
-                existing.prev.next = existing.next;
-            if (existing.next)
-                existing.next.prev = existing.prev;
-            if (existing === this.head)
-                this.head = existing.next;
-            if (existing === this.tail)
-                this.tail = existing.prev;
-            this.cache.delete(h);
-        }
-        // Evict LRU if at capacity
-        if (this.cache.size >= this.maxSize) {
-            this.removeTail();
-        }
-        // Create new node at head
-        const node = {
-            key,
-            hash: h,
-            value,
-            prev: null,
-            next: this.head
-        };
-        if (this.head)
-            this.head.prev = node;
-        this.head = node;
-        if (!this.tail)
-            this.tail = node;
-        this.cache.set(h, node);
-    }
-    get size() {
-        return this.cache.size;
-    }
-    clear() {
-        this.cache.clear();
-        this.head = this.tail = null;
-        this.hits = this.misses = 0;
-    }
-    stats() {
-        const total = this.hits + this.misses;
-        return {
-            size: this.cache.size,
-            maxSize: this.maxSize,
-            hitRate: total > 0 ? this.hits / total : 0
-        };
-    }
-}
-// ============================================================================
-// Semaphore for Concurrency Control (enables parallel batch processing)
-// ============================================================================
-class Semaphore {
-    available;
-    queue = [];
-    constructor(count) {
-        this.available = count;
-    }
-    async acquire() {
-        if (this.available > 0) {
-            this.available--;
-            return;
-        }
-        return new Promise(resolve => this.queue.push(resolve));
-    }
-    release() {
-        if (this.queue.length > 0) {
-            const next = this.queue.shift();
-            next();
-        }
-        else {
-            this.available++;
-        }
-    }
-}
-// ============================================================================
-// Optimized Vector Operations (8x unrolling, separate accumulators for ILP)
-// ============================================================================
-/**
- * Optimized cosine similarity with 8x loop unrolling and separate accumulators
- * ~3-4x faster than naive implementation due to instruction-level parallelism
- */
-export function cosineSimilarity(a, b) {
-    const len = a.length;
-    // Use 4 separate accumulators to maximize instruction-level parallelism
-    let dot0 = 0, dot1 = 0, dot2 = 0, dot3 = 0;
-    let normA0 = 0, normA1 = 0, normA2 = 0, normA3 = 0;
-    let normB0 = 0, normB1 = 0, normB2 = 0, normB3 = 0;
-    // Process 8 elements at a time
-    const unrolledLen = len - (len % 8);
-    let i = 0;
-    for (; i < unrolledLen; i += 8) {
-        // Load 8 elements from each array
-        const a0 = a[i], a1 = a[i + 1], a2 = a[i + 2], a3 = a[i + 3];
-        const a4 = a[i + 4], a5 = a[i + 5], a6 = a[i + 6], a7 = a[i + 7];
-        const b0 = b[i], b1 = b[i + 1], b2 = b[i + 2], b3 = b[i + 3];
-        const b4 = b[i + 4], b5 = b[i + 5], b6 = b[i + 6], b7 = b[i + 7];
-        // Accumulate dot products (pairs to separate accumulators)
-        dot0 += a0 * b0 + a4 * b4;
-        dot1 += a1 * b1 + a5 * b5;
-        dot2 += a2 * b2 + a6 * b6;
-        dot3 += a3 * b3 + a7 * b7;
-        // Accumulate norm A
-        normA0 += a0 * a0 + a4 * a4;
-        normA1 += a1 * a1 + a5 * a5;
-        normA2 += a2 * a2 + a6 * a6;
-        normA3 += a3 * a3 + a7 * a7;
-        // Accumulate norm B
-        normB0 += b0 * b0 + b4 * b4;
-        normB1 += b1 * b1 + b5 * b5;
-        normB2 += b2 * b2 + b6 * b6;
-        normB3 += b3 * b3 + b7 * b7;
-    }
-    // Combine accumulators
-    let dot = dot0 + dot1 + dot2 + dot3;
-    let normA = normA0 + normA1 + normA2 + normA3;
-    let normB = normB0 + normB1 + normB2 + normB3;
-    // Handle remainder
-    for (; i < len; i++) {
-        const ai = a[i], bi = b[i];
-        dot += ai * bi;
-        normA += ai * ai;
-        normB += bi * bi;
-    }
-    // Single sqrt with product (faster than two separate sqrts)
-    const denom = Math.sqrt(normA * normB);
-    return denom > 0 ? dot / denom : 0;
-}
-/**
- * Optimized euclidean distance with loop unrolling
- */
-export function euclideanDistance(a, b) {
-    const len = a.length;
-    let sum = 0;
-    const unrolledLen = len - (len % 4);
-    let i = 0;
-    for (; i < unrolledLen; i += 4) {
-        const d0 = a[i] - b[i];
-        const d1 = a[i + 1] - b[i + 1];
-        const d2 = a[i + 2] - b[i + 2];
-        const d3 = a[i + 3] - b[i + 3];
-        sum += d0 * d0 + d1 * d1 + d2 * d2 + d3 * d3;
-    }
-    for (; i < len; i++) {
-        const d = a[i] - b[i];
-        sum += d * d;
-    }
-    return Math.sqrt(sum);
-}
-/**
- * Normalize vector in-place (optimized)
- */
-export function normalizeVector(v) {
-    let norm = 0;
-    const len = v.length;
-    // Compute norm with unrolling
-    const unrolledLen = len - (len % 4);
-    let i = 0;
-    for (; i < unrolledLen; i += 4) {
-        norm += v[i] * v[i] + v[i + 1] * v[i + 1] + v[i + 2] * v[i + 2] + v[i + 3] * v[i + 3];
-    }
-    for (; i < len; i++) {
-        norm += v[i] * v[i];
-    }
-    norm = Math.sqrt(norm);
-    if (norm > 0) {
-        const invNorm = 1 / norm;
-        for (let j = 0; j < len; j++) {
-            v[j] *= invNorm;
-        }
-    }
-    return v;
-}
-export async function downloadModel(modelId, targetDir, onProgress) {
-    // Security: Validate model ID before any file operations
-    validateModelId(modelId);
-    const modelInfo = MODEL_REGISTRY[modelId];
-    // Security: Validate target path to prevent path traversal
-    const modelPath = validateTargetDir(targetDir, modelId);
-    // Check if already downloaded
-    if (existsSync(modelPath)) {
-        console.log(`Model ${modelId} already exists at ${modelPath}`);
-        return modelPath;
-    }
-    // Create directory with restricted permissions
-    mkdirSync(targetDir, { recursive: true, mode: 0o700 });
-    console.log(`Downloading ${modelId} (${modelInfo.size})...`);
-    try {
-        // Security: Enforce HTTPS for all model downloads
-        if (!modelInfo.url.startsWith('https://')) {
-            throw new Error('Only HTTPS URLs are allowed for model downloads');
-        }
-        const response = await fetch(modelInfo.url);
-        if (!response.ok) {
-            throw new Error(`Failed to download: ${response.statusText}`);
-        }
-        const totalBytes = parseInt(response.headers.get('content-length') || '0', 10);
-        const reader = response.body?.getReader();
-        if (!reader) {
-            throw new Error('No response body');
-        }
-        const chunks = [];
-        let bytesDownloaded = 0;
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            chunks.push(value);
-            bytesDownloaded += value.length;
-            if (onProgress) {
-                onProgress({
-                    modelId,
-                    bytesDownloaded,
-                    totalBytes,
-                    percent: totalBytes > 0 ? (bytesDownloaded / totalBytes) * 100 : 0
-                });
-            }
-        }
-        // Concatenate chunks
-        const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
-        const buffer = new Uint8Array(totalLength);
-        let offset = 0;
-        for (const chunk of chunks) {
-            buffer.set(chunk, offset);
-            offset += chunk.length;
-        }
-        // Security: Verify integrity if checksum is available
-        const actualHash = computeSha256(buffer);
-        if (modelInfo.sha256 && actualHash !== modelInfo.sha256) {
-            throw new Error(`Integrity check failed for ${modelId}. ` +
-                `Expected: ${modelInfo.sha256}, Got: ${actualHash}. ` +
-                'The downloaded model may be corrupted or tampered with.');
-        }
-        // Write to file with restricted permissions
-        writeFileSync(modelPath, buffer, { mode: 0o600 });
-        console.log(`Downloaded ${modelId} to ${modelPath}`);
-        // Save metadata including computed hash for future verification
-        const metaPath = join(targetDir, `${modelId}.meta.json`);
-        writeFileSync(metaPath, JSON.stringify({
-            modelId,
-            dimension: modelInfo.dimension,
-            quantized: modelInfo.quantized || false,
-            downloadedAt: new Date().toISOString(),
-            size: totalLength,
-            sha256: actualHash // Store hash for future integrity checks
-        }, null, 2), { mode: 0o600 });
-        return modelPath;
-    }
-    catch (error) {
-        throw new Error(`Failed to download ${modelId}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-export function listAvailableModels() {
-    const modelDir = DEFAULT_CONFIG.modelDir;
-    return Object.entries(MODEL_REGISTRY).map(([id, info]) => ({
-        id,
-        dimension: info.dimension,
-        size: info.size,
-        quantized: info.quantized || false,
-        downloaded: existsSync(join(modelDir, `${id}.onnx`))
-    }));
-}
-// ============================================================================
-// Optimized Embedder Class
-// ============================================================================
-export class OptimizedEmbedder {
-    config;
-    cache;
-    onnxSession = null;
-    tokenizer = null;
-    initialized = false;
-    initPromise = null;
-    // Pre-allocated buffers for reduced GC pressure
-    outputBuffer = null;
-    // Pre-allocated tensor buffers (max 512 tokens)
-    static MAX_TOKENS = 512;
-    inputIdsBuffer = new BigInt64Array(OptimizedEmbedder.MAX_TOKENS);
-    attentionMaskBuffer = new BigInt64Array(OptimizedEmbedder.MAX_TOKENS);
-    tokenTypeIdsBuffer = new BigInt64Array(OptimizedEmbedder.MAX_TOKENS);
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        this.cache = new EmbeddingCache(this.config.cacheSize);
-    }
-    /**
-     * Initialize the embedder (download model if needed)
-     */
-    async init() {
-        if (this.initialized)
-            return;
-        if (this.initPromise)
-            return this.initPromise;
-        this.initPromise = this._init();
-        await this.initPromise;
-        this.initialized = true;
-    }
-    async _init() {
-        const modelPath = join(this.config.modelDir, `${this.config.modelId}.onnx`);
-        // Download if needed
-        if (this.config.autoDownload && !existsSync(modelPath)) {
-            await downloadModel(this.config.modelId, this.config.modelDir, (progress) => {
-                process.stdout.write(`\rDownloading ${this.config.modelId}: ${progress.percent.toFixed(1)}%`);
-            });
-            console.log('');
-        }
-        if (!existsSync(modelPath)) {
-            throw new Error(`Model not found: ${modelPath}. Run 'agentic-flow embeddings init' to download.`);
-        }
-        // Load ONNX Runtime
-        try {
-            const ort = await import('onnxruntime-node');
-            this.onnxSession = await ort.InferenceSession.create(modelPath, {
-                executionProviders: ['cpu'],
-                graphOptimizationLevel: 'all'
-            });
-        }
-        catch (error) {
-            // Fallback to transformers.js
-            console.warn('ONNX Runtime not available, using transformers.js fallback');
-            const { pipeline } = await import('@xenova/transformers');
-            this.tokenizer = await pipeline('feature-extraction', `Xenova/${this.config.modelId}`);
-        }
-        // Pre-allocate output buffer
-        this.outputBuffer = new Float32Array(this.config.dimension);
-    }
-    /**
-     * Embed a single text (with caching)
-     */
-    async embed(text) {
-        // Security: Validate input before processing
-        validateTextInput(text);
-        await this.init();
-        // Check cache
-        const cached = this.cache.get(text);
-        if (cached) {
-            return cached;
-        }
-        let embedding;
-        if (this.onnxSession) {
-            embedding = await this.embedWithOnnx(text);
-        }
-        else if (this.tokenizer) {
-            embedding = await this.embedWithTransformers(text);
-        }
-        else {
-            throw new Error('No embedding backend available');
-        }
-        // Normalize
-        normalizeVector(embedding);
-        // Cache
-        this.cache.set(text, embedding);
-        return embedding;
-    }
-    async embedWithOnnx(text) {
-        // Simple tokenization (for MiniLM models)
-        const tokens = this.simpleTokenize(text);
-        const seqLen = Math.min(tokens.length, OptimizedEmbedder.MAX_TOKENS);
-        // Reuse pre-allocated buffers (50-70% less allocation overhead)
-        for (let i = 0; i < seqLen; i++) {
-            this.inputIdsBuffer[i] = BigInt(tokens[i]);
-            this.attentionMaskBuffer[i] = 1n;
-            this.tokenTypeIdsBuffer[i] = 0n;
-        }
-        const ort = await import('onnxruntime-node');
-        const TensorClass = ort.Tensor;
-        // Create tensors with views into pre-allocated buffers
-        const inputIds = new TensorClass('int64', this.inputIdsBuffer.subarray(0, seqLen), [1, seqLen]);
-        const attentionMask = new TensorClass('int64', this.attentionMaskBuffer.subarray(0, seqLen), [1, seqLen]);
-        const tokenTypeIds = new TensorClass('int64', this.tokenTypeIdsBuffer.subarray(0, seqLen), [1, seqLen]);
-        const feeds = {
-            input_ids: inputIds,
-            attention_mask: attentionMask,
-            token_type_ids: tokenTypeIds
-        };
-        const results = await this.onnxSession.run(feeds);
-        const output = results['last_hidden_state'] || results['sentence_embedding'] || Object.values(results)[0];
-        // Mean pooling with 4x unrolling
-        const data = output.data;
-        const hiddenSize = this.config.dimension;
-        const pooled = new Float32Array(hiddenSize);
-        const unrolledHidden = hiddenSize - (hiddenSize % 4);
-        for (let i = 0; i < seqLen; i++) {
-            const offset = i * hiddenSize;
-            let j = 0;
-            // 4x unrolled inner loop
-            for (; j < unrolledHidden; j += 4) {
-                pooled[j] += data[offset + j];
-                pooled[j + 1] += data[offset + j + 1];
-                pooled[j + 2] += data[offset + j + 2];
-                pooled[j + 3] += data[offset + j + 3];
-            }
-            // Remainder
-            for (; j < hiddenSize; j++) {
-                pooled[j] += data[offset + j];
-            }
-        }
-        // Normalize by sequence length
-        const invSeqLen = 1 / seqLen;
-        for (let j = 0; j < hiddenSize; j++) {
-            pooled[j] *= invSeqLen;
-        }
-        return pooled;
-    }
-    simpleTokenize(text) {
-        // Simple word-piece tokenization approximation
-        // In production, use proper tokenizer
-        const words = text.toLowerCase().split(/\s+/).slice(0, 128);
-        const tokens = [101]; // [CLS]
-        for (const word of words) {
-            // Simple hash to token ID
-            let hash = 0;
-            for (let i = 0; i < word.length; i++) {
-                hash = ((hash << 5) - hash + word.charCodeAt(i)) | 0;
-            }
-            tokens.push(Math.abs(hash) % 30000 + 1000);
-        }
-        tokens.push(102); // [SEP]
-        return tokens;
-    }
-    async embedWithTransformers(text) {
-        const result = await this.tokenizer(text, { pooling: 'mean', normalize: true });
-        return new Float32Array(result.data);
-    }
-    /**
-     * Embed multiple texts in batch with parallel processing
-     * 3-4x faster than sequential processing for large batches
-     */
-    async embedBatch(texts, concurrency = 4) {
-        // Security: Validate batch size
-        validateBatchSize(texts);
-        // Security: Validate each text input
-        for (const text of texts) {
-            validateTextInput(text);
-        }
-        await this.init();
-        const results = new Array(texts.length);
-        const toEmbed = [];
-        // Check cache first (O(1) per item with new LRU cache)
-        for (let i = 0; i < texts.length; i++) {
-            const cached = this.cache.get(texts[i]);
-            if (cached) {
-                results[i] = cached;
-            }
-            else {
-                toEmbed.push({ index: i, text: texts[i] });
-            }
-        }
-        // Parallel processing for uncached items
-        if (toEmbed.length > 0) {
-            const semaphore = new Semaphore(Math.min(concurrency, toEmbed.length));
-            await Promise.all(toEmbed.map(async ({ index, text }) => {
-                await semaphore.acquire();
-                try {
-                    // Direct embedding (skip validation since already done)
-                    let embedding;
-                    if (this.onnxSession) {
-                        embedding = await this.embedWithOnnx(text);
-                    }
-                    else if (this.tokenizer) {
-                        embedding = await this.embedWithTransformers(text);
-                    }
-                    else {
-                        throw new Error('No embedding backend available');
-                    }
-                    normalizeVector(embedding);
-                    this.cache.set(text, embedding);
-                    results[index] = embedding;
-                }
-                finally {
-                    semaphore.release();
-                }
-            }));
-        }
-        return results;
-    }
-    /**
-     * Find similar texts using optimized cosine similarity
-     */
-    async findSimilar(query, candidates, topK = 5) {
-        const queryEmb = await this.embed(query);
-        const candidateEmbs = await this.embedBatch(candidates);
-        const scores = candidateEmbs.map((emb, index) => ({
-            text: candidates[index],
-            score: cosineSimilarity(queryEmb, emb),
-            index
-        }));
-        return scores
-            .sort((a, b) => b.score - a.score)
-            .slice(0, topK);
-    }
-    /**
-     * Get cache statistics
-     */
-    getCacheStats() {
-        return {
-            size: this.cache.size,
-            maxSize: this.config.cacheSize
-        };
-    }
-    /**
-     * Clear the embedding cache
-     */
-    clearCache() {
-        this.cache.clear();
-    }
-    /**
-     * Check if initialized
-     */
-    isInitialized() {
-        return this.initialized;
-    }
-}
-// ============================================================================
-// Singleton Instance
-// ============================================================================
-let defaultEmbedder = null;
-export function getOptimizedEmbedder(config) {
-    if (!defaultEmbedder) {
-        defaultEmbedder = new OptimizedEmbedder(config);
-    }
-    return defaultEmbedder;
-}
-// ============================================================================
-// CLI Integration
-// ============================================================================
-export async function initEmbeddings(modelId) {
-    const id = modelId || DEFAULT_CONFIG.modelId;
-    console.log(`Initializing embeddings with model: ${id}`);
-    await downloadModel(id, DEFAULT_CONFIG.modelDir, (progress) => {
-        process.stdout.write(`\r  Downloading: ${progress.percent.toFixed(1)}% (${(progress.bytesDownloaded / 1024 / 1024).toFixed(1)}MB)`);
-    });
-    console.log('\n  ✓ Model downloaded');
-    const embedder = getOptimizedEmbedder({ modelId: id });
-    await embedder.init();
-    console.log('  ✓ Embedder initialized');
-    // Quick validation
-    const testEmb = await embedder.embed('test');
-    console.log(`  ✓ Validation: ${testEmb.length}d embedding, norm=${Math.sqrt(testEmb.reduce((s, v) => s + v * v, 0)).toFixed(4)}`);
-}
-//# sourceMappingURL=optimized-embedder.js.map