rag-lite-ts 2.1.1 → 2.3.0

package/dist/cjs/core/vector-index.js

@@ -0,0 +1,344 @@
+/**
+ * CORE MODULE — Shared between text-only (rag-lite-ts) and future multimodal (rag-lite-mm)
+ * Model-agnostic. No transformer or modality-specific logic.
+ *
+ * Worker-based implementation to prevent WebAssembly memory accumulation.
+ */
+import { Worker } from 'worker_threads';
+import { existsSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { handleError, ErrorCategory, ErrorSeverity, createError } from './error-handler.js';
+import { createMissingFileError, createDimensionMismatchError } from './actionable-error-messages.js';
+export class VectorIndex {
+    worker = null;
+    indexPath;
+    options;
+    messageQueue = new Map();
+    messageId = 0;
+    isInitialized = false;
+    constructor(indexPath, options) {
+        this.indexPath = indexPath;
+        this.options = {
+            efConstruction: 200,
+            M: 16,
+            seed: 100,
+            ...options
+        };
+    }
+    /**
+     * Get the path to the worker script
+     * Always uses compiled .js files - workers cannot execute TypeScript directly
+     */
+    getWorkerPath() {
+        const currentFile = fileURLToPath(import.meta.url);
+        const currentDir = dirname(currentFile);
+        // Always prefer .js (compiled output)
+        const jsPath = join(currentDir, 'vector-index-worker.js');
+        // Check if .js exists in current directory (compiled)
+        if (existsSync(jsPath)) {
+            return jsPath;
+        }
+        // If running from src/ (development), try dist/ paths
+        if (currentDir.includes('src')) {
+            // Find project root (go up from src/core)
+            const projectRoot = currentDir.replace(/[\\/]src[\\/]core.*$/, '');
+            const distEsmPath = join(projectRoot, 'dist', 'esm', 'core', 'vector-index-worker.js');
+            const distCjsPath = join(projectRoot, 'dist', 'cjs', 'core', 'vector-index-worker.js');
+            if (existsSync(distEsmPath)) {
+                return distEsmPath;
+            }
+            if (existsSync(distCjsPath)) {
+                return distCjsPath;
+            }
+        }
+        // If running from node_modules (installed package), try dist paths
+        if (currentDir.includes('node_modules')) {
+            const packageRoot = currentDir.split('node_modules')[0];
+            const distEsmPath = join(packageRoot, 'node_modules', 'rag-lite-ts', 'dist', 'esm', 'core', 'vector-index-worker.js');
+            const distCjsPath = join(packageRoot, 'node_modules', 'rag-lite-ts', 'dist', 'cjs', 'core', 'vector-index-worker.js');
+            if (existsSync(distEsmPath)) {
+                return distEsmPath;
+            }
+            if (existsSync(distCjsPath)) {
+                return distCjsPath;
+            }
+        }
+        // Final fallback - will fail with clear error
+        throw new Error(`Worker file not found. Expected: ${jsPath}\n` +
+            'Please run "npm run build" to compile the vector-index-worker.ts file.\n' +
+            `Current directory: ${currentDir}\n` +
+            `Checked paths: ${jsPath}, ${currentDir.includes('src') ? join(currentDir.replace(/[\\/]src[\\/]core.*$/, ''), 'dist', 'esm', 'core', 'vector-index-worker.js') : 'N/A'}`);
+    }
+    /**
+     * Ensure worker is created and ready
+     */
+    async ensureWorker() {
+        if (this.worker) {
+            return;
+        }
+        const workerPath = this.getWorkerPath();
+        this.worker = new Worker(workerPath);
+        // Set up message handler
+        this.worker.on('message', (response) => {
+            const handler = this.messageQueue.get(response.id);
+            if (handler) {
+                this.messageQueue.delete(response.id);
+                if (response.type === 'error') {
+                    handler.reject(new Error(response.error || 'Unknown error'));
+                }
+                else {
+                    handler.resolve(response.payload);
+                }
+            }
+        });
+        // Handle worker errors
+        this.worker.on('error', (error) => {
+            console.error('VectorIndex worker error:', error);
+            // Reject all pending requests
+            for (const [id, handler] of this.messageQueue.entries()) {
+                handler.reject(error);
+            }
+            this.messageQueue.clear();
+        });
+        // Handle worker exit
+        this.worker.on('exit', (code) => {
+            if (code !== 0) {
+                console.error(`VectorIndex worker exited with code ${code}`);
+            }
+            // Reject all pending requests
+            for (const [id, handler] of this.messageQueue.entries()) {
+                handler.reject(new Error(`Worker exited with code ${code}`));
+            }
+            this.messageQueue.clear();
+            this.worker = null;
+            this.isInitialized = false;
+        });
+    }
+    /**
+     * Send a message to the worker and wait for response
+     */
+    async sendMessage(type, payload) {
+        await this.ensureWorker();
+        return new Promise((resolve, reject) => {
+            const id = this.messageId++;
+            this.messageQueue.set(id, { resolve, reject });
+            const request = { id, type, payload };
+            this.worker.postMessage(request);
+        });
+    }
+    /**
+     * Convert Float32Array to ArrayBuffer for transfer
+     */
+    float32ArrayToBuffer(vector) {
+        const buffer = vector.buffer.slice(vector.byteOffset, vector.byteOffset + vector.byteLength);
+        // Ensure we return ArrayBuffer, not SharedArrayBuffer
+        return buffer instanceof ArrayBuffer ? buffer : new ArrayBuffer(0);
+    }
+    /**
+     * Initialize the HNSW index with cosine similarity using hnswlib-wasm
+     */
+    async initialize() {
+        try {
+            const payload = {
+                dimensions: this.options.dimensions,
+                maxElements: this.options.maxElements,
+                M: this.options.M,
+                efConstruction: this.options.efConstruction,
+                seed: this.options.seed,
+                indexPath: this.indexPath // Pass indexPath to worker for saveIndex operations
+            };
+            await this.sendMessage('init', payload);
+            this.isInitialized = true;
+            console.log(`Initialized HNSW index with ${this.options.dimensions} dimensions using hnswlib-wasm (worker)`);
+        }
+        catch (error) {
+            handleError(createError.index(`Failed to initialize vector index: ${error instanceof Error ? error.message : String(error)}`), 'Vector Index Initialization', {
+                category: ErrorCategory.INDEX,
+                severity: ErrorSeverity.FATAL
+            });
+            throw error;
+        }
+    }
+    /**
+     * Load existing index from file using hnswlib-wasm
+     */
+    async loadIndex() {
+        if (!existsSync(this.indexPath)) {
+            throw createMissingFileError(this.indexPath, 'index', {
+                operationContext: 'VectorIndex.loadIndex'
+            });
+        }
+        try {
+            const payload = {
+                indexPath: this.indexPath
+            };
+            const result = await this.sendMessage('loadIndex', payload);
+            this.isInitialized = true;
+            console.log(`✓ Loaded HNSW index with ${result.count} vectors from ${this.indexPath} (worker)`);
+        }
+        catch (error) {
+            throw new Error(`Failed to load index from ${this.indexPath}: ${error}`);
+        }
+    }
+    /**
+     * Save index to binary format
+     */
+    async saveIndex() {
+        if (!this.isInitialized) {
+            throw new Error('Index not initialized');
+        }
+        try {
+            const result = await this.sendMessage('saveIndex');
+            const actualSize = result.count;
+            console.log(`✓ Saved HNSW index with ${actualSize} vectors (${(actualSize * this.options.dimensions * 4 / 1024).toFixed(2)} KB of vector data) to ${this.indexPath} (worker)`);
+        }
+        catch (error) {
+            throw new Error(`Failed to save index to ${this.indexPath}: ${error}`);
+        }
+    }
+    /**
+     * Add a single vector to the HNSW index
+     * Now async due to worker-based implementation
+     */
+    async addVector(embeddingId, vector) {
+        if (!this.isInitialized) {
+            throw new Error('Index not initialized');
+        }
+        if (vector.length !== this.options.dimensions) {
+            throw createDimensionMismatchError(this.options.dimensions, vector.length, 'vector addition', { operationContext: 'VectorIndex.addVector' });
+        }
+        const payload = {
+            id: embeddingId,
+            vector: this.float32ArrayToBuffer(vector),
+            dimensions: vector.length
+        };
+        await this.sendMessage('addVector', payload);
+    }
+    /**
+     * Add multiple vectors to the index in batch
+     * Now async due to worker-based implementation
+     */
+    async addVectors(vectors) {
+        if (!this.isInitialized) {
+            throw new Error('Index not initialized');
+        }
+        const payload = {
+            vectors: vectors.map(v => ({
+                id: v.id,
+                vector: this.float32ArrayToBuffer(v.vector),
+                dimensions: v.vector.length
+            }))
+        };
+        await this.sendMessage('addVectors', payload);
+    }
+    /**
+     * Search for k nearest neighbors using hnswlib-wasm
+     * Now async due to worker-based implementation
+     */
+    async search(queryVector, k = 5) {
+        if (!this.isInitialized) {
+            throw new Error('Index not initialized');
+        }
+        if (queryVector.length !== this.options.dimensions) {
+            throw createDimensionMismatchError(this.options.dimensions, queryVector.length, 'vector search', { operationContext: 'VectorIndex.search' });
+        }
+        const payload = {
+            queryVector: this.float32ArrayToBuffer(queryVector),
+            dimensions: queryVector.length,
+            k
+        };
+        const result = await this.sendMessage('search', payload);
+        // Check if empty result
+        if (result.neighbors.length === 0 && result.distances.length === 0) {
+            return { neighbors: [], distances: [] };
+        }
+        return result;
+    }
+    /**
+     * Get current number of vectors in the index
+     * Now async due to worker-based implementation
+     */
+    async getCurrentCount() {
+        if (!this.isInitialized) {
+            return 0;
+        }
+        const result = await this.sendMessage('getCurrentCount');
+        return result.count;
+    }
+    /**
+     * Check if index exists on disk
+     */
+    indexExists() {
+        // This can be synchronous since it's just a file system check
+        return existsSync(this.indexPath);
+    }
+    /**
+     * Set search parameters for query time
+     * Now async due to worker-based implementation
+     */
+    async setEf(ef) {
+        if (!this.isInitialized) {
+            throw new Error('Index not initialized');
+        }
+        const payload = { ef };
+        try {
+            await this.sendMessage('setEf', payload);
+        }
+        catch (error) {
+            console.log(`Failed to set ef: ${error}`);
+        }
+    }
+    /**
+     * Resize index to accommodate more vectors
+     * Now async due to worker-based implementation
+     */
+    async resizeIndex(newMaxElements) {
+        if (!this.isInitialized) {
+            throw new Error('Index not initialized');
+        }
+        if (newMaxElements <= this.options.maxElements) {
+            throw new Error(`New max elements (${newMaxElements}) must be greater than current (${this.options.maxElements})`);
+        }
+        const payload = { newMaxElements };
+        await this.sendMessage('resizeIndex', payload);
+        this.options.maxElements = newMaxElements;
+        console.log(`Resized index to accommodate ${newMaxElements} vectors`);
+    }
+    /**
+     * Reset the vector index to an empty state.
+     * Clears all vectors from the HNSW graph and vectorStorage.
+     * The index parameters (dimensions, M, efConstruction) are preserved.
+     */
+    async reset() {
+        console.log('🔄 VectorIndex: Resetting to empty state...');
+        await this.sendMessage('reset');
+        console.log('✓ VectorIndex reset: cleared all vectors');
+    }
+    /**
+     * Get index options (for external access to configuration)
+     */
+    getOptions() {
+        return { ...this.options };
+    }
+    /**
+     * Cleanup: terminate worker and free all WebAssembly memory
+     */
+    async cleanup() {
+        if (this.worker) {
+            try {
+                // Send cleanup message (worker will acknowledge)
+                await this.sendMessage('cleanup');
+            }
+            catch (error) {
+                // Ignore errors during cleanup
+            }
+            // Terminate worker - this frees ALL WebAssembly memory
+            await this.worker.terminate();
+            this.worker = null;
+            this.isInitialized = false;
+            this.messageQueue.clear();
+        }
+    }
+}
+//# sourceMappingURL=vector-index.js.map

package/dist/{factories → cjs/factories}/ingestion-factory.js

@@ -296,8 +296,7 @@ export class IngestionFactory {
             // Preserve custom error messages for model mismatch and mode mismatch
             if (error instanceof Error && (error.message.includes('Model mismatch') ||
                 error.message.includes('Mode mismatch') ||
-                error.message.includes('--force-rebuild') ||
-                error.message.includes('--rebuild-if-needed'))) {
+                error.message.includes('--force-rebuild'))) {
                 throw error; // Re-throw custom validation errors as-is
             }
             throw createFactoryCreationError('IngestionFactory', error instanceof Error ? error.message : 'Unknown error', { operationContext: 'ingestion pipeline creation' });
@@ -366,13 +365,10 @@ export class IngestionFactory {
                             `❌ Model mismatch: Database is configured for '${existingSystemInfo.modelName}', but '${effectiveModel}' was requested.`,
                             '',
                             '🛠️  How to fix this:',
-                            '   1. Use --force-rebuild to change models:',
+                            '   1. Use --force-rebuild to rebuild from scratch:',
                             '      raglite ingest <path> --model ' + effectiveModel + ' --force-rebuild',
                             '',
-                            '   2. Or use --rebuild-if-needed for automatic handling:',
-                            '      raglite ingest <path> --model ' + effectiveModel + ' --rebuild-if-needed',
-                            '',
-                            '   3. Or continue using the existing model:',
+                            '   2. Or continue using the existing model:',
                             '      raglite ingest <path>  # Uses ' + existingSystemInfo.modelName,
                             '',
                             '🔍 Model switching requires rebuilding the vector index because different models',

package/dist/{factories → cjs/factories}/search-factory.js

@@ -281,6 +281,17 @@ export class SearchFactory {
                 enhancedMessage += '\n   The index was created with a different model. Rebuild the index:';
                 enhancedMessage += '\n   raglite ingest <directory> --force-rebuild';
             }
+            else if (error.message.includes('Cannot enlarge memory') ||
+                error.message.includes('WebAssembly memory limit') ||
+                error.message.includes('memory limit exceeded')) {
+                enhancedMessage += '\n\n💡 WebAssembly memory limit exceeded.';
+                enhancedMessage += '\n   Your vector index is too large for the 2GB WebAssembly memory limit.';
+                enhancedMessage += '\n   Solutions:';
+                enhancedMessage += '\n   1. Increase Node.js memory: node --max-old-space-size=4096 ...';
+                enhancedMessage += '\n   2. Split your data into smaller indexes';
+                enhancedMessage += '\n   3. Use a smaller embedding model (fewer dimensions)';
+                enhancedMessage += '\n   4. Rebuild the index with fewer vectors';
+            }
             return new Error(enhancedMessage);
         }
         return new Error(`SearchFactory.create failed: Unknown error`);

package/dist/{index-manager.d.ts → cjs/index-manager.d.ts}

@@ -86,11 +86,12 @@ export declare class IndexManager {
     saveGroupedIndex(textEmbeddings: EmbeddingResult[], imageEmbeddings: EmbeddingResult[]): Promise<void>;
     /**
      * Search for similar vectors
+     * Now async due to worker-based VectorIndex implementation
      */
-    search(queryVector: Float32Array, k?: number, contentType?: 'text' | 'image' | 'combined'): {
+    search(queryVector: Float32Array, k?: number, contentType?: 'text' | 'image' | 'combined'): Promise<{
         embeddingIds: string[];
         distances: number[];
-    };
+    }>;
     /**
      * Get index statistics
      */
@@ -109,8 +110,27 @@ export declare class IndexManager {
      */
     private unhashEmbeddingId;
     /**
-     * Close database connection
+     * Close database connection and cleanup vector index worker
      */
     close(): Promise<void>;
+    /**
+     * Reset the vector index by clearing all vectors while keeping the index structure.
+     * This is a safer alternative to file deletion that avoids file locking issues on Windows.
+     *
+     * The reset operation:
+     * 1. Clears in-memory HNSW index
+     * 2. Clears in-memory vector storage and ID mappings
+     * 3. Reinitializes an empty index with the same parameters
+     * 4. Saves the empty index to disk (overwrites existing file)
+     *
+     * @returns Promise that resolves when reset is complete
+     */
+    reset(): Promise<void>;
+    /**
+     * Check if the index has any vectors
+     * @returns true if the index contains vectors, false if empty
+     * Now async due to worker-based VectorIndex implementation
+     */
+    hasVectors(): Promise<boolean>;
 }
 //# sourceMappingURL=index-manager.d.ts.map

package/dist/{index-manager.js → cjs/index-manager.js}

@@ -64,7 +64,7 @@ export class IndexManager {
                 this.hashEmbeddingId(chunk.embedding_id); // This will populate the mapping
             }
             this.isInitialized = true;
-            const vectorCount = this.vectorIndex.getCurrentCount();
+            const vectorCount = await this.vectorIndex.getCurrentCount();
             console.log(`Index manager initialized with ${vectorCount} vectors${this.textIndex && this.imageIndex ? ' (multi-graph mode)' : ''}`);
         }
         catch (error) {
@@ -145,17 +145,18 @@ export class IndexManager {
                 vector: embedding.vector
             }));
             // Check if we need to resize the index before adding
