rag-lite-ts 1.0.2 → 2.0.1

package/dist/text/sentence-transformer-embedder.d.ts

@@ -0,0 +1,96 @@
+/**
+ * TEXT IMPLEMENTATION — Sentence Transformer Embedder Implementation
+ * Implements UniversalEmbedder interface for sentence-transformer models
+ * Adapts existing text embedding logic to the universal interface
+ */
+import '../dom-polyfills.js';
+import { BaseUniversalEmbedder, type EmbedderOptions } from '../core/abstract-embedder.js';
+import type { EmbeddingResult } from '../types.js';
+/**
+ * Sentence transformer embedder implementation
+ * Supports sentence-transformers/all-MiniLM-L6-v2 and Xenova/all-mpnet-base-v2
+ * Ensures consistent EmbeddingResult format with contentType='text'
+ * Adapts existing EmbeddingEngine to UniversalEmbedder interface
+ */
+export declare class SentenceTransformerEmbedder extends BaseUniversalEmbedder {
+    private embeddingEngine;
+    private resourceManager;
+    private embedderResourceId?;
+    private engineResourceId?;
+    constructor(modelName: string, options?: EmbedderOptions);
+    /**
+     * Load the sentence transformer model using existing EmbeddingEngine
+     */
+    loadModel(): Promise<void>;
+    /**
+     * Clean up model resources with comprehensive disposal
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Embed text using the existing EmbeddingEngine
+     */
+    embedText(text: string): Promise<EmbeddingResult>;
+    /**
+     * Optimized batch processing using existing EmbeddingEngine and BatchProcessingOptimizer
+     * Overrides the base implementation for better performance with progress reporting
+     */
+    protected processBatch(batch: Array<{
+        content: string;
+        contentType: string;
+        metadata?: Record<string, any>;
+    }>): Promise<EmbeddingResult[]>;
+    /**
+     * Get model-specific information
+     */
+    getModelInfo(): {
+        capabilities: {
+            supportsSemanticSimilarity: boolean;
+            supportsTextClassification: boolean;
+            supportsTextClustering: boolean;
+            recommendedUseCase: string;
+            supportsText: boolean;
+            supportsImages: boolean;
+            supportsBatchProcessing: boolean;
+            supportsMetadata: boolean;
+            maxBatchSize?: number;
+            maxTextLength?: number;
+            supportedImageFormats?: readonly string[];
+            supportsMultimodal?: boolean;
+            supportsCrossModalSearch?: boolean;
+            unifiedEmbeddingSpace?: boolean;
+            reliableImplementation?: boolean;
+        };
+        name: string;
+        type: import("../core/universal-embedder.js").ModelType;
+        dimensions: number;
+        version: string;
+        supportedContentTypes: readonly string[];
+        requirements: import("../types.js").ModelRequirements;
+    };
+    /**
+     * Check if the model is suitable for a specific task
+     */
+    isSuitableForTask(task: 'similarity' | 'classification' | 'clustering' | 'retrieval'): boolean;
+    /**
+     * Embed document batch using existing EmbeddingEngine's optimized method
+     * This method provides compatibility with the existing document ingestion pipeline
+     */
+    embedDocumentBatch(chunks: string[]): Promise<EmbeddingResult[]>;
+    /**
+     * Get the model version from the underlying EmbeddingEngine
+     */
+    getModelVersion(): string;
+    /**
+     * Get the batch size from the underlying EmbeddingEngine
+     */
+    getBatchSize(): number;
+    /**
+     * Check if the underlying EmbeddingEngine is loaded
+     */
+    isEngineLoaded(): boolean;
+    /**
+     * Override isLoaded to check both internal state and engine state
+     */
+    isLoaded(): boolean;
+}
+//# sourceMappingURL=sentence-transformer-embedder.d.ts.map

package/dist/text/sentence-transformer-embedder.js

