rag-lite-ts 1.0.1 → 2.0.0

package/dist/multimodal/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Multimodal implementation layer exports
+ * Provides CLIP-based embedders for cross-modal search capabilities
+ */
+export { CLIPEmbedder } from './clip-embedder.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/multimodal/index.js

@@ -0,0 +1,6 @@
+/**
+ * Multimodal implementation layer exports
+ * Provides CLIP-based embedders for cross-modal search capabilities
+ */
+export { CLIPEmbedder } from './clip-embedder.js';
+//# sourceMappingURL=index.js.map

package/dist/preprocess.js

@@ -1,4 +1,4 @@
-import { mergePreprocessingConfig, validatePreprocessingConfig } from './config.js';
+import { mergePreprocessingConfig, validatePreprocessingConfig } from './core/config.js';
 import { preprocessorRegistry, ContentTypeDetector } from './preprocessors/index.js';
 /**
  * Main preprocessing function that processes document content based on configuration

package/dist/run-error-recovery-tests.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Test Runner for Chameleon Error Recovery and Reliability Tests
+ * Runs the comprehensive error recovery test suite
+ */
+declare function runTests(): Promise<boolean>;
+export { runTests };
+//# sourceMappingURL=run-error-recovery-tests.d.ts.map

package/dist/run-error-recovery-tests.js

@@ -0,0 +1,101 @@
+/**
+ * Test Runner for Chameleon Error Recovery and Reliability Tests
+ * Runs the comprehensive error recovery test suite
+ */
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+async function runTests() {
+    console.log('🧪 Running Chameleon Error Recovery and Reliability Tests...\n');
+    const testFiles = [
+        'chameleon-error-recovery.test.ts',
+        'chameleon-reliability-integration.test.ts',
+        'chameleon-stress-testing.test.ts',
+        'chameleon-error-simulation.test.ts'
+    ];
+    let totalTests = 0;
+    let passedTests = 0;
+    let failedTests = 0;
+    for (const testFile of testFiles) {
+        console.log(`\n📋 Running ${testFile}...`);
+        try {
+            // Build the test file first
+            const buildProcess = spawn('npx', ['tsc', '--project', 'tsconfig.test.json'], {
+                stdio: 'pipe',
+                shell: true
+            });
+            await new Promise((resolve, reject) => {
+                buildProcess.on('close', (code) => {
+                    if (code === 0) {
+                        resolve(code);
+                    }
+                    else {
+                        reject(new Error(`Build failed with code ${code}`));
+                    }
+                });
+            });
+            // Run the compiled test
+            const testProcess = spawn('node', ['--test', `dist/${testFile.replace('.ts', '.js')}`], {
+                stdio: 'pipe',
+                shell: true
+            });
+            let output = '';
+            let errorOutput = '';
+            testProcess.stdout?.on('data', (data) => {
+                output += data.toString();
+            });
+            testProcess.stderr?.on('data', (data) => {
+                errorOutput += data.toString();
+            });
+            await new Promise((resolve) => {
+                testProcess.on('close', (code) => {
+                    console.log(`Exit code: ${code}`);
+                    if (output) {
+                        console.log('Output:', output);
+                    }
+                    if (errorOutput) {
+                        console.log('Errors:', errorOutput);
+                    }
+                    // Count tests (this is a simple approximation)
+                    const testMatches = output.match(/✓|×/g);
+                    const currentTests = testMatches ? testMatches.length : 0;
+                    totalTests += currentTests;
+                    if (code === 0) {
+                        passedTests += currentTests;
+                        console.log(`✅ ${testFile} completed successfully`);
+                    }
+                    else {
+                        failedTests += currentTests;
+                        console.log(`❌ ${testFile} failed`);
+                    }
+                    resolve(code);
+                });
+            });
+        }
+        catch (error) {
+            console.error(`❌ Failed to run ${testFile}:`, error instanceof Error ? error.message : String(error));
+            failedTests++;
+        }
+    }
+    console.log('\n📊 Test Summary:');
+    console.log(`Total Tests: ${totalTests}`);
+    console.log(`Passed: ${passedTests}`);
+    console.log(`Failed: ${failedTests}`);
+    if (failedTests === 0) {
+        console.log('\n🎉 All error recovery tests completed!');
+        console.log('✅ System demonstrates robust error handling and recovery mechanisms');
+    }
+    else {
+        console.log('\n⚠️  Some tests failed - this may be expected in test environments');
+        console.log('🔍 Review the output above for specific failure details');
+    }
+    return failedTests === 0;
+}
+// Run tests if this file is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    runTests().catch(console.error);
+}
+export { runTests };
+//# sourceMappingURL=run-error-recovery-tests.js.map

package/dist/search-standalone.js

@@ -4,7 +4,7 @@
  * Usage: node search.js <query> [--top-k <number>] [--rerank|--no-rerank]
  */
 import { runSearch } from './cli/search.js';
