rag-lite-ts 1.0.1 → 1.0.2

package/dist/core/adapters.d.ts

@@ -0,0 +1,93 @@
+/**
+ * CORE MODULE — Shared between text-only (rag-lite-ts) and future multimodal (rag-lite-mm)
+ * Model-agnostic. No transformer or modality-specific logic.
+ *
+ * This module provides adapter utilities to convert existing implementations to the new
+ * dependency injection interfaces. These adapters enable:
+ *
+ * 1. Integration with existing embedding and reranking implementations
+ * 2. Support for dependency injection patterns
+ * 3. Wrapping of third-party libraries to match core interfaces
+ * 4. Testing with mock implementations
+ *
+ * ADAPTER PATTERN USAGE:
+ * ```typescript
+ * // Convert embedder to dependency injection
+ * const embedder = new TextEmbeddingEngine();
+ * const embedFn = EmbeddingAdapter.fromEmbedder(embedder);
+ * const search = new SearchEngine(embedFn, indexManager, db);
+ *
+ * // Convert reranker to dependency injection
+ * const reranker = new CrossEncoderReranker();
+ * const rerankFn = RerankingAdapter.fromReranker(reranker);
+ * const search = new SearchEngine(embedFn, indexManager, db, rerankFn);
+ *
+ * // Create full interfaces for advanced usage
+ * const embeddingInterface = EmbeddingAdapter.createInterface(
+ *   embedder,
+ *   ['text'],
+ *   384,
+ *   'all-MiniLM-L6-v2'
+ * );
+ * ```
+ */
+import type { EmbedFunction, RerankFunction, EmbeddingQueryInterface, RerankingInterface } from './interfaces.js';
+/**
+ * Adapter to convert embedding engines to core EmbedFunction
+ * Enables integration while supporting dependency injection
+ *
+ * USAGE EXAMPLES:
+ * ```typescript
+ * // Basic adapter usage
+ * const embedder = new TextEmbeddingEngine();
+ * const embedFn = EmbeddingAdapter.fromEmbedder(embedder);
+ *
+ * // Use in SearchEngine
+ * const search = new SearchEngine(embedFn, indexManager, db);
+ *
+ * // Create full interface for advanced features
+ * const embeddingInterface = EmbeddingAdapter.createInterface(
+ *   embedder,
+ *   ['text', 'code'],  // Supported content types
+ *   384,               // Embedding dimensions
+ *   'all-MiniLM-L6-v2' // Model identifier
+ * );
+ *
+ * // Use interface for validation and metadata
+ * if (embeddingInterface.supportedContentTypes.includes('text')) {
+ *   const result = await embeddingInterface.embedQuery('test query');
+ * }
+ * ```
+ */
+export declare class EmbeddingAdapter {
+    /**
+     * Convert an embedding engine to an EmbedFunction
+     * @param embedder - Embedder with embedSingle method
+     * @returns EmbedFunction compatible with core dependency injection
+     */
+    static fromEmbedder(embedder: any): EmbedFunction;
+    /**
+     * Create an EmbeddingQueryInterface from an embedder
+     * @param embedder - Embedder with embedSingle method
+     * @param supportedContentTypes - Content types this embedder supports
+     * @param embeddingDimensions - Dimensions of embedding vectors
+     * @param modelIdentifier - Model name or identifier
+     * @returns Full EmbeddingQueryInterface with metadata
+     */
+    static createInterface(embedder: any, supportedContentTypes?: string[], embeddingDimensions?: number, modelIdentifier?: string): EmbeddingQueryInterface;
+}
+/**
+ * Adapter to convert rerankers to core RerankFunction
+ * Enables integration while supporting dependency injection
+ */
+export declare class RerankingAdapter {
+    /**
+     * Convert a reranker to a RerankFunction
+     */
+    static fromReranker(reranker: any): RerankFunction;
+    /**
+     * Create a RerankingInterface from a reranker
+     */
+    static createInterface(reranker: any, supportedContentTypes?: string[], modelIdentifier?: string): RerankingInterface;
+}
+//# sourceMappingURL=adapters.d.ts.map

