rag-lite-ts 2.1.1 → 2.3.0

package/README.md

@@ -11,7 +11,7 @@
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg?style=flat-square)](https://www.typescriptlang.org/)
 [![Node.js](https://img.shields.io/badge/Node.js-18+-green.svg?style=flat-square)](https://nodejs.org/)
 
-[Quick Start](#quick-start) • [Features](#features) • [Documentation](#documentation) • [Examples](#examples) • [MCP Integration](#mcp-server-integration)
+[Quick Start](#quick-start) • [Features](#features) • [Documentation](#documentation) • [Examples](#examples) • [UI](#web-interface-ui) • [MCP Integration](#mcp-server-integration)
 
 </div>
 
@@ -27,7 +27,7 @@ raglite ingest ./docs/
 raglite search "your query here"
 ```
 
-**That's it.** No API keys, no cloud services, no configuration hell.
+**That's it.** No API keys, no cloud services, no configuration hell. Prefer a UI? Run `raglite ui` for a visual interface with drag‑and‑drop ingestion and search.
 
 ### 🎬 See It In Action
 
@@ -101,6 +101,7 @@ See [CHANGELOG.md](CHANGELOG.md) for complete details.
 - [How It Works](#-how-it-works)
 - [Supported Models](#-supported-models)
 - [Documentation](#-documentation)
+- [Web Interface (UI)](#-web-interface-ui)
 - [MCP Server Integration](#-mcp-server-integration)
 - [Development](#-development)
 - [Contributing](#-contributing)
@@ -114,7 +115,7 @@ See [CHANGELOG.md](CHANGELOG.md) for complete details.
 npm install -g rag-lite-ts
 ```
 
-### Basic Usage
+### Basic Usage (CLI)
 
 ```bash
 # Ingest documents
@@ -127,11 +128,32 @@ raglite search "machine learning concepts"
 raglite search "API documentation" --top-k 10 --rerank
 ```
 
+### Web Interface (UI)
+
+Launch the visual web interface for interactive document management:
+
+```bash
+# Start the UI (opens in browser)
+raglite ui
+
+# UI provides:
+# - Drag & drop file upload
+# - Real-time ingestion progress
+# - Visual search interface
+# - Image search with upload
+# - Knowledge base statistics
+```
+
+→ **[Complete UI Guide](docs/ui-guide.md)**
+
 ### Using Different Models
 
 ```bash
-# Use higher quality model (auto-rebuilds if needed)
-raglite ingest ./docs/ --model Xenova/all-mpnet-base-v2 --rebuild-if-needed
+# Use higher quality model
+raglite ingest ./docs/ --model Xenova/all-mpnet-base-v2
+
+# Switch models or refresh your data (DESTRUCTIVE: wipes DB+index and rebuilds from scratch)
+raglite ingest ./docs/ --model Xenova/all-mpnet-base-v2 --force-rebuild
 
 # Search automatically uses the correct model
 raglite search "complex query"
@@ -441,6 +463,27 @@ Now Claude can search your docs directly! Works with any MCP-compatible AI tool.
 - **Model compatibility** - Auto-detection, rebuilds
 - **Error recovery** - Clear messages, helpful hints
 
+</td>
+</tr>
+<tr>
+<td width="50%">
+
+### 🎨 Web Interface (UI)
+- **Visual ingestion** - Drag & drop file upload
+- **Real-time progress** - Live ingestion tracking
+- **Image search** - Upload images to find similar content
+- **Interactive search** - Visual results with previews
+- **Knowledge base stats** - Overview of your data
+
+</td>
+<td width="50%">
+
+### 📚 Documentation
+- **Comprehensive guides** - CLI, API, multimodal tutorials
+- **Quick start guides** - Get running in minutes
+- **Troubleshooting** - Solutions for common issues
+- **Examples** - Real-world use cases
+
 </td>
 </tr>
 </table>
@@ -579,6 +622,7 @@ Choose the right model for your use case:
 
 ### 🚀 Getting Started
 - [CLI Reference](docs/cli-reference.md)
+- [UI Guide](docs/ui-guide.md) 🆕
 - [API Reference](docs/api-reference.md)
 - [Multimodal Tutorial](docs/multimodal-tutorial.md)
 - [Unified Content System](docs/unified-content-system.md)
@@ -610,6 +654,7 @@ Choose the right model for your use case:
 | I want to... | Start here |
 |--------------|------------|
 | 🆕 Try it out | [CLI Reference](docs/cli-reference.md) → `npm i -g rag-lite-ts` |
+| 🎨 Use visual interface | [UI Guide](docs/ui-guide.md) → `raglite ui` |
 | 🖼️ Search images | [Multimodal Tutorial](docs/multimodal-tutorial.md) → `--mode multimodal` |
 | 💻 Build an app | [API Reference](docs/api-reference.md) → `new SearchEngine()` |
 | 🤖 Integrate with AI | [MCP Guide](docs/mcp-server-multimodal-guide.md) → `raglite-mcp` |
@@ -618,6 +663,44 @@ Choose the right model for your use case:
 
 **📖 [Complete Documentation Hub](docs/README.md)**
 
+## 🎨 Web Interface (UI)
+
+RAG-lite TS includes a modern web-based interface for visual document management and search.
+
+### Quick Start
+
+```bash
+# Launch the UI (starts both frontend and backend)
+raglite ui
+
+# Opens in browser at http://localhost:3000
+```
+
+### Features
+
+- **📤 Visual Ingestion**: Drag & drop file upload with real-time progress
+- **🔍 Interactive Search**: Text and image search with visual results
+- **📊 Knowledge Base Stats**: Overview of documents, chunks, and model information
+- **⚙️ Configuration**: Visual interface for all ingestion options
+- **🖼️ Image Search**: Upload images to find similar content
+- **📁 Folder Support**: Upload entire directory structures
+
+### UI vs CLI
+
+| Feature | UI | CLI |
+|---------|----|----|
+| File upload | ✅ Drag & drop | ✅ Command-line |
+| Progress tracking | ✅ Visual bars | ✅ Console output |
+| Image search | ✅ Upload interface | ✅ File path |
+| Configuration | ✅ Visual options | ✅ Command flags |
+| Batch processing | ✅ | ✅ |
+| Scripting | ❌ | ✅ |
+
+**Use UI for:** Interactive exploration, visual feedback, learning the system  
+**Use CLI for:** Automation, scripting, headless environments
+
+→ **[Complete UI Guide](docs/ui-guide.md)**
+
 ## 🔌 MCP Server Integration
 
 **Give your AI agents semantic memory.** RAG-lite TS includes a built-in Model Context Protocol (MCP) server.

package/dist/{cli → cjs/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/cjs/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/cjs/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/{cli.js → cjs/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/{core → cjs/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/{core → cjs/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