-import { EXIT_CODES, ConfigurationError } from './config.js';
+import { EXIT_CODES, ConfigurationError } from './core/config.js';
 function parseArgs() {
     const args = process.argv.slice(2);
     if (args.length === 0) {

package/dist/search.d.ts

@@ -1,91 +1,73 @@
-import { EmbeddingEngine } from './embedder.js';
-import { IndexManager } from './index-manager.js';
-import { DatabaseConnection } from './db.js';
-import type { SearchResult, SearchOptions } from './types.js';
 /**
- * User-friendly error class with actionable suggestions
+ * Public API SearchEngine - Simple constructor interface with internal factory usage
+ *
+ * This class provides a clean, simple API while using the new core architecture
+ * internally. It handles dependency injection automatically.
+ *
+ * @example
+ * ```typescript
+ * // Simple usage
+ * const search = new SearchEngine('./index.bin', './db.sqlite');
+ * const results = await search.search('query');
+ *
+ * // With options
+ * const search = new SearchEngine('./index.bin', './db.sqlite', {
+ *   embeddingModel: 'all-MiniLM-L6-v2',
+ *   enableReranking: true
+ * });
+ * ```
  */
-export declare class SearchError extends Error {
-    code: string;
-    suggestions: string[];
-    constructor(message: string, code: string, suggestions: string[]);
+import { type TextSearchOptions } from './factories/index.js';
+import type { SearchResult, SearchOptions, EmbedFunction, RerankFunction } from './core/types.js';
+export interface SearchEngineOptions extends TextSearchOptions {
+    /** Custom embedding function (advanced usage) */
+    embedFn?: EmbedFunction;
+    /** Custom reranking function (advanced usage) */
+    rerankFn?: RerankFunction;
 }
-/**
- * Search engine that provides semantic search capabilities
- * Implements the core search pipeline: query embedding → vector search → metadata retrieval → optional reranking
- * Supports concurrent read operations for multiple simultaneous queries
- */
 export declare class SearchEngine {
-    private static instances;
-    private static cleanupHandlersSet;
-    private embedder;
-    private indexManager;
-    private dbConnection;
-    private reranker;
-    private isInitialized;
     private indexPath;
     private dbPath;
-    private enableReranking;
-    /**
-     * Creates a new SearchEngine with simplified constructor
-     * Search engine is ready to use immediately without requiring initialization calls (Requirement 3.5)
-     * @param indexPath - Path to vector index file (defaults to './vector-index.bin')
-     * @param dbPath - Path to database file (defaults to './db.sqlite')
-     */
-    constructor(indexPath?: string, dbPath?: string);
-    /**
-     * Legacy constructor for backward compatibility
-     * @deprecated Use the simple constructor new SearchEngine(indexPath?, dbPath?) instead
-     */
-    static createWithComponents(embedder: EmbeddingEngine, indexManager: IndexManager, dbConnection: DatabaseConnection, enableReranking?: boolean): SearchEngine;
-    /**
-     * Automatically initialize resources on first use with user-friendly error handling
-     * Implements lazy initialization as required by Requirements 3.5, 4.3, 5.1, 5.2
-     */
-    private ensureInitialized;
+    private options;
+    private coreEngine;
+    private initPromise;
+    constructor(indexPath: string, dbPath: string, options?: SearchEngineOptions);
     /**
-     * Create user-friendly error messages with actionable suggestions
-     * Implements requirement 5.3: Clear, actionable error messages with specific next steps
+     * Initialize the search engine using the factory or direct injection
      */
-    private createUserFriendlyError;
+    private initialize;
     /**
-     * Initialize the search engine (public method for backward compatibility)
-     * Sets up database, index manager, and embedding engine
+     * Perform semantic search
      */
-    initialize(): Promise<void>;
+    search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
     /**
-     * Perform semantic search on the indexed documents (matches README API)
-     * Automatically initializes resources on first use (Requirements 4.1, 4.2, 4.4, 4.5)
-     * Supports concurrent read operations for multiple simultaneous queries
-     * @param query - Search query string
-     * @param options - Search options including top_k and rerank settings
-     * @returns Promise resolving to array of search results
+     * Retrieve content by ID in the specified format
+     * @param contentId - Content ID to retrieve
+     * @param format - Format to return ('file' for CLI clients, 'base64' for MCP clients)
+     * @returns Promise that resolves to content in requested format
      */
-    search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+    getContent(contentId: string, format?: 'file' | 'base64'): Promise<string>;
     /**
-     * Format search results with proper structure
-     * @param chunks - Database chunks with metadata
-     * @param distances - Similarity distances from vector search
-     * @param embeddingIds - Embedding IDs in search result order
-     * @returns Formatted search results
+     * Retrieve multiple content items efficiently in batch
+     * @param contentIds - Array of content IDs to retrieve
+     * @param format - Format to return ('file' for CLI clients, 'base64' for MCP clients)
+     * @returns Promise that resolves to array of content in requested format
      */
-    private formatSearchResults;
+    getContentBatch(contentIds: string[], format?: 'file' | 'base64'): Promise<string[]>;
     /**
-     * Get search engine statistics
-     * @returns Object with current search engine stats
+     * Retrieve content metadata for result enhancement
+     * @param contentId - Content ID to get metadata for
+     * @returns Promise that resolves to content metadata
      */
-    getStats(): Promise<{
-        totalChunks: number;
-        indexSize: number;
-        rerankingEnabled: boolean;
-        isInitialized: boolean;
-    }>;
+    getContentMetadata(contentId: string): Promise<import('./core/content-resolver.js').ContentMetadata>;
     /**
-     * Set up automatic cleanup on process exit (Requirement 5.5)
+     * Verify that content exists and is accessible
+     * @param contentId - Content ID to verify
+     * @returns Promise that resolves to true if content exists, false otherwise
      */
-    private setupAutomaticCleanup;
+    verifyContentExists(contentId: string): Promise<boolean>;
     /**
-     * Clean up resources (Requirement 5.5)
+     * Clean up resources
      */
     cleanup(): Promise<void>;
 }