package/dist/core/adapters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapters.d.ts","sourceRoot":"","sources":["../../src/core/adapters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,uBAAuB,EACvB,kBAAkB,EAEnB,MAAM,iBAAiB,CAAC;AAGzB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,gBAAgB;IAC3B;;;;OAIG;IACH,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,GAAG,GAAG,aAAa;IAOjD;;;;;;;OAOG;IACH,MAAM,CAAC,eAAe,CACpB,QAAQ,EAAE,GAAG,EACb,qBAAqB,GAAE,MAAM,EAAa,EAC1C,mBAAmB,GAAE,MAAY,EACjC,eAAe,GAAE,MAAkB,GAClC,uBAAuB;CAQ3B;AAED;;;GAGG;AACH,qBAAa,gBAAgB;IAC3B;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,GAAG,GAAG,cAAc;IAoClD;;OAEG;IACH,MAAM,CAAC,eAAe,CACpB,QAAQ,EAAE,GAAG,EACb,qBAAqB,GAAE,MAAM,EAAa,EAC1C,eAAe,GAAE,MAAkB,GAClC,kBAAkB;CAQtB"}

package/dist/core/adapters.js

@@ -0,0 +1,139 @@
+/**
+ * CORE MODULE — Shared between text-only (rag-lite-ts) and future multimodal (rag-lite-mm)
+ * Model-agnostic. No transformer or modality-specific logic.
+ *
+ * This module provides adapter utilities to convert existing implementations to the new
+ * dependency injection interfaces. These adapters enable:
+ *
+ * 1. Integration with existing embedding and reranking implementations
+ * 2. Support for dependency injection patterns
+ * 3. Wrapping of third-party libraries to match core interfaces
+ * 4. Testing with mock implementations
+ *
+ * ADAPTER PATTERN USAGE:
+ * ```typescript
+ * // Convert embedder to dependency injection
+ * const embedder = new TextEmbeddingEngine();
+ * const embedFn = EmbeddingAdapter.fromEmbedder(embedder);
+ * const search = new SearchEngine(embedFn, indexManager, db);
+ *
+ * // Convert reranker to dependency injection
+ * const reranker = new CrossEncoderReranker();
+ * const rerankFn = RerankingAdapter.fromReranker(reranker);
+ * const search = new SearchEngine(embedFn, indexManager, db, rerankFn);
+ *
+ * // Create full interfaces for advanced usage
+ * const embeddingInterface = EmbeddingAdapter.createInterface(
+ *   embedder,
+ *   ['text'],
+ *   384,
+ *   'all-MiniLM-L6-v2'
+ * );
+ * ```
+ */
+/**
+ * Adapter to convert embedding engines to core EmbedFunction
+ * Enables integration while supporting dependency injection
+ *
+ * USAGE EXAMPLES:
+ * ```typescript
+ * // Basic adapter usage
+ * const embedder = new TextEmbeddingEngine();
+ * const embedFn = EmbeddingAdapter.fromEmbedder(embedder);
+ *
+ * // Use in SearchEngine
+ * const search = new SearchEngine(embedFn, indexManager, db);
+ *
+ * // Create full interface for advanced features
+ * const embeddingInterface = EmbeddingAdapter.createInterface(
+ *   embedder,
+ *   ['text', 'code'],  // Supported content types
+ *   384,               // Embedding dimensions
+ *   'all-MiniLM-L6-v2' // Model identifier
+ * );
+ *
+ * // Use interface for validation and metadata
+ * if (embeddingInterface.supportedContentTypes.includes('text')) {
+ *   const result = await embeddingInterface.embedQuery('test query');
+ * }
+ * ```
+ */
+export class EmbeddingAdapter {
+    /**
+     * Convert an embedding engine to an EmbedFunction
+     * @param embedder - Embedder with embedSingle method
+     * @returns EmbedFunction compatible with core dependency injection
+     */
+    static fromEmbedder(embedder) {
+        return async (query, contentType) => {
+            // Call the embedSingle method
+            return await embedder.embedSingle(query);
+        };
+    }
+    /**
+     * Create an EmbeddingQueryInterface from an embedder
+     * @param embedder - Embedder with embedSingle method
+     * @param supportedContentTypes - Content types this embedder supports
+     * @param embeddingDimensions - Dimensions of embedding vectors
+     * @param modelIdentifier - Model name or identifier
+     * @returns Full EmbeddingQueryInterface with metadata
+     */
+    static createInterface(embedder, supportedContentTypes = ['text'], embeddingDimensions = 384, modelIdentifier = 'unknown') {
+        return {
+            embedQuery: this.fromEmbedder(embedder),
+            supportedContentTypes,
+            embeddingDimensions,
+            modelIdentifier
+        };
+    }
+}
+/**
+ * Adapter to convert rerankers to core RerankFunction
+ * Enables integration while supporting dependency injection
+ */
+export class RerankingAdapter {
+    /**
+     * Convert a reranker to a RerankFunction
+     */
+    static fromReranker(reranker) {
+        return async (query, results, contentType) => {
+            // Convert core SearchResult format to reranker format
+            const rerankResults = results.map(result => ({
+                text: result.content,
+                score: result.score,
+                document: {
+                    id: result.document.id,
+                    source: result.document.source,
+                    title: result.document.title
+                }
+            }));
+            // Call rerank method
+            const reranked = await reranker.rerank(query, rerankResults);
+            // Convert back to core SearchResult format
+            return reranked.map((result, index) => ({
+                content: result.text,
+                score: result.score,
+                contentType: results[index]?.contentType || 'text',
+                document: {
+                    id: result.document.id,
+                    source: result.document.source,
+                    title: result.document.title,
+                    contentType: results[index]?.document.contentType || 'text'
+                },
+                metadata: results[index]?.metadata
+            }));
+        };
+    }
+    /**
+     * Create a RerankingInterface from a reranker
+     */
+    static createInterface(reranker, supportedContentTypes = ['text'], modelIdentifier = 'unknown') {
+        return {
+            rerankResults: this.fromReranker(reranker),
+            supportedContentTypes,
+            isEnabled: reranker && reranker.isLoaded && reranker.isLoaded(),
+            modelIdentifier
+        };
+    }
+}
+//# sourceMappingURL=adapters.js.map