-            const currentCount = this.vectorIndex.getCurrentCount();
-            const newCount = currentCount + vectors.length;
+            const initialCount = await this.vectorIndex.getCurrentCount();
+            const newCount = initialCount + vectors.length;
             const currentCapacity = 100000; // This should match the initial capacity
             if (newCount > currentCapacity * 0.9) {
                 const newCapacity = Math.ceil(newCount * 1.5);
                 console.log(`Resizing index from ${currentCapacity} to ${newCapacity} to accommodate new vectors`);
-                this.vectorIndex.resizeIndex(newCapacity);
+                await this.vectorIndex.resizeIndex(newCapacity);
             }
             // Add vectors incrementally (this is the key requirement - no rebuild needed)
-            this.vectorIndex.addVectors(vectors);
-            console.log(`Incrementally added ${embeddings.length} vectors to index (total: ${this.vectorIndex.getCurrentCount()})`);
+            await this.vectorIndex.addVectors(vectors);
+            const finalCount = await this.vectorIndex.getCurrentCount();
+            console.log(`Incrementally added ${embeddings.length} vectors to index (total: ${finalCount})`);
             // Save the updated index
             await this.saveIndex();
         }
@@ -223,7 +224,7 @@ export class IndexManager {
             const currentCapacity = 100000; // Default capacity
             if (chunkData.length > currentCapacity * 0.8) {
                 const newCapacity = Math.ceil(chunkData.length * 1.5);
-                this.vectorIndex.resizeIndex(newCapacity);
+                await this.vectorIndex.resizeIndex(newCapacity);
                 console.log(`Resized index capacity to ${newCapacity} for ${chunkData.length} chunks`);
             }
             // Update model version if provided
@@ -279,7 +280,7 @@ export class IndexManager {
             const currentCapacity = 100000;
             if (chunkData.length > currentCapacity * 0.8) {
                 const newCapacity = Math.ceil(chunkData.length * 1.5);
-                this.vectorIndex.resizeIndex(newCapacity);
+                await this.vectorIndex.resizeIndex(newCapacity);
                 console.log(`Resized index capacity to ${newCapacity}`);
             }
             // Re-generate embeddings for all chunks
@@ -294,7 +295,7 @@ export class IndexManager {
                 id: this.hashEmbeddingId(embedding.embedding_id),
                 vector: embedding.vector
             }));
