rag-lite-ts 1.0.2 → 2.0.0

package/dist/cli/indexer.js

@@ -1,7 +1,110 @@
 import { existsSync, statSync } from 'fs';
 import { resolve } from 'path';
 import { TextIngestionFactory } from '../factories/text-factory.js';
+import { withCLIDatabaseAccess, setupCLICleanup, isDatabaseBusy } from '../core/cli-database-utils.js';
 import { EXIT_CODES, ConfigurationError } from '../core/config.js';
+/**
+ * Validate mode-specific model and strategy combinations
+ * Ensures that the selected model is compatible with the chosen mode
+ * and that reranking strategies are valid for the mode
+ */
+async function validateModeConfiguration(options) {
+    const mode = options.mode || 'text';
+    const model = options.embeddingModel;
+    const rerankingStrategy = options.rerankingStrategy;
+    // Define supported models for each mode
+    const textModels = [
+        'sentence-transformers/all-MiniLM-L6-v2',
+        'Xenova/all-mpnet-base-v2'
+    ];
+    const multimodalModels = [
+        'Xenova/clip-vit-base-patch32'
+    ];
+    // Validate model compatibility with mode
+    if (model) {
+        if (mode === 'text' && !textModels.includes(model)) {
+            if (multimodalModels.includes(model)) {
+                throw new ConfigurationError(`Model '${model}' is a multimodal model but text mode was selected.\n` +
+                    `\n` +
+                    `To use this model, specify multimodal mode:\n` +
+                    `  raglite ingest <path> --mode multimodal --model ${model}\n` +
+                    `\n` +
+                    `Or choose a text model for text mode:\n` +
+                    `  ${textModels.map(m => `raglite ingest <path> --model ${m}`).join('\n  ')}\n`, EXIT_CODES.INVALID_ARGUMENTS);
+            }
+            else {
+                throw new ConfigurationError(`Model '${model}' is not supported for text mode.\n` +
+                    `\n` +
+                    `Supported models for text mode:\n` +
+                    `  ${textModels.join('\n  ')}\n` +
+                    `\n` +
+                    `Examples:\n` +
+                    `  raglite ingest <path> --model sentence-transformers/all-MiniLM-L6-v2\n` +
+                    `  raglite ingest <path> --model Xenova/all-mpnet-base-v2\n`, EXIT_CODES.INVALID_ARGUMENTS);
+            }
+        }
+        if (mode === 'multimodal' && !multimodalModels.includes(model)) {
+            if (textModels.includes(model)) {
+                throw new ConfigurationError(`Model '${model}' is a text-only model but multimodal mode was selected.\n` +
+                    `\n` +
+                    `To use this model, specify text mode:\n` +
+                    `  raglite ingest <path> --mode text --model ${model}\n` +
+                    `\n` +
+                    `Or choose a multimodal model for multimodal mode:\n` +
+                    `  ${multimodalModels.map(m => `raglite ingest <path> --mode multimodal --model ${m}`).join('\n  ')}\n`, EXIT_CODES.INVALID_ARGUMENTS);
+            }
+            else {
+                throw new ConfigurationError(`Model '${model}' is not supported for multimodal mode.\n` +
+                    `\n` +
+                    `Supported models for multimodal mode:\n` +
+                    `  ${multimodalModels.join('\n  ')}\n` +
+                    `\n` +
+                    `Example:\n` +
+                    `  raglite ingest <path> --mode multimodal --model Xenova/clip-vit-base-patch32\n`, EXIT_CODES.INVALID_ARGUMENTS);
+            }
+        }
+    }
+    // Validate reranking strategy compatibility with mode
+    if (rerankingStrategy) {
+        const textStrategies = ['cross-encoder', 'disabled'];
+        const multimodalStrategies = ['text-derived', 'metadata', 'disabled'];
+        if (mode === 'text' && !textStrategies.includes(rerankingStrategy)) {
+            throw new ConfigurationError(`Reranking strategy '${rerankingStrategy}' is not supported for text mode.\n` +
+                `\n` +
+                `Supported strategies for text mode:\n` +
+                `  cross-encoder  Use cross-encoder model for reranking (default)\n` +
+                `  disabled       No reranking, use vector similarity only\n` +
+                `\n` +
+                `Examples:\n` +
+                `  raglite ingest <path> --mode text --rerank-strategy cross-encoder\n` +
+                `  raglite ingest <path> --mode text --rerank-strategy disabled\n`, EXIT_CODES.INVALID_ARGUMENTS);
+        }
+        if (mode === 'multimodal' && !multimodalStrategies.includes(rerankingStrategy)) {
+            throw new ConfigurationError(`Reranking strategy '${rerankingStrategy}' is not supported for multimodal mode.\n` +
+                `\n` +
+                `Supported strategies for multimodal mode:\n` +
+                `  text-derived  Convert images to text, then use cross-encoder (default)\n` +
+                `  metadata      Use filename and metadata-based scoring\n` +
+                `  disabled      No reranking, use vector similarity only\n` +
+                `\n` +
+                `Examples:\n` +
+                `  raglite ingest <path> --mode multimodal --rerank-strategy text-derived\n` +
+                `  raglite ingest <path> --mode multimodal --rerank-strategy metadata\n` +
+                `  raglite ingest <path> --mode multimodal --rerank-strategy disabled\n`, EXIT_CODES.INVALID_ARGUMENTS);
+        }
+    }
+    // Log the final configuration
+    console.log('✅ Mode configuration validated successfully');
+    if (mode !== 'text') {
+        console.log(`   Mode: ${mode}`);
+    }
+    if (model) {
+        console.log(`   Model: ${model}`);
+    }
+    if (rerankingStrategy) {
+        console.log(`   Reranking: ${rerankingStrategy}`);
+    }
+}
 /**
  * Run document ingestion from CLI
  * @param path - File or directory path to ingest
@@ -9,6 +112,7 @@ import { EXIT_CODES, ConfigurationError } from '../core/config.js';
  */
 export async function runIngest(path, options = {}) {
     try {
+        // Handle --rebuild-if-needed flag immediately to prevent dimension mismatch error
         // Validate path exists
         const resolvedPath = resolve(path);
         if (!existsSync(resolvedPath)) {
@@ -64,15 +168,53 @@ export async function runIngest(path, options = {}) {
             factoryOptions.embeddingModel = options.model;
             console.log(`Using embedding model: ${options.model}`);
         }
+        if (options.mode) {
+            factoryOptions.mode = options.mode;
+            console.log(`Using processing mode: ${options.mode}`);
+        }
+        if (options['rerank-strategy']) {
+            factoryOptions.rerankingStrategy = options['rerank-strategy'];
+            console.log(`Using reranking strategy: ${options['rerank-strategy']}`);
+        }
         if (options.rebuildIfNeeded) {
             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}`);
+                }
+            }
+        }
+        // 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';
+        // Setup graceful cleanup
+        setupCLICleanup(dbPath);
+        // Check if database is busy before starting
+        const busyStatus = await isDatabaseBusy(dbPath);
+        if (busyStatus.isBusy) {
+            console.log('⚠️  Database appears to be in use by another process');
+            console.log(`   Reason: ${busyStatus.reason}`);
+            console.log('   Attempting to proceed anyway...');
+            console.log('');
         }
         // Create ingestion pipeline using factory
         let pipeline;
         try {
-            // Create ingestion pipeline using TextIngestionFactory
-            pipeline = await TextIngestionFactory.create(process.env.RAG_DB_FILE || './db.sqlite', process.env.RAG_INDEX_FILE || './vector-index.bin', factoryOptions);
+            // Create ingestion pipeline using TextIngestionFactory with database protection
+            pipeline = await withCLIDatabaseAccess(dbPath, () => TextIngestionFactory.create(dbPath, indexPath, factoryOptions), {
+                commandName: 'Ingestion command',
+                showProgress: true,
+                maxWaitMs: 15000 // Longer timeout for ingestion
+            });
             const result = await pipeline.ingestPath(resolvedPath);
             // Display final results
             console.log('\n' + '='.repeat(50));
@@ -93,12 +235,26 @@ export async function runIngest(path, options = {}) {
                 console.log(`Processing rate: ${chunksPerSecond} chunks/second`);
             }
             console.log('\nIngestion completed successfully!');
+            // Display mode-specific information
+            const mode = options.mode || 'text';
+            if (mode === 'multimodal') {
+                console.log('✨ Multimodal mode enabled - you can now search across text and image content');
+            }
             console.log('You can now search your documents using: raglite search "your query"');
+            console.log('');
+            console.log('💡 The search command will automatically detect and use the ingestion mode.');
         }
         finally {
             if (pipeline) {
                 await pipeline.cleanup();
             }
+            // Ensure clean exit for CLI commands
+            const { DatabaseConnectionManager } = await import('../core/database-connection-manager.js');
+            await DatabaseConnectionManager.closeAllConnections();
+            // Force exit for CLI commands to prevent hanging
+            setTimeout(() => {
+                process.exit(0);
+            }, 100);
         }
     }
     catch (error) {
@@ -178,12 +334,37 @@ export async function runRebuild() {
         console.log('');
         console.log('Progress will be shown below...');
         console.log('');
+        // Detect mode from existing database for rebuild
+        const dbPath = process.env.RAG_DB_FILE || './db.sqlite';
+        const indexPath = process.env.RAG_INDEX_FILE || './vector-index.bin';
+        let rebuildOptions = { forceRebuild: true };
+        if (existsSync(dbPath)) {
+            try {
+                // Import mode detection service
+                const { ModeDetectionService } = await import('../core/mode-detection-service.js');
+                const modeService = new ModeDetectionService(dbPath);
+                const systemInfo = await modeService.detectMode();
+                console.log(`🎯 Detected existing configuration:`);
+                console.log(`   Mode: ${systemInfo.mode}`);
+                console.log(`   Model: ${systemInfo.modelName}`);
+                console.log(`   Reranking: ${systemInfo.rerankingStrategy}`);
+                console.log('');
+                // Use the detected configuration for rebuild
+                rebuildOptions.mode = systemInfo.mode;
+                rebuildOptions.embeddingModel = systemInfo.modelName;
+                rebuildOptions.rerankingStrategy = systemInfo.rerankingStrategy;
+            }
+            catch (error) {
+                console.warn('⚠️  Could not detect existing mode configuration, using defaults');
+                console.warn(`   Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }
         // Create ingestion pipeline with force rebuild using factory
-        const pipeline = await TextIngestionFactory.create(process.env.RAG_DB_FILE || './db.sqlite', process.env.RAG_INDEX_FILE || './vector-index.bin', { forceRebuild: true });
+        const pipeline = await TextIngestionFactory.create(dbPath, indexPath, rebuildOptions);
         try {
             // Get all documents from database and re-ingest them
             const { openDatabase } = await import('../core/db.js');
-            const db = await openDatabase(process.env.RAG_DB_FILE || './db.sqlite');
+            const db = await openDatabase(dbPath);
             try {
                 const documents = await db.all('SELECT DISTINCT source FROM documents ORDER BY source');
                 if (documents.length === 0) {
@@ -240,6 +421,13 @@ export async function runRebuild() {
         }
         finally {
             await pipeline.cleanup();
+            // Ensure clean exit for CLI commands
+            const { DatabaseConnectionManager } = await import('../core/database-connection-manager.js');
+            await DatabaseConnectionManager.closeAllConnections();
+            // Force exit for CLI commands to prevent hanging
+            setTimeout(() => {
+                process.exit(0);
+            }, 100);
         }
     }
     catch (error) {

package/dist/cli/search.js

@@ -1,5 +1,6 @@
 import { existsSync } from 'fs';
-import { TextSearchFactory } from '../factories/text-factory.js';
+import { PolymorphicSearchFactory } from '../core/polymorphic-search-factory.js';
+import { withCLIDatabaseAccess, setupCLICleanup } from '../core/cli-database-utils.js';
 import { config, EXIT_CODES, ConfigurationError } from '../core/config.js';
 /**
  * Run search from CLI
@@ -54,15 +55,16 @@ export async function runSearch(query, options = {}) {
         }
         console.log(`Searching for: "${query}"`);
         console.log('');
-        // Initialize search engine using factory
+        // Setup graceful cleanup
+        setupCLICleanup(effectiveConfig.db_file);
+        // Initialize search engine using polymorphic factory with database protection
         let searchEngine;
         try {
-            // Prepare factory options
-            const factoryOptions = {
-                enableReranking: options.rerank !== undefined ? options.rerank : effectiveConfig.rerank_enabled
-            };
-            // Create search engine using TextSearchFactory
-            searchEngine = await TextSearchFactory.create(effectiveConfig.index_file, effectiveConfig.db_file, factoryOptions);
+            // Create search engine using PolymorphicSearchFactory (auto-detects mode)
+            searchEngine = await withCLIDatabaseAccess(effectiveConfig.db_file, () => PolymorphicSearchFactory.create(effectiveConfig.index_file, effectiveConfig.db_file), {
+                commandName: 'Search command',
+                showProgress: true
+            });
             // Prepare search options
             const searchOptions = {};
             if (options['top-k'] !== undefined) {
@@ -73,8 +75,18 @@ export async function runSearch(query, options = {}) {
             }
             // Perform search
             const startTime = Date.now();
-            const results = await searchEngine.search(query, searchOptions);
+            let results = await searchEngine.search(query, searchOptions);
             const searchTime = Date.now() - startTime;
+            // Apply content type filter if specified
+            const contentTypeFilter = options['content-type'];
+            if (contentTypeFilter && contentTypeFilter !== 'all') {
+                const originalCount = results.length;
+                results = results.filter(r => r.contentType === contentTypeFilter);
+                if (results.length < originalCount) {
+                    console.log(`Filtered to ${results.length} ${contentTypeFilter} result${results.length === 1 ? '' : 's'} (from ${originalCount} total)`);
+                    console.log('');
+                }
+            }
             // Display results
             if (results.length === 0) {
                 console.log('No results found.');
@@ -86,10 +98,30 @@ export async function runSearch(query, options = {}) {
             else {
                 console.log(`Found ${results.length} result${results.length === 1 ? '' : 's'} in ${searchTime}ms:\n`);
                 results.forEach((result, index) => {
-                    console.log(`${index + 1}. ${result.document.title}`);
+                    // Add content type icon for visual distinction
+                    const contentTypeIcon = result.contentType === 'image' ? '🖼️ ' : '📄 ';
+                    const contentTypeLabel = result.contentType === 'image' ? '[IMAGE]' : '[TEXT]';
+                    console.log(`${index + 1}. ${contentTypeIcon}${result.document.title}`);
                     console.log(`   Source: ${result.document.source}`);
+                    console.log(`   Type: ${contentTypeLabel}`);
                     console.log(`   Score: ${(result.score * 100).toFixed(1)}%`);
-                    console.log(`   Text: ${truncateText(result.content, 200)}`);
+                    // Display content differently based on type
+                    if (result.contentType === 'image') {
+                        // For images, show metadata if available
+                        if (result.metadata?.description) {
+                            console.log(`   Description: ${truncateText(result.metadata.description, 200)}`);
+                        }
+                        if (result.metadata?.dimensions) {
+                            console.log(`   Dimensions: ${result.metadata.dimensions}`);
+                        }
+                        if (result.metadata?.format) {
+                            console.log(`   Format: ${result.metadata.format}`);
+                        }
+                    }
+                    else {
+                        // For text, show content preview
+                        console.log(`   Text: ${truncateText(result.content, 200)}`);
+                    }
                     console.log('');
                 });
                 // Show search statistics
@@ -107,6 +139,13 @@ export async function runSearch(query, options = {}) {
             if (searchEngine) {
                 await searchEngine.cleanup();
             }
+            // Ensure clean exit for CLI commands
+            const { DatabaseConnectionManager } = await import('../core/database-connection-manager.js');
+            await DatabaseConnectionManager.closeAllConnections();
+            // Force exit for CLI commands to prevent hanging
+            setTimeout(() => {
+                process.exit(0);
+            }, 100);
         }
     }
     catch (error) {

package/dist/cli.js

@@ -29,26 +29,40 @@ Examples:
   raglite ingest ./docs/           # Ingest all .md/.txt files in docs/
   raglite ingest ./readme.md       # Ingest single file
   raglite ingest ./docs/ --model Xenova/all-mpnet-base-v2  # Use higher quality model
+  raglite ingest ./docs/ --mode multimodal  # Enable multimodal processing
+  raglite ingest ./docs/ --mode multimodal --rerank-strategy metadata  # Use metadata reranking
   raglite ingest ./docs/ --path-strategy relative --path-base /project  # Use relative paths
   raglite search "machine learning" # Search for documents about machine learning
   raglite search "API documentation" --top-k 10  # Get top 10 results
+  raglite search "red car" --content-type image  # Search only image results
 
   raglite rebuild                  # Rebuild the entire index
 
 Options for search:
-  --top-k <number>    Number of results to return (default: 10)
-  --rerank           Enable reranking for better results
-  --no-rerank        Disable reranking
+  --top-k <number>       Number of results to return (default: 10)
+  --rerank              Enable reranking for better results
+  --no-rerank           Disable reranking
+  --content-type <type> Filter results by content type: 'text', 'image', or 'all' (default: all)
 
 Options for ingest:
   --model <name>       Use specific embedding model
+  --mode <mode>        Processing mode: 'text' (default) or 'multimodal'
+  --rerank-strategy <strategy>  Reranking strategy for multimodal mode
   --rebuild-if-needed  Automatically rebuild if model mismatch detected (WARNING: rebuilds entire index)
   --path-strategy <strategy>  Path storage strategy: 'relative' (default) or 'absolute'
   --path-base <path>   Base directory for relative paths (defaults to current directory)
 
 Available models:
-  sentence-transformers/all-MiniLM-L6-v2  (384 dim, fast, default)
-  Xenova/all-mpnet-base-v2               (768 dim, higher quality)
+  Text mode:
+    sentence-transformers/all-MiniLM-L6-v2  (384 dim, fast, default)
+    Xenova/all-mpnet-base-v2               (768 dim, higher quality)
+  Multimodal mode:
+    Xenova/clip-vit-base-patch32           (512 dim, text + image support)
+
+Available reranking strategies (multimodal mode):
+  text-derived  Use image-to-text conversion + cross-encoder (default)
+  metadata      Use filename and metadata-based scoring
+  disabled      No reranking, use vector similarity only
 
 For more information, visit: https://github.com/your-repo/rag-lite-ts
 `);
@@ -115,9 +129,13 @@ function validateArgs(command, args, options) {
                 console.error('  raglite ingest ./docs/           # Ingest all .md/.txt files in docs/');
                 console.error('  raglite ingest ./readme.md       # Ingest single file');
                 console.error('  raglite ingest ./docs/ --model Xenova/all-mpnet-base-v2  # Use higher quality model');
+                console.error('  raglite ingest ./docs/ --mode multimodal  # Enable multimodal processing');
+                console.error('  raglite ingest ./docs/ --mode multimodal --rerank-strategy metadata  # Use metadata reranking');
                 console.error('');
                 console.error('Options:');
                 console.error('  --model <name>         Use specific embedding model');
+                console.error('  --mode <mode>          Processing mode: text (default) or multimodal');
+                console.error('  --rerank-strategy <strategy>  Reranking strategy for multimodal mode');
                 console.error('  --rebuild-if-needed    Automatically rebuild if model mismatch detected');
                 console.error('');
                 console.error('The path can be either a file (.md or .txt) or a directory.');
@@ -134,11 +152,13 @@ function validateArgs(command, args, options) {
                 console.error('  raglite search "machine learning"');
                 console.error('  raglite search "API documentation" --top-k 10');
                 console.error('  raglite search "tutorial" --rerank');
+                console.error('  raglite search "red car" --content-type image');
                 console.error('');
                 console.error('Options:');
-                console.error('  --top-k <number>    Number of results to return (default: 10)');
-                console.error('  --rerank           Enable reranking for better results');
-                console.error('  --no-rerank        Disable reranking');
+                console.error('  --top-k <number>       Number of results to return (default: 10)');
+                console.error('  --rerank              Enable reranking for better results');
+                console.error('  --no-rerank           Disable reranking');
+                console.error('  --content-type <type> Filter by content type: text, image, or all (default: all)');
                 process.exit(EXIT_CODES.INVALID_ARGUMENTS);
             }
             break;
@@ -173,6 +193,96 @@ function validateArgs(command, args, options) {
         }
         options['top-k'] = topK;
     }
+    // Validate content-type option (only for search command)
+    if (options['content-type'] !== undefined) {
+        if (command !== 'search') {
+            console.error(`Error: --content-type option is only available for the 'search' command`);
+            console.error('');
+            console.error('Use this option to filter search results by content type.');
+            console.error('');
+            console.error('Examples:');
+            console.error('  raglite search "query" --content-type text   # Only text results');
+            console.error('  raglite search "query" --content-type image  # Only image results');
+            process.exit(EXIT_CODES.INVALID_ARGUMENTS);
+        }
+        const supportedTypes = ['text', 'image', 'all'];
+        if (!supportedTypes.includes(options['content-type'])) {
+            console.error(`Error: Unsupported content type '${options['content-type']}'`);
+            console.error('');
+            console.error('Supported content types:');
+            console.error('  text   Filter to show only text results');
+            console.error('  image  Filter to show only image results');
+            console.error('  all    Show all results (default)');
+            console.error('');
+            console.error('Examples:');
+            console.error('  --content-type text');
+            console.error('  --content-type image');
+            console.error('  --content-type all');
+            process.exit(EXIT_CODES.INVALID_ARGUMENTS);
+        }
+    }
+    // Validate mode option (only for ingest command)
+    if (options.mode !== undefined) {
+        if (command !== 'ingest') {
+            console.error(`Error: --mode option is only available for the 'ingest' command`);
+            console.error('');
+            console.error('The search command automatically detects the mode from the database.');
+            console.error('Mode is set once during ingestion and persists for all searches.');
+            console.error('');
+            console.error('Examples:');
+            console.error('  raglite ingest ./docs/ --mode multimodal');
+            console.error('  raglite search "your query"  # Uses mode from ingestion');
+            process.exit(EXIT_CODES.INVALID_ARGUMENTS);
+        }
+        const supportedModes = ['text', 'multimodal'];
+        if (!supportedModes.includes(options.mode)) {
+            console.error(`Error: Unsupported mode '${options.mode}'`);
+            console.error('');
+            console.error('Supported modes:');
+            console.error('  text        Process text documents only (default)');
+            console.error('  multimodal  Process text and image documents');
+            console.error('');
+            console.error('Examples:');
+            console.error('  --mode text');
+            console.error('  --mode multimodal');
+            process.exit(EXIT_CODES.INVALID_ARGUMENTS);
+        }
+    }
+    // Validate rerank-strategy option (only for ingest command with multimodal mode)
+    if (options['rerank-strategy'] !== undefined) {
+        if (command !== 'ingest') {
+            console.error(`Error: --rerank-strategy option is only available for the 'ingest' command`);
+            console.error('');
+            console.error('Reranking strategy is configured during ingestion and used automatically during search.');
+            process.exit(EXIT_CODES.INVALID_ARGUMENTS);
+        }
+        const mode = options.mode || 'text';
+        if (mode !== 'multimodal') {
+            console.error(`Error: --rerank-strategy option is only available in multimodal mode`);
+            console.error('');
+            console.error('To use reranking strategies, specify --mode multimodal');
+            console.error('');
+            console.error('Examples:');
+            console.error('  raglite ingest ./docs/ --mode multimodal --rerank-strategy text-derived');
+            console.error('  raglite ingest ./docs/ --mode multimodal --rerank-strategy metadata');
+            process.exit(EXIT_CODES.INVALID_ARGUMENTS);
+        }
+        const supportedStrategies = ['text-derived', 'metadata', 'disabled'];
+        if (!supportedStrategies.includes(options['rerank-strategy'])) {
+            console.error(`Error: Unsupported reranking strategy '${options['rerank-strategy']}'`);
+            console.error('');
+            console.error('Supported strategies for multimodal mode:');
+            console.error('  text-derived  Convert images to text, then use cross-encoder (default)');
+            console.error('  metadata      Use filename and metadata-based scoring');
+            console.error('  disabled      No reranking, use vector similarity only');
+            console.error('');
+            console.error('Examples:');
+            console.error('  --rerank-strategy text-derived');
+            console.error('  --rerank-strategy metadata');
+            console.error('  --rerank-strategy disabled');
+            process.exit(EXIT_CODES.INVALID_ARGUMENTS);
+        }
+    }
     // Validate model option (only for ingest command)
     if (options.model !== undefined) {
         if (command !== 'ingest') {
@@ -186,20 +296,45 @@ function validateArgs(command, args, options) {
             console.error('  raglite search "your query"  # Uses the model from ingestion');
             process.exit(EXIT_CODES.INVALID_ARGUMENTS);
         }
-        const supportedModels = [
+        const mode = options.mode || 'text';
+        const textModels = [
             'sentence-transformers/all-MiniLM-L6-v2',
             'Xenova/all-mpnet-base-v2'
         ];
+        const multimodalModels = [
+            'Xenova/clip-vit-base-patch32'
+        ];
+        let supportedModels;
+        let modelTypeDescription;
+        if (mode === 'multimodal') {
+            supportedModels = multimodalModels;
+            modelTypeDescription = 'multimodal models';
+        }
+        else {
+            supportedModels = textModels;
+            modelTypeDescription = 'text models';
+        }
         if (!supportedModels.includes(options.model)) {
-            console.error(`Error: Unsupported model '${options.model}'`);
+            console.error(`Error: Model '${options.model}' is not supported for ${mode} mode`);
             console.error('');
-            console.error('Supported models:');
-            console.error('  sentence-transformers/all-MiniLM-L6-v2  (384 dim, fast, default)');
-            console.error('  Xenova/all-mpnet-base-v2               (768 dim, higher quality)');
+            if (mode === 'text') {
+                console.error('Supported models for text mode:');
+                console.error('  sentence-transformers/all-MiniLM-L6-v2  (384 dim, fast, default)');
+                console.error('  Xenova/all-mpnet-base-v2               (768 dim, higher quality)');
+            }
+            else {
+                console.error('Supported models for multimodal mode:');
+                console.error('  Xenova/clip-vit-base-patch32           (512 dim, text + image support)');
+            }
             console.error('');
             console.error('Examples:');
-            console.error('  --model sentence-transformers/all-MiniLM-L6-v2');
-            console.error('  --model Xenova/all-mpnet-base-v2');
+            if (mode === 'text') {
+                console.error('  --model sentence-transformers/all-MiniLM-L6-v2');
+                console.error('  --model Xenova/all-mpnet-base-v2');
+            }
+            else {
+                console.error('  --model Xenova/clip-vit-base-patch32 --mode multimodal');
+            }
             process.exit(EXIT_CODES.INVALID_ARGUMENTS);
         }
     }
@@ -243,6 +378,8 @@ function validateArgs(command, args, options) {
  * Main CLI entry point
  */
 async function main() {
+    // Set CLI mode to prevent database connection manager from starting timers
+    process.env.RAG_CLI_MODE = 'true';
     try {
         const { command, args, options } = parseArgs();
         // Validate arguments
@@ -340,23 +477,43 @@ process.on('uncaughtException', (error) => {
     process.exit(EXIT_CODES.GENERAL_ERROR);
 });
 // Handle process termination signals gracefully
-process.on('SIGINT', () => {
+process.on('SIGINT', async () => {
     console.log('\n\nReceived SIGINT (Ctrl+C). Shutting down gracefully...');
     console.log('If you need to force quit, press Ctrl+C again.');
+    // Clean up database connections before exit
+    try {
+        const { DatabaseConnectionManager } = await import('./core/database-connection-manager.js');
+        await DatabaseConnectionManager.closeAllConnections();
+    }
+    catch (error) {
+        // Ignore cleanup errors during shutdown
+    }
     process.exit(EXIT_CODES.SUCCESS);
 });
-process.on('SIGTERM', () => {
+process.on('SIGTERM', async () => {
     console.log('\n\nReceived SIGTERM. Shutting down gracefully...');
-    process.exit(EXIT_CODES.SUCCESS);
-});
-// Run the CLI
-main().catch((error) => {
-    console.error('Fatal error:', error instanceof Error ? error.message : String(error));
-    if (error instanceof ConfigurationError) {
-        process.exit(error.exitCode);
+    // Clean up database connections before exit
+    try {
+        const { DatabaseConnectionManager } = await import('./core/database-connection-manager.js');
+        await DatabaseConnectionManager.closeAllConnections();
     }
-    else {
-        process.exit(EXIT_CODES.GENERAL_ERROR);
+    catch (error) {
+        // Ignore cleanup errors during shutdown
     }
+    process.exit(EXIT_CODES.SUCCESS);
 });
+// Run the CLI only if this file is executed directly
+// In ES modules, we need to check import.meta.url instead of require.main
+// Check if this file is being run directly
+if (process.argv[1] === __filename || process.argv[1].endsWith('cli.js')) {
+    main().catch((error) => {
+        console.error('Fatal error:', error instanceof Error ? error.message : String(error));
+        if (error instanceof ConfigurationError) {
+            process.exit(error.exitCode);
+        }
+        else {
+            process.exit(EXIT_CODES.GENERAL_ERROR);
+        }
+    });
+}
 //# sourceMappingURL=cli.js.map