rag-lite-ts 1.0.1 → 2.0.0

package/dist/search.js

@@ -1,453 +1,158 @@
-import { initializeEmbeddingEngine } from './embedder.js';
-import { IndexManager } from './index-manager.js';
-import { getChunksByEmbeddingIds, openDatabase, getStoredModelInfo } from './db.js';
-import { CrossEncoderReranker } from './reranker.js';
-import { config } from './config.js';
-import { join, resolve } from 'path';
-import { existsSync } from 'fs';
 /**
- * User-friendly error class with actionable suggestions
- */
-export class SearchError extends Error {
-    code;
-    suggestions;
-    constructor(message, code, suggestions) {
-        super(message);
-        this.code = code;
-        this.suggestions = suggestions;
-        this.name = 'SearchError';
-    }
-}
-/**
- * Resolves paths for the search engine based on provided paths or defaults
- * @param indexPath - Path to vector index file (optional)
- * @param dbPath - Path to database file (optional)
- * @returns Resolved paths for index and database files
- */
-function resolveSearchPaths(indexPath, dbPath) {
-    const currentDir = process.cwd();
-    return {
-        indexPath: indexPath ? resolve(indexPath) : join(currentDir, 'vector-index.bin'),
-        dbPath: dbPath ? resolve(dbPath) : join(currentDir, 'db.sqlite')
-    };
-}
-/**
- * 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
+ * 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
+ * });
+ * ```
  */