-            this.vectorIndex.addVectors(vectors);
+            await this.vectorIndex.addVectors(vectors);
             console.log(`Added ${vectors.length} vectors to rebuilt index`);
             // Update model version
             await this.updateModelVersion(embeddingEngine.getModelVersion());
@@ -414,12 +415,12 @@ export class IndexManager {
                     // Create text-only index
                     this.textIndex = new VectorIndex(`${this.indexPath}.text`, this.vectorIndexOptions);
                     await this.textIndex.initialize();
-                    this.textIndex.addVectors(indexData.textVectors);
+                    await this.textIndex.addVectors(indexData.textVectors);
                     console.log(`✓ Text index created with ${indexData.textVectors.length} vectors`);
                     // Create image-only index
                     this.imageIndex = new VectorIndex(`${this.indexPath}.image`, this.vectorIndexOptions);
                     await this.imageIndex.initialize();
-                    this.imageIndex.addVectors(indexData.imageVectors);
+                    await this.imageIndex.addVectors(indexData.imageVectors);
                     console.log(`✓ Image index created with ${indexData.imageVectors.length} vectors`);
                     console.log('✓ Specialized indexes ready for content type filtering');
                 }
@@ -475,8 +476,9 @@ export class IndexManager {
     }
     /**
      * Search for similar vectors
+     * Now async due to worker-based VectorIndex implementation
      */