package/dist/core/adapters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapters.js","sourceRoot":"","sources":["../../src/core/adapters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAWH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,OAAO,gBAAgB;IAC3B;;;;OAIG;IACH,MAAM,CAAC,YAAY,CAAC,QAAa;QAC/B,OAAO,KAAK,EAAE,KAAa,EAAE,WAAoB,EAA4B,EAAE;YAC7E,8BAA8B;YAC9B,OAAO,MAAM,QAAQ,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QAC3C,CAAC,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,eAAe,CACpB,QAAa,EACb,wBAAkC,CAAC,MAAM,CAAC,EAC1C,sBAA8B,GAAG,EACjC,kBAA0B,SAAS;QAEnC,OAAO;YACL,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC;YACvC,qBAAqB;YACrB,mBAAmB;YACnB,eAAe;SAChB,CAAC;IACJ,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAO,gBAAgB;IAC3B;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,QAAa;QAC/B,OAAO,KAAK,EACV,KAAa,EACb,OAAuB,EACvB,WAAoB,EACK,EAAE;YAC3B,sDAAsD;YACtD,MAAM,aAAa,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;gBAC3C,IAAI,EAAE,MAAM,CAAC,OAAO;gBACpB,KAAK,EAAE,MAAM,CAAC,KAAK;gBACnB,QAAQ,EAAE;oBACR,EAAE,EAAE,MAAM,CAAC,QAAQ,CAAC,EAAE;oBACtB,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM;oBAC9B,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK;iBAC7B;aACF,CAAC,CAAC,CAAC;YAEJ,qBAAqB;YACrB,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;YAE7D,2CAA2C;YAC3C,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,MAAW,EAAE,KAAa,EAAE,EAAE,CAAC,CAAC;gBACnD,OAAO,EAAE,MAAM,CAAC,IAAI;gBACpB,KAAK,EAAE,MAAM,CAAC,KAAK;gBACnB,WAAW,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,WAAW,IAAI,MAAM;gBAClD,QAAQ,EAAE;oBACR,EAAE,EAAE,MAAM,CAAC,QAAQ,CAAC,EAAE;oBACtB,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM;oBAC9B,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK;oBAC5B,WAAW,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,WAAW,IAAI,MAAM;iBAC5D;gBACD,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,QAAQ;aACnC,CAAC,CAAC,CAAC;QACN,CAAC,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,eAAe,CACpB,QAAa,EACb,wBAAkC,CAAC,MAAM,CAAC,EAC1C,kBAA0B,SAAS;QAEnC,OAAO;YACL,aAAa,EAAE,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC;YAC1C,qBAAqB;YACrB,SAAS,EAAE,QAAQ,IAAI,QAAQ,CAAC,QAAQ,IAAI,QAAQ,CAAC,QAAQ,EAAE;YAC/D,eAAe;SAChB,CAAC;IACJ,CAAC;CACF"}

package/dist/core/chunker.d.ts

