rag-lite-ts 2.2.0 → 2.3.0

package/dist/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/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/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';

package/dist/esm/cli/indexer.js

@@ -80,7 +80,7 @@ async function validateModeConfiguration(options) {
  */
 export async function runIngest(path, options = {}) {
     try {
-        // Handle --rebuild-if-needed flag immediately to prevent dimension mismatch error
+        // Handle --force-rebuild flag immediately to prevent dimension mismatch errors
         // Validate path exists
         const resolvedPath = resolve(path);
         if (!existsSync(resolvedPath)) {
@@ -159,26 +159,52 @@ export async function runIngest(path, options = {}) {
             factoryOptions.mode = options.mode;
             console.log(`Using processing mode: ${options.mode}`);
         }
-        if (options.rebuildIfNeeded) {
+        if (options.forceRebuild) {
             factoryOptions.forceRebuild = true;
-            console.log('Force rebuild enabled due to rebuildIfNeeded option');
-            // Delete old index file immediately to prevent dimension mismatch errors
-            const indexPath = process.env.RAG_INDEX_FILE || './vector-index.bin';
-            const { existsSync, unlinkSync } = await import('fs');
-            if (existsSync(indexPath)) {
-                try {
-                    unlinkSync(indexPath);
-                    console.log('🗑️ Removed old index file to prevent dimension mismatch');
-                }
-                catch (error) {
-                    console.warn(`⚠️ Could not remove old index file: ${error}`);
-                }
-            }
+            console.log('Force rebuild enabled (--force-rebuild)');
         }
         // Validate mode-specific model and strategy combinations
         await validateModeConfiguration(factoryOptions);
         const dbPath = process.env.RAG_DB_FILE || './db.sqlite';
         const indexPath = process.env.RAG_INDEX_FILE || './vector-index.bin';
+        // --force-rebuild: Always delete DB (and sidecars) and index to guarantee a clean rebuild.
+        if (options.forceRebuild) {
+            try {
+                const { existsSync: fsExistsSync, unlinkSync } = await import('fs');
+                console.log('🗑️ Deleting existing database and index to perform a clean rebuild...');
+                // Remove WAL/SHM if present (common on SQLite with WAL journaling).
+                const sidecars = [`${dbPath}-wal`, `${dbPath}-shm`];
+                for (const p of sidecars) {
+                    if (fsExistsSync(p)) {
+                        try {
+                            unlinkSync(p);
+                        }
+                        catch (e) {
+                            console.warn(`⚠️ Could not remove SQLite sidecar file (${p}):`, e);
+                        }
+                    }
+                }
+                if (fsExistsSync(dbPath)) {
+                    try {
+                        unlinkSync(dbPath);
+                    }
+                    catch (e) {
+                        console.warn(`⚠️ Could not remove database file (${dbPath}):`, e);
+                    }
+                }
+                if (fsExistsSync(indexPath)) {
+                    try {
+                        unlinkSync(indexPath);
+                    }
+                    catch (e) {
+                        console.warn(`⚠️ Could not remove index file (${indexPath}):`, e);
+                    }
+                }
+            }
+            catch (error) {
+                console.warn('⚠️ Could not delete existing database/index for clean rebuild:', error instanceof Error ? error.message : String(error));
+            }
+        }
         // Setup graceful cleanup
         setupCLICleanup(dbPath);
         // Check if database is busy before starting
@@ -218,6 +244,22 @@ export async function runIngest(path, options = {}) {
                 console.log(`Processing rate: ${chunksPerSecond} chunks/second`);
             }
             console.log('\nIngestion completed successfully!');
+            // Run VACUUM to compact the SQLite database after ingestion
+            try {
+                const { openDatabase } = await import('../core/db.js');
+                const vacuumDb = await openDatabase(dbPath);
+                try {
+                    console.log('Running VACUUM to optimize database size...');
+                    await vacuumDb.run('VACUUM');
+                    console.log('VACUUM completed successfully.');
+                }
+                finally {
+                    await vacuumDb.close();
+                }
+            }
+            catch (vacuumError) {
+                console.warn('⚠️  VACUUM operation failed or was skipped:', vacuumError instanceof Error ? vacuumError.message : String(vacuumError));
+            }
             // Display mode-specific information
             const mode = options.mode || 'text';
             if (mode === 'multimodal') {
@@ -397,6 +439,22 @@ export async function runRebuild() {
                 console.log('All embeddings have been regenerated with the current model.');
                 console.log('');
                 console.log('You can now search your documents using: raglite search "your query"');
+                // Run VACUUM to compact the SQLite database after rebuild
+                try {
+                    const { openDatabase } = await import('../core/db.js');
+                    const vacuumDb = await openDatabase(dbPath);
+                    try {
+                        console.log('Running VACUUM to optimize database size after rebuild...');
+                        await vacuumDb.run('VACUUM');
+                        console.log('VACUUM completed successfully.');
+                    }
+                    finally {
+                        await vacuumDb.close();
+                    }
+                }
+                catch (vacuumError) {
+                    console.warn('⚠️  VACUUM operation failed or was skipped:', vacuumError instanceof Error ? vacuumError.message : String(vacuumError));
+                }
             }
             finally {
                 await db.close();

package/dist/esm/cli/ui-server.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Launch the UI server
+ */
+export declare function runUI(options?: any): Promise<void>;
+//# sourceMappingURL=ui-server.d.ts.map

package/dist/esm/cli/ui-server.js

@@ -0,0 +1,152 @@
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { spawn } from 'child_process';
+import fs from 'fs';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Get the project root directory
+ * When built, CLI is at dist/esm/cli/ui-server.js, so go up 3 levels
+ * When running from source, CLI is at src/cli/ui-server.ts, so go up 2 levels
+ */
+function getProjectRoot() {
+    // Try going up 3 levels first (for built version)
+    const builtPath = join(__dirname, '../../..');
+    if (fs.existsSync(join(builtPath, 'package.json'))) {
+        return builtPath;
+    }
+    // Fallback: go up 2 levels (for source execution)
+    return join(__dirname, '../..');
+}
+/**
+ * Launch the UI server
+ */
+export async function runUI(options = {}) {
+    const port = options.port || 3000;
+    const backendPort = options.backendPort || 3001;
+    console.log('🚀 Launching RAG-lite TS UI...');
+    // Resolve UI paths from project root
+    const projectRoot = getProjectRoot();
+    const backendBuiltPath = join(projectRoot, 'ui', 'backend', 'dist', 'index.js');
+    const backendSourcePath = join(projectRoot, 'ui', 'backend', 'src', 'index.ts');
+    const frontendBuiltPath = join(projectRoot, 'ui', 'frontend', 'dist');
+    const frontendSourcePath = join(projectRoot, 'ui', 'frontend');
+    // Check if built files exist
+    const useBuiltBackend = fs.existsSync(backendBuiltPath);
+    const useBuiltFrontend = fs.existsSync(frontendBuiltPath);
+    if (!useBuiltBackend && !fs.existsSync(backendSourcePath)) {
+        console.error(`❌ UI backend not found at: ${backendSourcePath}`);
+        console.error('   Make sure the UI is set up in the ui/ directory.');
+        process.exit(1);
+    }
+    if (!useBuiltFrontend && !fs.existsSync(frontendSourcePath)) {
+        console.error(`❌ UI frontend not found at: ${frontendSourcePath}`);
+        console.error('   Make sure the UI is set up in the ui/ directory.');
+        process.exit(1);
+    }
+    // Pass the working directory where 'raglite ui' was called to the backend
+    const workingDir = process.cwd();
+    // Built mode: single server on port (UI + API). Dev mode: backend on backendPort, frontend on port.
+    const effectiveBackendPort = useBuiltFrontend ? port : backendPort;
+    console.log(`📡 Starting backend on port ${effectiveBackendPort}...`);
+    // Start backend server - use built version if available
+    const backendCommand = useBuiltBackend ? 'node' : 'npx';
+    const backendArgs = useBuiltBackend
+        ? [backendBuiltPath]
+        : ['tsx', backendSourcePath];
+    const backendProcess = spawn(backendCommand, backendArgs, {
+        stdio: 'pipe',
+        env: {
+            ...process.env,
+            PORT: effectiveBackendPort.toString(),
+            RAG_WORKING_DIR: workingDir,
+            UI_FRONTEND_DIST: useBuiltFrontend ? frontendBuiltPath : undefined
+        },
+        shell: true
+    });
+    backendProcess.on('error', (err) => {
+        console.error('❌ Failed to start backend process:', err);
+        process.exit(1);
+    });
+    // Forward backend output with prefix
+    backendProcess.stdout?.on('data', (data) => {
+        process.stdout.write(`[Backend] ${data}`);
+    });
+    backendProcess.stderr?.on('data', (data) => {
+        process.stderr.write(`[Backend] ${data}`);
+    });
+    // Only start frontend dev server if built version doesn't exist
+    let frontendProcess = null;
+    if (!useBuiltFrontend) {
+        console.log(`🎨 Starting frontend dev server on port ${port}...`);
+        frontendProcess = spawn('npm', ['run', 'dev'], {
+            cwd: frontendSourcePath,
+            stdio: 'pipe',
+            env: {
+                ...process.env,
+                VITE_API_URL: `http://localhost:${effectiveBackendPort}`
+            },
+            shell: true
+        });
+        frontendProcess.on('error', (err) => {
+            console.error('❌ Failed to start frontend process:', err);
+            backendProcess.kill();
+            process.exit(1);
+        });
+        // Forward frontend output with prefix
+        frontendProcess.stdout?.on('data', (data) => {
+            process.stdout.write(`[Frontend] ${data}`);
+        });
+        frontendProcess.stderr?.on('data', (data) => {
+            process.stderr.write(`[Frontend] ${data}`);
+        });
+    }
+    else {
+        console.log(`🎨 Using built frontend from ${frontendBuiltPath}`);
+        console.log(`   Frontend will be served by backend on port ${effectiveBackendPort}`);
+    }
+    // Wait a bit for servers to start
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    console.log(`\n✨ UI Access:`);
+    if (useBuiltFrontend) {
+        console.log(`   Frontend & Backend: http://localhost:${port}`);
+    }
+    else {
+        console.log(`   Frontend: http://localhost:${port}`);
+        console.log(`   Backend:  http://localhost:${effectiveBackendPort}`);
+    }
+    console.log(`\n💡 Press Ctrl+C to stop both servers\n`);
+    // Keep the process alive and handle cleanup
+    return new Promise((resolve) => {
+        const cleanup = () => {
+            console.log('\n🛑 Shutting down servers...');
+            backendProcess.kill();
+            if (frontendProcess) {
+                frontendProcess.kill();
+            }
+            resolve();
+        };
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+        // Handle process exits
+        backendProcess.on('exit', (code) => {
+            if (code !== 0 && code !== null) {
+                console.error(`\n❌ Backend process exited with code ${code}`);
+                if (frontendProcess) {
+                    frontendProcess.kill();
+                }
+                resolve();
+            }
+        });
+        if (frontendProcess) {
+            frontendProcess.on('exit', (code) => {
+                if (code !== 0 && code !== null) {
+                    console.error(`\n❌ Frontend process exited with code ${code}`);
+                    backendProcess.kill();
+                    resolve();
+                }
+            });
+        }
+    });
+}
+//# sourceMappingURL=ui-server.js.map

package/dist/esm/cli.js

@@ -6,8 +6,18 @@ import { EXIT_CODES, ConfigurationError } from './core/config.js';
 // Get package.json for version info
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const packageJsonPath = join(__dirname, '..', 'package.json');
-const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+// When built, CLI is at dist/esm/cli.js, so go up two levels to root
+// When running from source, CLI is at src/cli.ts, so go up one level to root
+const packageJsonPath = join(__dirname, '..', '..', 'package.json');
+let packageJson;
+try {
+    packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+}
+catch {
+    // Fallback: try one level up (for source execution)
+    const fallbackPath = join(__dirname, '..', 'package.json');
+    packageJson = JSON.parse(readFileSync(fallbackPath, 'utf-8'));
+}
 /**
  * Display version information
  */
@@ -28,6 +38,7 @@ Usage:
 Commands:
   ingest <path>     Ingest documents from file or directory
   search <query>    Search indexed documents (text or image)
+  ui                Launch the web interface
   rebuild           Rebuild the vector index
   version           Show version information
   help              Show this help message
@@ -43,6 +54,7 @@ Examples:
   raglite search "red car" --content-type image  # Search only image results
   raglite search ./photo.jpg       # Search with image (multimodal mode only)
   raglite search ./image.png --top-k 5  # Find similar images
+  raglite ui                       # Launch web interface
 
   raglite rebuild                  # Rebuild the entire index
 
@@ -55,7 +67,7 @@ Options for search:
 Options for ingest:
   --model <name>       Use specific embedding model
   --mode <mode>        Processing mode: 'text' (default) or 'multimodal'
-  --rebuild-if-needed  Automatically rebuild if model mismatch detected (WARNING: rebuilds entire index)
+  --force-rebuild      Wipe DB+index and rebuild from scratch (DESTRUCTIVE)
   --path-strategy <strategy>  Path storage strategy: 'relative' (default) or 'absolute'
   --path-base <path>   Base directory for relative paths (defaults to current directory)
 
@@ -111,8 +123,8 @@ function parseArgs() {
             else if (optionName === 'no-rerank') {
                 options.rerank = false;
             }
-            else if (optionName === 'rebuild-if-needed') {
-                options.rebuildIfNeeded = true;
+            else if (optionName === 'force-rebuild') {
+                options.forceRebuild = true;
             }
             else if (optionName === 'help') {
                 return { command: 'help', args: [], options: {} };
@@ -169,7 +181,7 @@ function validateArgs(command, args, options) {
                 console.error('Options:');
                 console.error('  --model <name>         Use specific embedding model');
                 console.error('  --mode <mode>          Processing mode: text (default) or multimodal');
-                console.error('  --rebuild-if-needed    Automatically rebuild if model mismatch detected');
+                console.error('  --force-rebuild        Wipe DB+index and rebuild from scratch (DESTRUCTIVE)');
                 console.error('');
                 console.error('The path can be either a file (.md or .txt) or a directory.');
                 process.exit(EXIT_CODES.INVALID_ARGUMENTS);
@@ -201,6 +213,9 @@ function validateArgs(command, args, options) {
         case 'rebuild':
             // No arguments required
             break;
+        case 'ui':
+            // No arguments required
+            break;
         case 'version':
             // No validation needed
             break;
@@ -412,6 +427,10 @@ async function main() {
                 const { runRebuild } = await import('./cli/indexer.js');
                 await runRebuild();
                 break;
+            case 'ui':
+                const { runUI } = await import('./cli/ui-server.js');
+                await runUI(options);
+                break;
             default:
                 console.error(`Error: Unknown command '${command}'`);
                 process.exit(1);

package/dist/esm/core/binary-index-format.js

@@ -27,10 +27,12 @@ export class BinaryIndexFormat {
      * @param data Index data to serialize
      */
     static async save(indexPath, data) {
-        // Calculate total size
+        // Use actual vector count to ensure accurate file size
+        const actualVectorCount = data.vectors.length;
+        // Calculate total size based on actual vectors
         const headerSize = 24; // 6 uint32 fields
         const vectorSize = 4 + (data.dimensions * 4); // id + vector
-        const totalSize = headerSize + (data.currentSize * vectorSize);
+        const totalSize = headerSize + (actualVectorCount * vectorSize);
         const buffer = new ArrayBuffer(totalSize);
         const view = new DataView(buffer);
         let offset = 0;
@@ -45,7 +47,8 @@ export class BinaryIndexFormat {
         offset += 4;
         view.setUint32(offset, data.seed, true);
         offset += 4;
-        view.setUint32(offset, data.currentSize, true);
+        // Write actual vector count in header
+        view.setUint32(offset, actualVectorCount, true);
         offset += 4;
         // Write vectors
         for (const item of data.vectors) {

package/dist/esm/core/db.d.ts

@@ -210,4 +210,60 @@ export declare function updateStorageStats(connection: DatabaseConnection, stats
     filesystemRefs?: number;
     lastCleanup?: Date;
 }): Promise<void>;
+/**
+ * Result of a database reset operation
+ */
+export interface DatabaseResetResult {
+    /** Whether the reset was successful */
+    success: boolean;
+    /** Number of documents deleted */
+    documentsDeleted: number;
+    /** Number of chunks deleted */
+    chunksDeleted: number;
+    /** Number of content metadata entries deleted */
+    contentMetadataDeleted: number;
+    /** Whether system_info was preserved or cleared */
+    systemInfoCleared: boolean;
+    /** Time taken for the reset operation in milliseconds */
+    resetTimeMs: number;
+}
+/**
+ * Options for database reset operation
+ */
+export interface DatabaseResetOptions {
+    /** Whether to preserve system_info (mode, model configuration) - default: false */
+    preserveSystemInfo?: boolean;
+    /** Whether to run VACUUM after deletion to reclaim space - default: true */
+    runVacuum?: boolean;
+}
+/**
+ * Reset the database by deleting all data while keeping the schema intact.
+ * This is a safer alternative to file deletion that avoids file locking issues on Windows.
+ *
+ * This function:
+ * 1. Deletes all rows from chunks, documents, content_metadata tables
+ * 2. Optionally clears system_info (mode/model configuration)
+ * 3. Resets storage_stats counters
+ * 4. Optionally runs VACUUM to reclaim disk space
+ *
+ * @param connection - Database connection object
+ * @param options - Reset options
+ * @returns Promise resolving to reset result statistics
+ *
+ * @example
+ * ```typescript
+ * const db = await openDatabase('./db.sqlite');
+ * const result = await resetDatabase(db, { preserveSystemInfo: false });
+ * console.log(`Deleted ${result.documentsDeleted} documents and ${result.chunksDeleted} chunks`);
+ * ```
+ */
+export declare function resetDatabase(connection: DatabaseConnection, options?: DatabaseResetOptions): Promise<DatabaseResetResult>;
+/**
+ * Check if the database has any data (documents, chunks, or content)
+ * Useful for determining if a reset is needed
+ *
+ * @param connection - Database connection object
+ * @returns Promise resolving to true if database has data, false if empty
+ */
+export declare function hasDatabaseData(connection: DatabaseConnection): Promise<boolean>;
 //# sourceMappingURL=db.d.ts.map