+import { SearchEngine as CoreSearchEngine } from './core/search.js';
+import { TextSearchFactory } from './factories/index.js';
 export class SearchEngine {
-    // Static properties for automatic resource management (Requirement 5.1, 5.2)
-    static instances = new Set();
-    static cleanupHandlersSet = false;
-    embedder = null;
-    indexManager = null;
-    dbConnection = null;
-    reranker = null;
-    isInitialized = false;
     indexPath;
     dbPath;
-    enableReranking = false;
-    /**
-     * 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, dbPath) {
-        // Validate parameters
-        if (indexPath !== undefined && (typeof indexPath !== 'string' || indexPath.trim() === '')) {
-            throw new Error('indexPath must be a non-empty string when provided');
-        }
-        if (dbPath !== undefined && (typeof dbPath !== 'string' || dbPath.trim() === '')) {
-            throw new Error('dbPath must be a non-empty string when provided');
-        }
-        // Resolve paths automatically
-        const pathConfig = resolveSearchPaths(indexPath, dbPath);
-        this.indexPath = pathConfig.indexPath;
-        this.dbPath = pathConfig.dbPath;
-        // Set up automatic cleanup on process exit (Requirement 5.5)
-        this.setupAutomaticCleanup();
-    }
-    /**
-     * Legacy constructor for backward compatibility
-     * @deprecated Use the simple constructor new SearchEngine(indexPath?, dbPath?) instead
-     */
-    static createWithComponents(embedder, indexManager, dbConnection, enableReranking = false) {
-        const engine = new SearchEngine();
-        engine.embedder = embedder;
-        engine.indexManager = indexManager;
-        engine.dbConnection = dbConnection;
-        engine.enableReranking = enableReranking;
-        // Initialize reranker if enabled
-        if (enableReranking) {
-            engine.reranker = new CrossEncoderReranker();
+    options;
+    coreEngine = null;
+    initPromise = null;
+    constructor(indexPath, dbPath, options = {}) {
+        this.indexPath = indexPath;
+        this.dbPath = dbPath;
+        this.options = options;
+        // Validate required parameters
+        if (!indexPath || typeof indexPath !== 'string' || indexPath.trim() === '') {
+            throw new Error('Both indexPath and dbPath are required.\n' +
+                'Example: const search = new SearchEngine("./index.bin", "./db.sqlite");\n' +
+                'Or use: const search = await SearchFactory.create("./index.bin", "./db.sqlite");');
+        }
+        if (!dbPath || typeof dbPath !== 'string' || dbPath.trim() === '') {
+            throw new Error('Both indexPath and dbPath are required.\n' +
+                'Example: const search = new SearchEngine("./index.bin", "./db.sqlite");\n' +
+                'Or use: const search = await SearchFactory.create("./index.bin", "./db.sqlite");');
         }
-        engine.isInitialized = true;
-        return engine;
     }
     /**
-     * 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
+     * Initialize the search engine using the factory or direct injection
      */
-    async ensureInitialized() {
-        if (this.isInitialized) {
-            return;
-        }
-        // Check if required files exist first (before any initialization attempts)
-        if (!existsSync(this.dbPath)) {
-            throw this.createUserFriendlyError(new Error(`Database file not found: ${this.dbPath}`), 'missing_database');
-        }
-        if (!existsSync(this.indexPath)) {
-            throw this.createUserFriendlyError(new Error(`Vector index file not found: ${this.indexPath}`), 'missing_index');
-        }
-        try {
-            console.log('Initializing search engine...');
-            // Initialize database connection
-            console.log('Opening database connection...');
-            this.dbConnection = await openDatabase(this.dbPath);
-            // Read stored model info from database (Requirement 4.3)
-            console.log('Reading stored model information...');
-            const storedModelInfo = await getStoredModelInfo(this.dbConnection);
-            if (!storedModelInfo) {
-                throw this.createUserFriendlyError(new Error('No model information found in database'), 'missing_model_info');
-            }
-            // Initialize embedder with stored model info (Requirement 3.5)
-            console.log(`Loading embedding model: ${storedModelInfo.modelName}...`);
-            try {
-                this.embedder = await initializeEmbeddingEngine(storedModelInfo.modelName);
-            }
-            catch (error) {
-                throw this.createUserFriendlyError(error, 'model_loading');
-            }
-            // Initialize index manager with model compatibility validation
-            console.log('Initializing index manager...');
-            try {
-                this.indexManager = new IndexManager(this.indexPath, this.dbPath, storedModelInfo.dimensions, storedModelInfo.modelName);
-                await this.indexManager.initialize();
-            }
-            catch (error) {
-                // Check if this is a model compatibility issue
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                if (errorMessage.includes('mismatch') || errorMessage.includes('version') || errorMessage.includes('model')) {
-                    throw this.createUserFriendlyError(error, 'model_compatibility');
-                }
-                throw error;
-            }
-            // Load reranker model if enabled
-            if (this.enableReranking) {
-                this.reranker = new CrossEncoderReranker();
-                console.log('Loading reranker model...');
-                try {
-                    await this.reranker.loadModel();
+    async initialize() {
+        if (this.coreEngine) {
+            return; // Already initialized
+        }
+        if (this.initPromise) {
+            return this.initPromise; // Initialization in progress
+        }
+        this.initPromise = (async () => {
+            // If custom functions are provided, use direct dependency injection
+            if (this.options.embedFn || this.options.rerankFn) {
+                const { IndexManager } = await import('./index-manager.js');
+                const { openDatabase } = await import('./core/db.js');
+                const { createTextEmbedFunction } = await import('./text/embedder.js');
+                const { existsSync } = await import('fs');
+                // Validate files exist
+                if (!existsSync(this.indexPath)) {
+                    throw new Error(`Vector index not found at: ${this.indexPath}`);
                 }
-                catch (error) {
-                    console.warn(`Reranker initialization failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-                    console.warn('Continuing with vector search only (reranking disabled)');
-                    this.reranker = null; // Disable reranker for this session
+                if (!existsSync(this.dbPath)) {
+                    throw new Error(`Database not found at: ${this.dbPath}`);
                 }
-            }
-            this.isInitialized = true;
-            const stats = await this.indexManager.getStats();
-            console.log(`Search engine initialized with ${stats.totalVectors} chunks${this.reranker && this.reranker.isLoaded() ? ' and reranking enabled' : ''}`);
-        }
-        catch (error) {
-            await this.cleanup();
-            if (error instanceof SearchError) {
-                throw error;
+                // Use custom embedFn or create default
+                const embedFn = this.options.embedFn || createTextEmbedFunction(this.options.embeddingModel);
+                // Get model defaults for dimensions
+                const { getModelDefaults, config } = await import('./core/config.js');
+                const modelDefaults = getModelDefaults(this.options.embeddingModel || config.embedding_model);
+                // Initialize dependencies
+                const db = await openDatabase(this.dbPath);
+                const indexManager = new IndexManager(this.indexPath, this.dbPath, modelDefaults.dimensions, this.options.embeddingModel);
+                await indexManager.initialize();
+                // Create ContentResolver for unified content system
+                const { ContentResolver } = await import('./core/content-resolver.js');
+                const contentResolver = new ContentResolver(db);
+                // Create core engine with dependency injection
+                this.coreEngine = new CoreSearchEngine(embedFn, indexManager, db, this.options.rerankFn, contentResolver);
             }
             else {
-                throw this.createUserFriendlyError(error, 'initialization');
+                // Use factory for standard initialization
+                this.coreEngine = await TextSearchFactory.create(this.indexPath, this.dbPath, this.options);
             }
-        }
+        })();
+        return this.initPromise;
     }
     /**
-     * Create user-friendly error messages with actionable suggestions
-     * Implements requirement 5.3: Clear, actionable error messages with specific next steps
+     * Perform semantic search
      */
-    createUserFriendlyError(error, context) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        // Handle common error scenarios with specific guidance
-        if (context === 'missing_database') {
-            return new SearchError(`Database file not found: ${this.dbPath}`, 'DATABASE_NOT_FOUND', [
-                'Run ingestion first to create the database: pipeline.ingestDirectory("./docs/")',
-                'Check that the database path is correct',
-                'Ensure the ingestion process completed successfully'
-            ]);
+    async search(query, options) {
+        await this.initialize();
+        if (!this.coreEngine) {
+            throw new Error('SearchEngine failed to initialize');
         }
-        if (context === 'missing_index') {
-            return new SearchError(`Vector index file not found: ${this.indexPath}`, 'INDEX_NOT_FOUND', [
-                'Run ingestion first to create the index: pipeline.ingestDirectory("./docs/")',
-                'Check that the index path is correct',
-                'Ensure the ingestion process completed successfully'
-            ]);
-        }
-        if (context === 'missing_model_info') {
-            return new SearchError('No embedding model information found in database. The database may be from an older version or corrupted.', 'MODEL_INFO_NOT_FOUND', [
-                'Run ingestion again to store model information: pipeline.ingestDirectory("./docs/")',
-                'If the problem persists, delete the database and index files and run ingestion from scratch',
-                'Check that the database was created with a compatible version of the library'
-            ]);
-        }
-        if (context === 'model_loading') {
-            return new SearchError(`Failed to load embedding model: ${errorMessage}`, 'MODEL_LOADING_FAILED', [
-                'Check that the model name is correct and supported',
-                'Ensure you have internet connection for model download',
-                'Try running ingestion again with a supported model',
-                'Check the model configuration in your setup'
-            ]);
-        }
-        if (context === 'model_compatibility' || (errorMessage.includes('model') && errorMessage.includes('mismatch'))) {
-            return new SearchError(`Model compatibility issue detected: ${errorMessage}`, 'MODEL_COMPATIBILITY', [
-                'The stored model information doesn\'t match the current configuration',
-                'Run pipeline.rebuildIndex() to rebuild with the current model',
-                'Or ensure you\'re using the same model that was used during ingestion',
-                'Check that the index and database files are from the same ingestion run'
-            ]);
-        }
-        if (errorMessage.includes('ENOENT') || errorMessage.includes('no such file')) {
-            return new SearchError(`Required files not found: ${errorMessage}`, 'FILES_NOT_FOUND', [
-                'Run ingestion first to create the required files',
-                'Check that the file paths are correct',
-                'Ensure you have read permissions for the files'
-            ]);
-        }
-        if (errorMessage.includes('EACCES') || errorMessage.includes('permission denied')) {
-            return new SearchError(`Permission denied: ${errorMessage}`, 'PERMISSION_DENIED', [
-                'Check that you have read permissions for the database and index files',
-                'Ensure the files are not locked by another process',
-                'Try running with appropriate permissions'
-            ]);
-        }
-        if (errorMessage.includes('database') || errorMessage.includes('sqlite')) {
-            return new SearchError(`Database error: ${errorMessage}`, 'DATABASE_ERROR', [
-                'Check that the database file is not corrupted',
-                'Ensure no other processes are using the database',
-                'Try recreating the database by running ingestion again'
-            ]);
-        }
-        // Generic error with basic suggestions
-        return new SearchError(`Search engine ${context} failed: ${errorMessage}`, 'GENERAL_ERROR', [
-            'Check the error message above for specific details',
-            'Ensure all required files exist and are accessible',
-            'Try running ingestion first if you haven\'t already',
-            'Contact support if the issue persists'
-        ]);
+        return this.coreEngine.search(query, options);
     }
     /**
-     * Initialize the search engine (public method for backward compatibility)
-     * Sets up database, index manager, and embedding engine
+     * 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
      */
-    async initialize() {
-        await this.ensureInitialized();
-    }
-    /**
-     * 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
-     */
-    async search(query, options = {}) {
-        // Automatic initialization on first use (Requirement 4.1, 4.2)
-        await this.ensureInitialized();
-        if (!query || query.trim().length === 0) {
-            return [];
-        }
-        const startTime = performance.now();
-        const topK = options.top_k || config.top_k || 10;
-        const shouldRerank = options.rerank !== undefined ? options.rerank : config.rerank_enabled;
-        try {
-            // Ensure all components are initialized
-            if (!this.embedder || !this.indexManager || !this.dbConnection) {
-                throw new Error('Search engine components not properly initialized');
-            }
-            // Step 1: Build query embedding using same model as document chunks
-            const embeddingStartTime = performance.now();
-            const queryEmbedding = await this.embedder.embedSingle(query);
-            const embeddingTime = performance.now() - embeddingStartTime;
-            // Step 2: Search using IndexManager (which handles hash mapping properly)
-            const searchStartTime = performance.now();
-            let searchResult;
-            try {
-                searchResult = this.indexManager.search(queryEmbedding.vector, topK);
-            }
-            catch (error) {
-                if (error instanceof Error && error.message.includes('No embedding ID found for hash')) {
-                    console.warn(`Hash mapping issue detected: ${error.message}`);
-                    console.warn('This may indicate index/database synchronization issues. Consider running: raglite rebuild');
-                    return [];
-                }
-                throw error;
-            }
-            const vectorSearchTime = performance.now() - searchStartTime;
-            if (searchResult.embeddingIds.length === 0) {
-                const totalTime = performance.now() - startTime;
-                console.log(`No similar documents found (${totalTime.toFixed(2)}ms total)`);
-                return [];
-            }
-            // Step 3: Retrieve chunks from database using embedding IDs
-            const retrievalStartTime = performance.now();
-            const chunks = await getChunksByEmbeddingIds(this.dbConnection, searchResult.embeddingIds);
-            const retrievalTime = performance.now() - retrievalStartTime;
-            // Step 4: Format results as JSON with text, score, and document metadata
-            let results = this.formatSearchResults(chunks, searchResult.distances, searchResult.embeddingIds);
-            // Step 5: Optional reranking with cross-encoder when enabled
-            let rerankTime = 0;
-            if (shouldRerank && this.reranker && this.reranker.isLoaded() && results.length > 1) {
-                try {
-                    const rerankStartTime = performance.now();
-                    results = await this.reranker.rerank(query, results);
-                    rerankTime = performance.now() - rerankStartTime;
-                }
-                catch (error) {
-                    // Fallback to vector search results and log the error
-                    console.warn(`Reranking failed, using vector search results: ${error instanceof Error ? error.message : 'Unknown error'}`);
-                }
-            }
-            const totalTime = performance.now() - startTime;
-            // Measure latency without premature optimization - just log for monitoring
-            console.log(`Search completed: ${results.length} results in ${totalTime.toFixed(2)}ms ` +
-                `(embed: ${embeddingTime.toFixed(2)}ms, vector: ${vectorSearchTime.toFixed(2)}ms, ` +
-                `retrieval: ${retrievalTime.toFixed(2)}ms${rerankTime > 0 ? `, rerank: ${rerankTime.toFixed(2)}ms` : ''})`);
-            return results;
-        }
-        catch (error) {
-            throw new Error(`Search failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    async getContent(contentId, format = 'file') {
+        await this.initialize();
+        if (!this.coreEngine) {
+            throw new Error('SearchEngine failed to initialize');
         }
+        return this.coreEngine.getContent(contentId, format);
     }
     /**
-     * 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
      */
-    formatSearchResults(chunks, distances, embeddingIds) {
-        const results = [];
-        // Create a map for quick chunk lookup by embedding_id
-        const chunkMap = new Map();
-        chunks.forEach(chunk => {
-            chunkMap.set(chunk.embedding_id, chunk);
-        });
-        // Build results in the order of search results
-        for (let i = 0; i < embeddingIds.length; i++) {
-            const embeddingId = embeddingIds[i];
-            const chunk = chunkMap.get(embeddingId);
-            if (chunk) {
-                // Convert cosine distance to similarity score (1 - distance)
-                // hnswlib-wasm returns cosine distance, we want similarity
-                const score = Math.max(0, 1 - distances[i]);
-                results.push({
-                    text: chunk.text,
-                    score: score,
-                    document: {
-                        id: chunk.document_id,
-                        source: chunk.document_source,
-                        title: chunk.document_title
-                    }
-                });
-            }
+    async getContentBatch(contentIds, format = 'file') {
+        await this.initialize();
+        if (!this.coreEngine) {
+            throw new Error('SearchEngine failed to initialize');
         }
-        return results;
+        return this.coreEngine.getContentBatch(contentIds, format);
     }
     /**
-     * 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
      */
-    async getStats() {
-        if (!this.isInitialized) {
-            return {
-                totalChunks: 0,
-                indexSize: 0,
-                rerankingEnabled: false,
-                isInitialized: false
-            };
+    async getContentMetadata(contentId) {
+        await this.initialize();
+        if (!this.coreEngine) {
+            throw new Error('SearchEngine failed to initialize');
         }
-        const indexStats = await this.indexManager.getStats();
-        return {
-            totalChunks: indexStats.totalVectors,
-            indexSize: indexStats.totalVectors,
-            rerankingEnabled: this.reranker !== null && this.reranker.isLoaded(),
-            isInitialized: this.isInitialized
-        };
+        return this.coreEngine.getContentMetadata(contentId);
     }
     /**
-     * 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
      */
-    setupAutomaticCleanup() {
-        // Track this instance for cleanup
-        SearchEngine.instances.add(this);
-        // Set up process exit handlers only once
-        if (!SearchEngine.cleanupHandlersSet) {
-            SearchEngine.cleanupHandlersSet = true;
-            const cleanupAll = async () => {
-                const instances = Array.from(SearchEngine.instances);
-                await Promise.all(instances.map(instance => instance.cleanup()));
-            };
-            // Handle various exit scenarios
-            process.on('exit', () => {
-                // Synchronous cleanup for exit event
-                for (const instance of SearchEngine.instances) {
-                    try {
-                        if (instance.dbConnection) {
-                            // Synchronous close for exit handler
-                            instance.dbConnection = null;
-                        }
-                        if (instance.indexManager) {
-                            instance.indexManager = null;
-                        }
-                        instance.embedder = null;
-                        instance.reranker = null;
-                        instance.isInitialized = false;
-                    }
-                    catch (error) {
-                        // Silent cleanup on exit
-                    }
-                }
-            });
-            process.on('SIGINT', async () => {
-                await cleanupAll();
-                process.exit(0);
-            });
-            process.on('SIGTERM', async () => {
-                await cleanupAll();
-                process.exit(0);
-            });
-            process.on('uncaughtException', async (error) => {
-                console.error('Uncaught exception:', error);
-                await cleanupAll();
-                process.exit(1);
-            });
-            process.on('unhandledRejection', async (reason) => {
-                console.error('Unhandled rejection:', reason);
-                await cleanupAll();
-                process.exit(1);
-            });
+    async verifyContentExists(contentId) {
+        await this.initialize();
+        if (!this.coreEngine) {
+            throw new Error('SearchEngine failed to initialize');
         }
+        return this.coreEngine.verifyContentExists(contentId);
     }
     /**
-     * Clean up resources (Requirement 5.5)
+     * Clean up resources
      */
     async cleanup() {
-        try {
-            if (this.dbConnection) {
-                await this.dbConnection.close();
-                this.dbConnection = null;
-            }
-            if (this.indexManager) {
-                await this.indexManager.close();
-                this.indexManager = null;
-            }
-            this.embedder = null;
-            this.reranker = null;
-            this.isInitialized = false;
-            // Remove from instances set
-            SearchEngine.instances.delete(this);
-        }
-        catch (error) {
-            console.error('Error during SearchEngine cleanup:', error instanceof Error ? error.message : String(error));
+        if (this.coreEngine) {
+            await this.coreEngine.cleanup();
         }
     }
 }

package/dist/test-utils.d.ts

@@ -2,35 +2,17 @@
  * Test utilities for multi-model support
  * Provides common configurations and helpers for testing with different embedding models
  */
-export declare const TEST_MODELS: readonly [{
-    readonly name: "sentence-transformers/all-MiniLM-L6-v2";
-    readonly dimensions: 384;
-    readonly chunkSize: 250;
-    readonly batchSize: 16;
-}, {
-    readonly name: "Xenova/all-mpnet-base-v2";
-    readonly dimensions: 768;
-    readonly chunkSize: 400;
-    readonly batchSize: 8;
-}];
+export interface TestModel {
+    name: string;
+    dimensions: number;
+    chunkSize: number;
+    batchSize: number;
+}
+export declare const TEST_MODELS: TestModel[];
 /**
  * Retrieve model configuration by name
  * @param modelName - The name of the model to retrieve
  * @returns Model configuration object or undefined if not found
  */
-export declare function getTestModel(modelName: string): {
-    readonly name: "sentence-transformers/all-MiniLM-L6-v2";
-    readonly dimensions: 384;
-    readonly chunkSize: 250;
-    readonly batchSize: 16;
-} | {
-    readonly name: "Xenova/all-mpnet-base-v2";
-    readonly dimensions: 768;
-    readonly chunkSize: 400;
-    readonly batchSize: 8;
-} | undefined;
-/**
- * Type for test model configuration
- */
-export type TestModel = typeof TEST_MODELS[number];
+export declare function getTestModel(modelName: string): TestModel | undefined;
 //# sourceMappingURL=test-utils.d.ts.map

package/dist/text/chunker.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Text-specific chunking implementation
+ * Implements the ChunkingStrategy interface for text content
+ */
+import '../dom-polyfills.js';
+import { ChunkingStrategy, GenericDocument, GenericChunk, ChunkConfig } from '../core/chunker.js';
+/**
+ * Document interface for text chunking
+ */
+export interface Document {
+    source: string;
+    title: string;
+    content: string;
+    metadata?: Record<string, any>;
+}
+export interface Chunk {
+    text: string;
+    chunkIndex: number;
+    tokenCount: number;
+}
+/**
+ * Text chunking strategy implementation
+ */
+export declare class TextChunkingStrategy implements ChunkingStrategy {
+    appliesTo(contentType: string): boolean;
+    chunk(document: GenericDocument, config: ChunkConfig): Promise<GenericChunk[]>;
+}
+/**
+ * Text document chunking function
+ * Converts between text-specific and generic interfaces
+ */
+export declare function chunkDocument(document: Document, config?: ChunkConfig): Promise<Chunk[]>;
+//# sourceMappingURL=chunker.d.ts.map