@@ -0,0 +1,117 @@
+/**
+ * CORE MODULE — Shared between text-only (rag-lite-ts) and future multimodal (rag-lite-mm)
+ * Model-agnostic. No transformer or modality-specific logic.
+ */
+/**
+ * Configuration for chunking behavior
+ */
+export interface ChunkConfig {
+    /** Target chunk size in tokens (200-300 recommended) */
+    chunkSize: number;
+    /** Overlap between chunks in tokens (50 recommended) */
+    chunkOverlap: number;
+}
+/**
+ * Generic document interface that can represent different content types
+ */
+export interface GenericDocument {
+    /** Source path or identifier */
+    source: string;
+    /** Document title */
+    title: string;
+    /** Content (text, image path, etc.) */
+    content: string;
+    /** Content type identifier (text, image, etc.) */
+    contentType: string;
+    /** Optional metadata for the document */
+    metadata?: Record<string, any>;
+}
+/**
+ * Generic chunk interface that can represent different content types
+ */
+export interface GenericChunk {
+    /** The content of the chunk (text, image path, etc.) */
+    content: string;
+    /** Content type identifier (text, image, etc.) */
+    contentType: string;
+    /** Index of this chunk within the document */
+    chunkIndex: number;
+    /** Optional metadata for the chunk */
+    metadata?: Record<string, any>;
+}
+/**
+ * Strategy interface for chunking different content types
+ */
+export interface ChunkingStrategy {
+    /**
+     * Check if this strategy applies to the given content type
+     */
+    appliesTo(contentType: string): boolean;
+    /**
+     * Chunk a document using this strategy
+     */
+    chunk(document: GenericDocument, config: ChunkConfig): Promise<GenericChunk[]>;
+}
+/**
+ * Registry for chunking strategies
+ */
+export declare class ChunkingStrategyRegistry {
+    private strategies;
+    /**
+     * Register a chunking strategy
+     */
+    register(strategy: ChunkingStrategy): void;
+    /**
+     * Find the appropriate strategy for a content type
+     */
+    findStrategy(contentType: string): ChunkingStrategy | undefined;
+    /**
+     * Get all registered strategies
+     */
+    getStrategies(): ChunkingStrategy[];
+}
+/**
+ * Default chunking configuration
+ */
+export declare const DEFAULT_CHUNK_CONFIG: ChunkConfig;
+/**
+ * Global chunking strategy registry
+ */
+export declare const chunkingRegistry: ChunkingStrategyRegistry;
+/**
+ * Generic chunking function that uses registered strategies
+ */
+export declare function chunkGenericDocument(document: GenericDocument, config?: ChunkConfig): Promise<GenericChunk[]>;
+/**
+ * Document interface for text chunking
+ */
+export interface Document {
+    /** Source path or identifier */
+    source: string;
+    /** Document title */
+    title: string;
+    /** Full text content */
+    content: string;
+}
+/**
+ * Chunk interface for text chunking results
+ */
+export interface Chunk {
+    /** The text content of the chunk */
+    text: string;
+    /** Index of this chunk within the document */
+    chunkIndex: number;
+    /** Number of tokens in this chunk */
+    tokenCount: number;
+}
+/**
+ * Text document chunking function
+ * Uses the text chunking strategy from the text implementation layer
+ */
+export declare function chunkDocument(document: Document, config?: ChunkConfig): Promise<Chunk[]>;
+/**
+ * Register the text chunking strategy with the global registry
+ * This should be called during application initialization
+ */
+export declare function registerTextChunkingStrategy(): Promise<void>;
+//# sourceMappingURL=chunker.d.ts.map

package/dist/core/chunker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunker.d.ts","sourceRoot":"","sources":["../../src/core/chunker.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,wDAAwD;IACxD,SAAS,EAAE,MAAM,CAAC;IAClB,wDAAwD;IACxD,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,qBAAqB;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,uCAAuC;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,kDAAkD;IAClD,WAAW,EAAE,MAAM,CAAC;IACpB,yCAAyC;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;IAChB,kDAAkD;IAClD,WAAW,EAAE,MAAM,CAAC;IACpB,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAC;IACnB,sCAAsC;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC;IAExC;;OAEG;IACH,KAAK,CAAC,QAAQ,EAAE,eAAe,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;CAChF;AAED;;GAEG;AACH,qBAAa,wBAAwB;IACnC,OAAO,CAAC,UAAU,CAA0B;IAE5C;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI;IAI1C;;OAEG;IACH,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAI/D;;OAEG;IACH,aAAa,IAAI,gBAAgB,EAAE;CAGpC;AAED;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,WAGlC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,0BAAiC,CAAC;AAE/D;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,eAAe,EACzB,MAAM,GAAE,WAAkC,GACzC,OAAO,CAAC,YAAY,EAAE,CAAC,CAQzB;AAOD;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,qBAAqB;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,wBAAwB;IACxB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAC;IACnB,qCAAqC;IACrC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAsB,aAAa,CACjC,QAAQ,EAAE,QAAQ,EAClB,MAAM,GAAE,WAAkC,GACzC,OAAO,CAAC,KAAK,EAAE,CAAC,CAIlB;AACD;;;GAGG;AACH,wBAAsB,4BAA4B,IAAI,OAAO,CAAC,IAAI,CAAC,CAIlE"}

