rag-lite-ts 1.0.1 → 2.0.0

package/dist/cli.js

@@ -2,7 +2,7 @@
 import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
-import { EXIT_CODES, ConfigurationError } from './config.js';
+import { EXIT_CODES, ConfigurationError } from './core/config.js';
 // Get package.json for version info
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -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);
         }
     }
@@ -215,7 +350,7 @@ function validateArgs(command, args, options) {
             console.error('');
             console.error('Supported strategies:');
             console.error('  relative   Store paths relative to base directory (default, portable)');
-            console.error('  absolute   Store absolute paths (legacy mode)');
+            console.error('  absolute   Store absolute paths');
             console.error('');
             console.error('Examples:');
             console.error('  --path-strategy relative');
@@ -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

package/dist/config.d.ts

@@ -1,90 +1,51 @@
-import { PreprocessingConfig } from './types.js';
-export interface Config {
-    embedding_model: string;
-    chunk_size: number;
-    chunk_overlap: number;
-    batch_size: number;
-    top_k: number;
-    db_file: string;
-    index_file: string;
-    rerank_enabled: boolean;
-    preprocessing: PreprocessingConfig;
-    model_cache_path?: string;
-    path_storage_strategy: 'absolute' | 'relative';
-}
-export interface ModelDefaults {
-    dimensions: number;
-    chunk_size: number;
-    chunk_overlap: number;
-    batch_size: number;
-}
 /**
- * Default preprocessing configuration - "balanced" mode
+ * Main configuration file with text-specific settings
+ * Extends core configuration with implementation-specific properties
  */
-export declare const defaultPreprocessingConfig: PreprocessingConfig;
+import { CoreConfig } from './core/config.js';
 /**
- * Returns model-specific default configuration values
- * @param modelName - The embedding model name
- * @returns Model-specific defaults for dimensions, chunk_size, chunk_overlap, and batch_size
+ * Text-specific configuration properties
  */
-export declare function getModelDefaults(modelName: string): ModelDefaults;
-export declare const config: Config;
-/**
- * Standard exit codes for different error conditions
- */
-export declare const EXIT_CODES: {
-    readonly SUCCESS: 0;
-    readonly GENERAL_ERROR: 1;
-    readonly INVALID_ARGUMENTS: 2;
-    readonly CONFIGURATION_ERROR: 3;
-    readonly FILE_NOT_FOUND: 4;
-    readonly DATABASE_ERROR: 5;
-    readonly MODEL_ERROR: 6;
-    readonly INDEX_ERROR: 7;
-    readonly PERMISSION_ERROR: 8;
-};
-/**
- * Configuration validation error with specific exit code
- */
-export declare class ConfigurationError extends Error {
-    exitCode: number;
-    constructor(message: string, exitCode?: number);
+export interface TextConfig {
+    embedding_model: string;
+    rerank_enabled: boolean;
+    rerank_model: string;
+    preprocessing: {
+        enabled: boolean;
+        mdx: boolean;
+        mermaid: boolean;
+        code_blocks: boolean;
+    };
 }
 /**
- * Validates preprocessing configuration
- * @param config - Preprocessing configuration to validate
- * @throws {ConfigurationError} If preprocessing configuration is invalid
+ * Complete configuration interface combining core and text-specific settings
  */
-export declare function validatePreprocessingConfig(config: any): asserts config is PreprocessingConfig;
+export interface Config extends CoreConfig {
+    embedding_model: string;
+    rerank_enabled: boolean;
+    rerank_model: string;
+    preprocessing: {
+        enabled: boolean;
+        mdx: boolean;
+        mermaid: boolean;
+        code_blocks: boolean;
+    };
+}
 /**
- * Merges preprocessing mode with overrides to create final configuration
- * @param config - Base preprocessing configuration
- * @returns Resolved preprocessing options for each content type
+ * Default configuration object with both core and text-specific settings
  */
-export declare function mergePreprocessingConfig(config: PreprocessingConfig): {
-    mdx: 'strip' | 'keep' | 'placeholder';
-    mermaid: 'strip' | 'extract' | 'placeholder';
-    code: 'strip' | 'keep' | 'placeholder';
-};
+export declare const config: Config;
+export * from './core/config.js';
 /**
- * Validates the configuration object
- * @param config - Configuration object to validate
- * @throws {ConfigurationError} If configuration is invalid
+ * Validate complete configuration including text-specific settings
  */
 export declare function validateConfig(config: any): asserts config is Config;
 /**
- * Utility function to handle unrecoverable errors with descriptive messages
- * Logs error and exits immediately with appropriate exit code
- * @param error - Error object or message
- * @param context - Context where the error occurred
- * @param exitCode - Exit code to use (defaults to GENERAL_ERROR)
+ * Validate preprocessing configuration
  */
-export declare function handleUnrecoverableError(error: Error | string, context: string, exitCode?: number): never;
+export declare function validatePreprocessingConfig(config: any): boolean;
 /**
- * Utility function for safe error logging with context
- * @param error - Error to log
- * @param context - Context where error occurred
- * @param skipError - Whether to skip this error and continue (default: false)
+ * Merge preprocessing configurations
  */
-export declare function logError(error: Error | string, context: string, skipError?: boolean): void;
+export declare function mergePreprocessingConfig(base: any, override: any): any;
 //# sourceMappingURL=config.d.ts.map