@@ -0,0 +1,340 @@
+/**
+ * TEXT IMPLEMENTATION — Sentence Transformer Embedder Implementation
+ * Implements UniversalEmbedder interface for sentence-transformer models
+ * Adapts existing text embedding logic to the universal interface
+ */
+// Ensure DOM polyfills are set up before any other imports
+import '../dom-polyfills.js';
+import { BaseUniversalEmbedder } from '../core/abstract-embedder.js';
+import { EmbeddingEngine } from './embedder.js';
+import { getResourceManager } from '../core/resource-manager.js';
+// =============================================================================
+// SENTENCE TRANSFORMER EMBEDDER IMPLEMENTATION
+// =============================================================================
+/**
+ * Sentence transformer embedder implementation
+ * Supports sentence-transformers/all-MiniLM-L6-v2 and Xenova/all-mpnet-base-v2
+ * Ensures consistent EmbeddingResult format with contentType='text'
+ * Adapts existing EmbeddingEngine to UniversalEmbedder interface
+ */
+export class SentenceTransformerEmbedder extends BaseUniversalEmbedder {
+    embeddingEngine = null;
+    resourceManager = getResourceManager();
+    embedderResourceId;
+    engineResourceId;
+    constructor(modelName, options = {}) {
+        super(modelName, options);
+        // Register this embedder with the resource manager
+        this.embedderResourceId = this.resourceManager.registerEmbedder(this);
+    }
+    // =============================================================================
+    // MODEL LIFECYCLE METHODS
+    // =============================================================================
+    /**
+     * Load the sentence transformer model using existing EmbeddingEngine
+     */
+    async loadModel() {
+        // Check if already loaded and engine is ready
+        if (this._isLoaded && this.embeddingEngine?.isLoaded()) {
+            return;
+        }
+        try {
+            this.logModelLoading('Loading sentence transformer model');
+            // Create EmbeddingEngine if not exists
+            if (!this.embeddingEngine) {
+                this.embeddingEngine = new EmbeddingEngine(this.modelName, this.options.maxBatchSize || this._modelInfo.capabilities.maxBatchSize || 8);
+            }
+            // Load the model using the existing engine (only if not already loaded)
+            if (!this.embeddingEngine.isLoaded()) {
+                await this.embeddingEngine.loadModel();
+            }
+            // Register the embedding engine with resource manager if not already registered
+            if (!this.engineResourceId) {
+                this.engineResourceId = this.resourceManager.registerModel(this.embeddingEngine, this.modelName, 'sentence-transformer');
+            }
+            // Synchronize loading state
+            this._isLoaded = this.embeddingEngine.isLoaded();
+            if (this._isLoaded) {
+                this.logModelLoading('Model loaded successfully');
+            }
+            else {
+                throw new Error('Model loading failed - engine reports not loaded');
+            }
+        }
+        catch (error) {
+            // Reset state on failure
+            this._isLoaded = false;
+            const enhancedError = this.handleLoadingError(error);
+            throw enhancedError;
+        }
+    }
+    /**
+     * Clean up model resources with comprehensive disposal
+     */
+    async cleanup() {
+        let cleanupErrors = [];
+        try {
+            // Clean up embedding engine resources
+            if (this.embeddingEngine) {
+                try {
+                    // Use resource manager for proper cleanup
+                    if (this.engineResourceId) {
+                        await this.resourceManager.cleanupResource(this.engineResourceId);
+                        this.engineResourceId = undefined;
+                    }
+                    // Clear the reference (EmbeddingEngine doesn't have cleanup methods)
+                    this.embeddingEngine = null;
+                    this.logModelLoading('Sentence transformer embedding engine disposed');
+                }
+                catch (error) {
+                    const errorMsg = `Failed to dispose embedding engine: ${error instanceof Error ? error.message : 'Unknown error'}`;
+                    cleanupErrors.push(errorMsg);
+                    console.warn(errorMsg);
+                    // Force clear reference even if disposal failed
+                    this.embeddingEngine = null;
+                }
+            }
+            // Clear embedder resource registration (don't call resource manager to avoid circular cleanup)
+            if (this.embedderResourceId) {
+                this.embedderResourceId = undefined;
+            }
+        }
+        finally {
+            // Always clear loaded state regardless of cleanup success
+            this._isLoaded = false;
+            // Remove from lazy loading cache to ensure fresh instances
+            try {
+                const { LazyEmbedderLoader } = await import('../core/lazy-dependency-loader.js');
+                LazyEmbedderLoader.removeEmbedderFromCache(this.modelName, 'sentence-transformer');
+            }
+            catch (error) {
+                console.warn('Failed to remove embedder from cache:', error);
+            }
+            // Force garbage collection for sentence transformer models
+            if (global.gc) {
+                global.gc();
+                this.logModelLoading('Forced garbage collection after sentence transformer cleanup');
+            }
+            // Log cleanup completion
+            if (cleanupErrors.length === 0) {
+                this.logModelLoading('Sentence transformer resources cleaned up successfully');
+            }
+            else {
+                this.logModelLoading(`Sentence transformer cleanup completed with ${cleanupErrors.length} errors`);
+                // Don't throw errors during cleanup - just log them
+            }
+        }
+    }
+    // =============================================================================
+    // EMBEDDING METHODS
+    // =============================================================================
+    /**
+     * Embed text using the existing EmbeddingEngine
+     */
+    async embedText(text) {
+        // Validate input first, before checking if model is loaded
+        if (!text || text.trim().length === 0) {
+            throw new Error('Text input cannot be empty');
+        }
+        this.ensureLoaded();
+        // Update resource usage tracking
+        if (this.embedderResourceId) {
+            this.resourceManager.updateResourceUsage(this.embedderResourceId);
+        }
+        if (this.engineResourceId) {
+            this.resourceManager.updateResourceUsage(this.engineResourceId);
+        }
+        if (!this.embeddingEngine) {
+            throw new Error('Embedding engine not initialized');
+        }
+        try {
+            // Validate and truncate text if necessary
+            this.validateTextLength(text);
+            const processedText = this.truncateText(text.trim());
+            // Use the existing EmbeddingEngine to generate embeddings
+            const result = await this.embeddingEngine.embedSingle(processedText);
+            // Validate embedding dimensions
+            if (result.vector.length !== this.dimensions) {
+                throw new Error(`Embedding dimension mismatch: expected ${this.dimensions}, got ${result.vector.length}`);
+            }
+            // Ensure contentType is always present for UniversalEmbedder interface
+            return {
+                ...result,
+                contentType: 'text'
+            };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to embed text: ${error.message}`);
+            }
+            throw new Error('Failed to embed text: Unknown error');
+        }
+    }
+    // =============================================================================
+    // BATCH PROCESSING OPTIMIZATION
+    // =============================================================================
+    /**
+     * Optimized batch processing using existing EmbeddingEngine and BatchProcessingOptimizer
+     * Overrides the base implementation for better performance with progress reporting
+     */
+    async processBatch(batch) {
+        this.ensureLoaded();
+        if (!this.embeddingEngine) {
+            throw new Error('Embedding engine not initialized');
+        }
+        // Filter for text content only (sentence transformers don't support other types)
+        const textItems = batch.filter(item => item.contentType === 'text');
+        if (textItems.length === 0) {
+            return [];
+        }
+        // For small batches, use the existing EmbeddingEngine directly
+        if (textItems.length <= 10) {
+            try {
+                // Prepare texts for batch processing
+                const texts = textItems.map(item => this.truncateText(item.content.trim()));
+                // Use the existing EmbeddingEngine's batch processing
+                const results = await this.embeddingEngine.embedBatch(texts);
+                // Validate dimensions for all results
+                for (let i = 0; i < results.length; i++) {
+                    if (results[i].vector.length !== this.dimensions) {
+                        throw new Error(`Embedding dimension mismatch for item ${i}: expected ${this.dimensions}, got ${results[i].vector.length}`);
+                    }
+                }
+                return results;
+            }
+            catch (error) {
+                // Fall back to individual processing if batch fails
+                console.warn(`Batch processing failed, falling back to individual processing: ${error}`);
+                return super.processBatch(batch);
+            }
+        }
+        // For larger batches, use the BatchProcessingOptimizer
+        try {
+            const { createTextBatchProcessor } = await import('../core/batch-processing-optimizer.js');
+            const batchProcessor = createTextBatchProcessor();
+            // Convert to EmbeddingBatchItem format
+            const batchItems = textItems.map(item => ({
+                content: this.truncateText(item.content.trim()),
+                contentType: item.contentType,
+                metadata: item.metadata
+            }));
+            // Create embed function that uses this embedder
+            const embedFunction = async (item) => {
+                const result = await this.embeddingEngine.embedSingle(item.content);
+                // Validate dimensions
+                if (result.vector.length !== this.dimensions) {
+                    throw new Error(`Embedding dimension mismatch: expected ${this.dimensions}, got ${result.vector.length}`);
+                }
+                return result;
+            };
+            // Process with optimization and progress reporting
+            const batchResult = await batchProcessor.processBatch(batchItems, embedFunction, (stats) => {
+                if (stats.totalItems > 50) { // Only log for larger batches
+                    console.log(`Text embedding progress: ${stats.processedItems}/${stats.totalItems} (${Math.round((stats.processedItems / stats.totalItems) * 100)}%)`);
+                }
+            });
+            // Log final statistics for large batches
+            if (batchResult.stats.totalItems > 50) {
+                console.log(`✓ Text embedding complete: ${batchResult.stats.processedItems} processed, ${batchResult.stats.failedItems} failed`);
+                console.log(`  Processing time: ${Math.round(batchResult.stats.processingTimeMs / 1000)}s, Rate: ${Math.round(batchResult.stats.itemsPerSecond)} items/sec`);
+                if (batchResult.stats.peakMemoryUsageMB > 100) {
+                    console.log(`  Peak memory usage: ${batchResult.stats.peakMemoryUsageMB}MB`);
+                }
+            }
+            return batchResult.results;
+        }
+        catch (error) {
+            // Fall back to existing implementation if optimizer fails
+            console.warn(`Batch processing optimizer failed, using fallback: ${error}`);
+            try {
+                const texts = textItems.map(item => this.truncateText(item.content.trim()));
+                const results = await this.embeddingEngine.embedBatch(texts);
+                for (let i = 0; i < results.length; i++) {
+                    if (results[i].vector.length !== this.dimensions) {
+                        throw new Error(`Embedding dimension mismatch for item ${i}: expected ${this.dimensions}, got ${results[i].vector.length}`);
+                    }
+                }
+                return results;
+            }
+            catch (fallbackError) {
+                console.warn(`Fallback batch processing failed, using individual processing: ${fallbackError}`);
+                return super.processBatch(batch);
+            }
+        }
+    }
+    // =============================================================================
+    // UTILITY METHODS
+    // =============================================================================
+    /**
+     * Get model-specific information
+     */
+    getModelInfo() {
+        const baseInfo = super.getModelInfo();
+        return {
+            ...baseInfo,
+            capabilities: {
+                ...baseInfo.capabilities,
+                // Sentence transformers are optimized for text similarity
+                supportsSemanticSimilarity: true,
+                supportsTextClassification: true,
+                supportsTextClustering: true,
+                recommendedUseCase: 'text similarity and semantic search'
+            }
+        };
+    }
+    /**
+     * Check if the model is suitable for a specific task
+     */
+    isSuitableForTask(task) {
+        // Sentence transformers are suitable for all text-based tasks
+        const supportedTasks = ['similarity', 'classification', 'clustering', 'retrieval'];
+        return supportedTasks.includes(task);
+    }
+    // =============================================================================
+    // ADDITIONAL METHODS FOR COMPATIBILITY WITH EXISTING SYSTEM
+    // =============================================================================
+    /**
+     * Embed document batch using existing EmbeddingEngine's optimized method
+     * This method provides compatibility with the existing document ingestion pipeline
+     */
+    async embedDocumentBatch(chunks) {
+        this.ensureLoaded();
+        if (!this.embeddingEngine) {
+            throw new Error('Embedding engine not initialized');
+        }
+        // Use the existing EmbeddingEngine's document batch processing
+        // which includes progress logging and error handling
+        return await this.embeddingEngine.embedDocumentBatch(chunks);
+    }
+    /**
+     * Get the model version from the underlying EmbeddingEngine
+     */
+    getModelVersion() {
+        if (!this.embeddingEngine) {
+            throw new Error('Embedding engine not initialized');
+        }
+        return this.embeddingEngine.getModelVersion();
+    }
+    /**
+     * Get the batch size from the underlying EmbeddingEngine
+     */
+    getBatchSize() {
+        if (!this.embeddingEngine) {
+            return this.options.maxBatchSize || this._modelInfo.capabilities.maxBatchSize || 8;
+        }
+        return this.embeddingEngine.getBatchSize();
+    }
+    /**
+     * Check if the underlying EmbeddingEngine is loaded
+     */
+    isEngineLoaded() {
+        return this.embeddingEngine ? this.embeddingEngine.isLoaded() : false;
+    }
+    /**
+     * Override isLoaded to check both internal state and engine state
+     */
+    isLoaded() {
+        return this._isLoaded && this.isEngineLoaded();
+    }
+}
+//# sourceMappingURL=sentence-transformer-embedder.js.map

package/dist/types.d.ts

@@ -19,10 +19,17 @@ export interface Document {
     source: string;
     title: string;
     content: string;
+    metadata?: Record<string, any>;
 }
 export interface EmbeddingResult {
     embedding_id: string;
     vector: Float32Array;
+    contentType?: string;
+    metadata?: Record<string, any>;
+}
+export interface EnhancedEmbeddingResult extends EmbeddingResult {
+    contentType: string;
+    metadata?: Record<string, any>;
 }
 export interface Preprocessor {
     appliesTo(language: string): boolean;
@@ -40,5 +47,37 @@ export interface PreprocessingConfig {
         code?: 'strip' | 'keep' | 'placeholder';
     };
 }
+export type ModeType = 'text' | 'multimodal';
+export type ModelType = 'sentence-transformer' | 'clip';
+export type { RerankingStrategyType, RerankingConfig } from './core/reranking-config.js';
+import type { RerankingStrategyType, RerankingConfig } from './core/reranking-config.js';
+export interface SystemInfo {
+    mode: ModeType;
+    modelName: string;
+    modelType: ModelType;
+    modelDimensions: number;
+    modelVersion: string;
+    supportedContentTypes: string[];
+    rerankingStrategy: RerankingStrategyType;
+    rerankingModel?: string;
+    rerankingConfig?: RerankingConfig;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface SystemInfoRow {
+    id: number;
+    mode: string;
+    model_name: string;
+    model_type: string;
+    model_dimensions: number;
+    model_version: string;
+    supported_content_types: string;
+    reranking_strategy: string;
+    reranking_model?: string;
+    reranking_config?: string;
+    created_at: string;
+    updated_at: string;
+}
 export type { DatabaseConnection, ContentChunk } from './core/db.js';
+export type { UniversalEmbedder, ModelInfo, ModelCapabilities, ModelRequirements, EmbeddingBatchItem, ModelValidationResult, CreateEmbedderFunction, EmbedderCreationOptions, ContentType } from './core/universal-embedder.js';
 //# sourceMappingURL=types.d.ts.map

package/dist/utils/vector-math.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Vector mathematics utilities for embedding operations
+ */
+/**
+ * Compute cosine similarity between two vectors
+ * @param a - First vector (Float32Array or number array)
+ * @param b - Second vector (Float32Array or number array)
+ * @returns Cosine similarity score between -1 and 1
+ */
+export declare function cosineSimilarity(a: Float32Array | number[], b: Float32Array | number[]): number;
+/**
+ * Compute Euclidean distance between two vectors
+ * @param a - First vector
+ * @param b - Second vector
+ * @returns Euclidean distance
+ */
+export declare function euclideanDistance(a: Float32Array | number[], b: Float32Array | number[]): number;
+/**
+ * Compute dot product between two vectors
+ * @param a - First vector
+ * @param b - Second vector
+ * @returns Dot product
+ */
+export declare function dotProduct(a: Float32Array | number[], b: Float32Array | number[]): number;
+/**
+ * Compute vector magnitude (L2 norm)
+ * @param vector - Input vector
+ * @returns Vector magnitude
+ */
+export declare function magnitude(vector: Float32Array | number[]): number;
+//# sourceMappingURL=vector-math.d.ts.map

package/dist/utils/vector-math.js

@@ -0,0 +1,70 @@
+/**
+ * Vector mathematics utilities for embedding operations
+ */
+/**
+ * Compute cosine similarity between two vectors
+ * @param a - First vector (Float32Array or number array)
+ * @param b - Second vector (Float32Array or number array)
+ * @returns Cosine similarity score between -1 and 1
+ */
+export function cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+        throw new Error('Vectors must have the same 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 magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+    return magnitude === 0 ? 0 : dotProduct / magnitude;
+}
+/**
+ * Compute Euclidean distance between two vectors
+ * @param a - First vector
+ * @param b - Second vector
+ * @returns Euclidean distance
+ */
+export function euclideanDistance(a, b) {
+    if (a.length !== b.length) {
+        throw new Error('Vectors must have the same length');
+    }
+    let sum = 0;
+    for (let i = 0; i < a.length; i++) {
+        const diff = a[i] - b[i];
+        sum += diff * diff;
+    }
+    return Math.sqrt(sum);
+}
+/**
+ * Compute dot product between two vectors
+ * @param a - First vector
+ * @param b - Second vector
+ * @returns Dot product
+ */
+export function dotProduct(a, b) {
+    if (a.length !== b.length) {
+        throw new Error('Vectors must have the same length');
+    }
+    let product = 0;
+    for (let i = 0; i < a.length; i++) {
+        product += a[i] * b[i];
+    }
+    return product;
+}
+/**
+ * Compute vector magnitude (L2 norm)
+ * @param vector - Input vector
+ * @returns Vector magnitude
+ */
+export function magnitude(vector) {
+    let sum = 0;
+    for (let i = 0; i < vector.length; i++) {
+        sum += vector[i] * vector[i];
+    }
+    return Math.sqrt(sum);
+}
+//# sourceMappingURL=vector-math.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rag-lite-ts",
-  "version": "1.0.2",
-  "description": "Local-first TypeScript retrieval engine for semantic search over static documents",
+  "version": "2.0.1",
+  "description": "Local-first TypeScript retrieval engine with Chameleon Multimodal Architecture for semantic search over text and image content",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,7 +20,9 @@
     }
   },
   "files": [
-    "dist/**/*",
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "!dist/**/*.map",
     "README.md",
     "LICENSE"
   ],
@@ -29,9 +31,16 @@
     "build:test": "tsc --project tsconfig.test.json",
     "clean": "rimraf dist",
     "dev": "tsc --watch",
-    "test": "npm run build:test && node --test dist/text/tokenizer.test.js dist/core/chunker.test.js dist/text/embedder.test.js dist/core/vector-index.test.js dist/index-manager.test.js dist/core/search.test.js dist/file-processor.test.js dist/mcp-server.test.js dist/preprocess.test.js dist/core/config.test.js dist/preprocessors/integration.test.js dist/cli/cli.test.js",
-    "test:integration": "npm run build && npm run build:test && node --test dist/integration.test.js",
-    "test:all": "npm run test && npm run test:integration",
+    "test": "npm run build:test && node --expose-gc --test --test-concurrency=1 dist/__tests__/core dist/__tests__/text dist/__tests__/preprocessors",
+    "test:verbose": "npm run build:test && node --expose-gc --test --test-concurrency=1 --test-reporter=tap dist/__tests__/core dist/__tests__/text dist/__tests__/preprocessors",
+    "test:core": "npm run build:test && node --expose-gc --test --test-concurrency=1 dist/__tests__/core",
+    "test:core:verbose": "npm run build:test && node --expose-gc --test --test-concurrency=1 --test-reporter=tap dist/__tests__/core",
+    "test:text": "npm run build:test && node --expose-gc --test --test-concurrency=1 dist/__tests__/text",
+    "test:preprocessors": "npm run build:test && node --expose-gc --test --test-concurrency=1 dist/__tests__/preprocessors",
+    "test:integration": "npm run build && npm run build:test && node --expose-gc --test --test-concurrency=1 dist/__tests__/integration",
+    "test:integration:verbose": "npm run build && npm run build:test && node --expose-gc --test --test-concurrency=1 --test-reporter=tap dist/__tests__/integration",
+    "test:all": "npm run build:test && node --expose-gc --test --test-concurrency=1 dist/__tests__",
+    "test:all:verbose": "npm run build:test && node --expose-gc --test --test-concurrency=1 --test-reporter=tap dist/__tests__",
     "prepublishOnly": "npm run clean && npm run build"
   },
   "keywords": [
@@ -41,6 +50,11 @@
     "embeddings",
     "typescript",
     "local-first",
+    "multimodal",
+    "chameleon-architecture",
+    "clip",
+    "image-search",
+    "polymorphic-runtime",
     "mdx",
     "mermaid",
     "preprocessing",
@@ -64,17 +78,24 @@
   "dependencies": {
     "@huggingface/transformers": "^3.7.5",
     "@modelcontextprotocol/sdk": "^1.18.2",
+    "csv-parse": "^6.1.0",
     "hnswlib-wasm": "^0.8.2",
     "jsdom": "^27.0.0",
+    "lru-cache": "^11.2.2",
     "mammoth": "^1.11.0",
     "pdf-parse": "^2.1.10",
     "sqlite3": "^5.1.6"
   },
   "devDependencies": {
     "@types/jsdom": "^21.1.7",
+    "@types/lru-cache": "^7.10.9",
     "@types/node": "^20.11.0",
     "js-yaml": "^4.1.0",
     "rimraf": "^5.0.5",
+    "tsx": "^4.20.6",
     "typescript": "^5.3.0"
+  },
+  "optionalDependencies": {
+    "sharp": "^0.34.5"
   }
 }

package/dist/api-errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api-errors.d.ts","sourceRoot":"","sources":["../src/api-errors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,8BAAsB,QAAS,SAAQ,KAAK;IAGjC,IAAI,EAAE,MAAM;IACZ,WAAW,EAAE,MAAM,EAAE;IACrB,OAAO,CAAC,EAAE,MAAM;gBAHvB,OAAO,EAAE,MAAM,EACR,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EAAE,EACrB,OAAO,CAAC,EAAE,MAAM,YAAA;IAMzB;;OAEG;IACH,mBAAmB,IAAI,MAAM;IAa7B;;OAEG;IACH,QAAQ,IAAI,IAAI;CAejB;AAED;;GAEG;AACH,qBAAa,cAAe,SAAQ,QAAQ;gBAC9B,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM;CAGnF;AAED;;GAEG;AACH,qBAAa,WAAY,SAAQ,QAAQ;gBAC3B,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM;CAGnF;AAED;;GAEG;AACH,qBAAa,aAAc,SAAQ,QAAQ;gBAC7B,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM;CAGnF;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,QAAQ;gBACvC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM;CAGnF;AAED;;;GAGG;AACH,qBAAa,YAAY;IACvB;;OAEG;IACH,MAAM,CAAC,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,cAAc;IA+G5E;;OAEG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,WAAW;IA4HtE;;OAEG;IACH,MAAM,CAAC,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,aAAa;CA4C3E;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY;IACvB;;OAEG;;IAYH;;OAEG;;IAYH;;OAEG;;IAYH;;OAEG;;CAYJ,CAAC;AAEF;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,GAAG,QAAQ,GAAG,UAAU,GAAG,KAAK,CA4BrH"}