package/dist/core/chunker.js

@@ -0,0 +1,73 @@
+/**
+ * CORE MODULE — Shared between text-only (rag-lite-ts) and future multimodal (rag-lite-mm)
+ * Model-agnostic. No transformer or modality-specific logic.
+ */
+/**
+ * Registry for chunking strategies
+ */
+export class ChunkingStrategyRegistry {
+    strategies = [];
+    /**
+     * Register a chunking strategy
+     */
+    register(strategy) {
+        this.strategies.push(strategy);
+    }
+    /**
+     * Find the appropriate strategy for a content type
+     */
+    findStrategy(contentType) {
+        return this.strategies.find(strategy => strategy.appliesTo(contentType));
+    }
+    /**
+     * Get all registered strategies
+     */
+    getStrategies() {
+        return [...this.strategies];
+    }
+}
+/**
+ * Default chunking configuration
+ */
+export const DEFAULT_CHUNK_CONFIG = {
+    chunkSize: 250, // Target 200-300 tokens
+    chunkOverlap: 50
+};
+/**
+ * Global chunking strategy registry
+ */
+export const chunkingRegistry = new ChunkingStrategyRegistry();
+/**
+ * Generic chunking function that uses registered strategies
+ */
+export async function chunkGenericDocument(document, config = DEFAULT_CHUNK_CONFIG) {
+    const strategy = chunkingRegistry.findStrategy(document.contentType);
+    if (!strategy) {
+        throw new Error(`No chunking strategy found for content type: ${document.contentType}`);
+    }
+    return strategy.chunk(document, config);
+}
+/**
+ * Text document chunking function
+ * Uses the text chunking strategy from the text implementation layer
+ */
+export async function chunkDocument(document, config = DEFAULT_CHUNK_CONFIG) {
+    // Import the text chunker implementation dynamically to avoid circular dependencies
+    const { chunkDocument: textChunkDocument } = await import('../text/chunker.js');
+    return textChunkDocument(document, config);
+}
+/**
+ * Register the text chunking strategy with the global registry
+ * This should be called during application initialization
+ */
+export async function registerTextChunkingStrategy() {
+    const { TextChunkingStrategy } = await import('../text/chunker.js');
+    const textStrategy = new TextChunkingStrategy();
+    chunkingRegistry.register(textStrategy);
+}
+// Auto-register the text strategy when this module is loaded
+// This ensures text chunking works out of the box
+registerTextChunkingStrategy().catch(error => {
+    console.warn('Failed to register text chunking strategy:', error);
+});
+//# sourceMappingURL=chunker.js.map

package/dist/core/chunker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunker.js","sourceRoot":"","sources":["../../src/core/chunker.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAyDH;;GAEG;AACH,MAAM,OAAO,wBAAwB;IAC3B,UAAU,GAAuB,EAAE,CAAC;IAE5C;;OAEG;IACH,QAAQ,CAAC,QAA0B;QACjC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,YAAY,CAAC,WAAmB;QAC9B,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC;IAC3E,CAAC;IAED;;OAEG;IACH,aAAa;QACX,OAAO,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC;IAC9B,CAAC;CACF;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAgB;IAC/C,SAAS,EAAE,GAAG,EAAE,wBAAwB;IACxC,YAAY,EAAE,EAAE;CACjB,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,IAAI,wBAAwB,EAAE,CAAC;AAE/D;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,QAAyB,EACzB,SAAsB,oBAAoB;IAE1C,MAAM,QAAQ,GAAG,gBAAgB,CAAC,YAAY,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;IAErE,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CAAC,gDAAgD,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC;IAC1F,CAAC;IAED,OAAO,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;AAC1C,CAAC;AA+BD;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,QAAkB,EAClB,SAAsB,oBAAoB;IAE1C,oFAAoF;IACpF,MAAM,EAAE,aAAa,EAAE,iBAAiB,EAAE,GAAG,MAAM,MAAM,CAAC,oBAAoB,CAAC,CAAC;IAChF,OAAO,iBAAiB,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;AAC7C,CAAC;AACD;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,4BAA4B;IAChD,MAAM,EAAE,oBAAoB,EAAE,GAAG,MAAM,MAAM,CAAC,oBAAoB,CAAC,CAAC;IACpE,MAAM,YAAY,GAAG,IAAI,oBAAoB,EAAE,CAAC;IAChD,gBAAgB,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;AAC1C,CAAC;AAED,6DAA6D;AAC7D,kDAAkD;AAClD,4BAA4B,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;IAC3C,OAAO,CAAC,IAAI,CAAC,4CAA4C,EAAE,KAAK,CAAC,CAAC;AACpE,CAAC,CAAC,CAAC"}