-    search(queryVector, k = 5, contentType) {
+    async search(queryVector, k = 5, contentType) {
         if (!this.isInitialized) {
             throw new Error('Index manager not initialized');
         }
@@ -499,7 +501,7 @@ export class IndexManager {
             // No specialized indexes (text-only mode) - ignore contentType and use combined index
             targetIndex = this.vectorIndex;
         }
-        const results = targetIndex.search(queryVector, k);
+        const results = await targetIndex.search(queryVector, k);
         // Convert numeric IDs back to embedding IDs
         const embeddingIds = results.neighbors.map(id => this.unhashEmbeddingId(id));
         return {
@@ -514,7 +516,7 @@ export class IndexManager {
         if (!this.db) {
             throw new Error('Database not initialized');
         }
-        const totalVectors = this.vectorIndex.getCurrentCount();
+        const totalVectors = await this.vectorIndex.getCurrentCount();
         try {
             const systemInfo = await getSystemInfo(this.db);
             const modelVersion = systemInfo?.modelVersion || null;
@@ -586,13 +588,80 @@ export class IndexManager {
         return embeddingId;
     }
     /**
-     * Close database connection
+     * Close database connection and cleanup vector index worker
      */
     async close() {
         if (this.db) {
             await this.db.close();
             this.db = null;
         }
+        // Clean up vector index worker to free WebAssembly memory
+        if (this.vectorIndex && typeof this.vectorIndex.cleanup === 'function') {
+            await this.vectorIndex.cleanup();
+        }
+        // Also clean up specialized indexes
+        if (this.textIndex && typeof this.textIndex.cleanup === 'function') {
+            await this.textIndex.cleanup();
+        }
+        if (this.imageIndex && typeof this.imageIndex.cleanup === 'function') {
+            await this.imageIndex.cleanup();
+        }
+    }
+    /**
+     * Reset the vector index by clearing all vectors while keeping the index structure.
+     * This is a safer alternative to file deletion that avoids file locking issues on Windows.
+     *
+     * The reset operation:
+     * 1. Clears in-memory HNSW index
+     * 2. Clears in-memory vector storage and ID mappings
+     * 3. Reinitializes an empty index with the same parameters
+     * 4. Saves the empty index to disk (overwrites existing file)
+     *
+     * @returns Promise that resolves when reset is complete
+     */
+    async reset() {
+        console.log('🔄 Starting index reset...');
+        const startTime = Date.now();
+        try {
+            // Clear in-memory mappings
+            const previousVectorCount = await this.vectorIndex.getCurrentCount();
+            this.hashToEmbeddingId.clear();
+            this.embeddingIdToHash.clear();
+            // Clear grouped embeddings if any
+            this.groupedEmbeddings = undefined;
+            // Clear specialized indexes if they exist
+            if (this.textIndex) {
+                this.textIndex = undefined;
+            }
+            if (this.imageIndex) {
+                this.imageIndex = undefined;
+            }
+            // Reset the vector index (clears all vectors and reinitializes empty HNSW graph)
+            console.log('  Resetting HNSW index...');
+            await this.vectorIndex.reset();
+            // Save the empty index to disk (this overwrites the existing file)
+            console.log('  Saving empty index to disk...');
+            await this.vectorIndex.saveIndex();
+            const resetTimeMs = Date.now() - startTime;
+            const currentCount = await this.vectorIndex.getCurrentCount();
+            console.log(`✓ Index reset complete in ${resetTimeMs}ms`);
+            console.log(`  Vectors cleared: ${previousVectorCount}`);
+            console.log(`  Current vector count: ${currentCount}`);
+        }
+        catch (error) {
+            const resetTimeMs = Date.now() - startTime;
+            console.error(`❌ Index reset failed after ${resetTimeMs}ms:`, error);
+            throw new Error(`Failed to reset index: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Check if the index has any vectors
+     * @returns true if the index contains vectors, false if empty
+     * Now async due to worker-based VectorIndex implementation
+     */
+    async hasVectors() {
+        const count = await this.vectorIndex.getCurrentCount();
+        return count > 0;
     }
 }
 //# sourceMappingURL=index-manager.js.map

package/dist/{index.d.ts → cjs/index.d.ts}

@@ -59,7 +59,8 @@ export { CrossEncoderReranker, createTextRerankFunction } from './text/reranker.
 export { countTokens } from './text/tokenizer.js';
 export type { RerankingStrategyType, RerankingConfig } from './core/reranking-config.js';
 export { validateRerankingStrategy, validateRerankingConfig, getDefaultRerankingConfig, isStrategySupported, getSupportedStrategies, RerankingConfigBuilder, DEFAULT_TEXT_RERANKING_CONFIG, DEFAULT_MULTIMODAL_RERANKING_CONFIG } from './core/reranking-config.js';
-export { openDatabase, initializeSchema, insertDocument, insertChunk, upsertDocument, getChunksByEmbeddingIds, type DatabaseConnection } from './core/db.js';
+export { openDatabase, initializeSchema, insertDocument, insertChunk, upsertDocument, getChunksByEmbeddingIds, resetDatabase, hasDatabaseData, type DatabaseConnection, type DatabaseResetOptions, type DatabaseResetResult } from './core/db.js';
+export { KnowledgeBaseManager, type KnowledgeBaseResetOptions, type KnowledgeBaseResetResult } from './core/knowledge-base-manager.js';
 export { IndexManager } from './index-manager.js';
 export { VectorIndex } from './core/vector-index.js';
 export { config, getModelDefaults, type CoreConfig, type ExtensibleConfig, type ModelDefaults, EXIT_CODES, ConfigurationError, getDefaultModelCachePath, handleUnrecoverableError, logError } from './core/config.js';

package/dist/{index.js → cjs/index.js}

@@ -83,7 +83,9 @@ export { validateRerankingStrategy, validateRerankingConfig, getDefaultReranking
 // CORE INFRASTRUCTURE (FOR ADVANCED USERS)
 // =============================================================================
 // Database operations
-export { openDatabase, initializeSchema, insertDocument, insertChunk, upsertDocument, getChunksByEmbeddingIds } from './core/db.js';
+export { openDatabase, initializeSchema, insertDocument, insertChunk, upsertDocument, getChunksByEmbeddingIds, resetDatabase, hasDatabaseData } from './core/db.js';
+// Knowledge Base Manager (for reset operations)
+export { KnowledgeBaseManager } from './core/knowledge-base-manager.js';
 // Vector index management
 export { IndexManager } from './index-manager.js';
 export { VectorIndex } from './core/vector-index.js';