package/dist/core/config.d.ts

@@ -0,0 +1,102 @@
+/**
+ * CORE MODULE — Shared between text-only (rag-lite-ts) and future multimodal (rag-lite-mm)
+ * Model-agnostic. No transformer or modality-specific logic.
+ */
+/**
+ * Core configuration interface - model-agnostic settings
+ */
+export interface CoreConfig {
+    chunk_size: number;
+    chunk_overlap: number;
+    batch_size: number;
+    top_k: number;
+    db_file: string;
+    index_file: string;
+    model_cache_path?: string;
+    path_storage_strategy: 'absolute' | 'relative';
+    embedding_model: string;
+    rerank_enabled: boolean;
+    preprocessing?: any;
+}
+/**
+ * Extensible configuration interface that can be extended by implementations
+ */
+export interface ExtensibleConfig<T = {}> extends CoreConfig {
+    implementation: T;
+}
+/**
+ * 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);
+}
+/**
+ * Get the default model cache path as specified in the requirements
+ * @returns Default cache path (~/.raglite/models/)
+ */
+export declare function getDefaultModelCachePath(): string;
+/**
+ * Validates core configuration fields
+ * @param config - Configuration object to validate
+ * @throws {ConfigurationError} If configuration is invalid
+ */
+export declare function validateCoreConfig(config: any): asserts config is CoreConfig;
+/**
+ * Model defaults interface for different embedding models
+ */
+export interface ModelDefaults {
+    dimensions: number;
+    chunk_size: number;
+    chunk_overlap: number;
+    batch_size: number;
+}
+/**
+ * Get default configuration for different embedding models
+ * @param modelName - Name of the embedding model
+ * @returns Model-specific defaults
+ */
+export declare function getModelDefaults(modelName?: string): ModelDefaults;
+/**
+ * Default core configuration object
+ * Model-agnostic settings that can be used by core modules
+ */
+export declare const config: CoreConfig;
+/**
+ * Validate preprocessing configuration
+ */
+export declare function validatePreprocessingConfig(config: any): asserts config is any;
+/**
+ * Merge preprocessing configurations with mode defaults
+ */
+export declare function mergePreprocessingConfig(config: any): any;
+/**
+ * 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)
+ */
+export declare function handleUnrecoverableError(error: Error | string, context: string, exitCode?: number): never;
+/**
+ * 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)
+ */
+export declare function logError(error: Error | string, context: string, skipError?: boolean): void;
+//# sourceMappingURL=config.d.ts.map

package/dist/core/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/core/config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qBAAqB,EAAE,UAAU,GAAG,UAAU,CAAC;IAC/C,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,GAAG,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC,GAAG,EAAE,CAAE,SAAQ,UAAU;IAC1D,cAAc,EAAE,CAAC,CAAC;CACnB;AAED;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;CAUb,CAAC;AAEX;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IACP,QAAQ,EAAE,MAAM;gBAAxC,OAAO,EAAE,MAAM,EAAS,QAAQ,GAAE,MAAuC;CAItF;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CAEjD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,IAAI,UAAU,CA+D5E;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,aAAa,CA6BlE;AAED;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE,UAYpB,CAAC;AAEF;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,IAAI,GAAG,CAgC9E;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAazD;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,KAAK,GAAG,MAAM,EACrB,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,MAAiC,GAC1C,KAAK,CAgCP;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,GAAE,OAAe,GAAG,IAAI,CAQjG"}