rag-lite-ts 2.2.0 → 2.3.1

package/dist/esm/core/generator-registry.js

@@ -0,0 +1,280 @@
+/**
+ * CORE MODULE — Generator Registry for RAG Response Generation
+ *
+ * Centralized registry of supported generator models with validation and
+ * compatibility checking. Follows the same patterns as model-registry.ts.
+ *
+ * SUPPORTED MODELS:
+ * - HuggingFaceTB/SmolLM2-135M-Instruct: Balanced instruct model (DEFAULT, 3 chunks)
+ * - HuggingFaceTB/SmolLM2-360M-Instruct: Higher quality instruct model (5 chunks)
+ *
+ * PREREQUISITES:
+ * - Reranking must be enabled for response generation to ensure quality context
+ *
+ * @experimental This feature is experimental and may change in future versions.
+ */
+// =============================================================================
+// GENERATOR REGISTRY
+// =============================================================================
+/**
+ * Registry of supported generator models with their metadata and capabilities
+ */
+export const SUPPORTED_GENERATORS = {
+    // SmolLM2-135M-Instruct - Balanced instruction-tuned model (RECOMMENDED DEFAULT)
+    'HuggingFaceTB/SmolLM2-135M-Instruct': {
+        name: 'HuggingFaceTB/SmolLM2-135M-Instruct',
+        type: 'instruct',
+        version: '1.0.0',
+        description: 'Balanced instruction-tuned model with good quality and speed (uses top 3 chunks)',
+        capabilities: {
+            supportsStreaming: true,
+            supportsSystemPrompt: true, // Instruct models support system prompts
+            instructionTuned: true,
+            maxContextLength: 2048,
+            defaultMaxOutputTokens: 512,
+            recommendedTemperature: 0.1,
+            defaultMaxChunksForContext: 3 // Use top 3 reranked chunks for context
+        },
+        requirements: {
+            transformersJsVersion: '>=3.0.0',
+            minimumMemory: 768,
+            requiredFeatures: ['text-generation'],
+            platformSupport: ['node', 'browser']
+        },
+        isDefault: true // Recommended default model
+    },
+    // SmolLM2-360M-Instruct - Higher quality instruction-tuned model
+    'HuggingFaceTB/SmolLM2-360M-Instruct': {
+        name: 'HuggingFaceTB/SmolLM2-360M-Instruct',
+        type: 'instruct',
+        version: '1.0.0',
+        description: 'Higher quality instruction-tuned model, slower but more accurate (uses top 5 chunks)',
+        capabilities: {
+            supportsStreaming: true,
+            supportsSystemPrompt: true,
+            instructionTuned: true,
+            maxContextLength: 2048,
+            defaultMaxOutputTokens: 512,
+            recommendedTemperature: 0.1,
+            defaultMaxChunksForContext: 5 // Use top 5 reranked chunks for context
+        },
+        requirements: {
+            transformersJsVersion: '>=3.0.0',
+            minimumMemory: 1024,
+            requiredFeatures: ['text-generation'],
+            platformSupport: ['node', 'browser']
+        },
+        isDefault: false
+    }
+};
+// =============================================================================
+// DEFAULT MODEL
+// =============================================================================
+/** Default generator model name */
+export const DEFAULT_GENERATOR_MODEL = 'HuggingFaceTB/SmolLM2-135M-Instruct';
+// =============================================================================
+// GENERATOR REGISTRY CLASS
+// =============================================================================
+/**
+ * Generator registry class providing validation and model information services
+ */
+export class GeneratorRegistry {
+    /**
+     * Gets generator model information for a given model name
+     * @param modelName - Name of the generator model
+     * @returns Generator model information or null if not supported
+     */
+    static getGeneratorInfo(modelName) {
+        return SUPPORTED_GENERATORS[modelName] || null;
+    }
+    /**
+     * Validates a generator model name and returns compatibility information
+     * @param modelName - Name of the model to validate
+     * @returns Validation result with errors, warnings, and suggestions
+     */
+    static validateGenerator(modelName) {
+        const modelInfo = this.getGeneratorInfo(modelName);
+        if (!modelInfo) {
+            const suggestions = this.getSimilarGenerators(modelName);
+            return {
+                isValid: false,
+                errors: [`Generator model '${modelName}' is not supported`],
+                warnings: [],
+                suggestions: suggestions.length > 0
+                    ? [`Did you mean: ${suggestions.join(', ')}?`]
+                    : [`Available generators: ${this.getSupportedGenerators().join(', ')}`]
+            };
+        }
+        const warnings = [];
+        const suggestions = [];
+        // Memory warnings
+        if (modelInfo.requirements.minimumMemory > 768) {
+            warnings.push(`Model requires ${modelInfo.requirements.minimumMemory}MB memory`);
+        }
+        return {
+            isValid: true,
+            errors: [],
+            warnings,
+            suggestions
+        };
+    }
+    /**
+     * Lists all supported generator models
+     * @param modelType - Optional filter by model type
+     * @returns Array of supported generator model names
+     */
+    static getSupportedGenerators(modelType) {
+        const allModels = Object.keys(SUPPORTED_GENERATORS);
+        if (!modelType) {
+            return allModels;
+        }
+        return allModels.filter(modelName => SUPPORTED_GENERATORS[modelName].type === modelType);
+    }
+    /**
+     * Gets the default generator model name
+     * @returns Default generator model name
+     */
+    static getDefaultGenerator() {
+        return DEFAULT_GENERATOR_MODEL;
+    }
+    /**
+     * Gets generators by type
+     * @param type - Generator type ('causal-lm' or 'instruct')
+     * @returns Array of model names matching the type
+     */
+    static getGeneratorsByType(type) {
+        return Object.keys(SUPPORTED_GENERATORS).filter(modelName => SUPPORTED_GENERATORS[modelName].type === type);
+    }
+    /**
+     * Checks if a generator model supports a specific capability
+     * @param modelName - Name of the model
+     * @param capability - Capability to check
+     * @returns True if the model supports the capability
+     */
+    static supportsCapability(modelName, capability) {
+        const modelInfo = this.getGeneratorInfo(modelName);
+        if (!modelInfo)
+            return false;
+        const value = modelInfo.capabilities[capability];
+        return typeof value === 'boolean' ? value : value !== undefined;
+    }
+    /**
+     * Gets generators similar to the given model name (for suggestions)
+     * @private
+     */
+    static getSimilarGenerators(modelName) {
+        const allModels = Object.keys(SUPPORTED_GENERATORS);
+        const lowerModelName = modelName.toLowerCase();
+        // Simple similarity check based on common substrings
+        const keywords = ['gpt', 'smol', 'lm', 'instruct', 'distil'];
+        const modelKeywords = keywords.filter(keyword => lowerModelName.includes(keyword));
+        return allModels.filter(supportedModel => {
+            const lowerSupported = supportedModel.toLowerCase();
+            return modelKeywords.some(keyword => lowerSupported.includes(keyword));
+        }).slice(0, 3);
+    }
+    /**
+     * Validates system compatibility for a generator model
+     * @param modelName - Name of the model
+     * @param systemCapabilities - System capabilities to check against
+     * @returns Validation result with compatibility information
+     */
+    static validateSystemCompatibility(modelName, systemCapabilities) {
+        const modelInfo = this.getGeneratorInfo(modelName);
+        if (!modelInfo) {
+            return {
+                isValid: false,
+                errors: [`Generator model '${modelName}' is not supported`],
+                warnings: [],
+                suggestions: []
+            };
+        }
+        const errors = [];
+        const warnings = [];
+        const suggestions = [];
+        // Check memory requirements
+        if (systemCapabilities.availableMemory !== undefined) {
+            if (systemCapabilities.availableMemory < modelInfo.requirements.minimumMemory) {
+                errors.push(`Insufficient memory: ${systemCapabilities.availableMemory}MB available, ` +
+                    `${modelInfo.requirements.minimumMemory}MB required`);
+                // Suggest lighter models
+                const lighterModels = this.getSupportedGenerators().filter(name => {
+                    const info = this.getGeneratorInfo(name);
+                    return info &&
+                        info.requirements.minimumMemory <= systemCapabilities.availableMemory;
+                });
+                if (lighterModels.length > 0) {
+                    suggestions.push(`Consider lighter models: ${lighterModels.join(', ')}`);
+                }
+            }
+        }
+        // Check platform compatibility
+        if (systemCapabilities.platform) {
+            if (!modelInfo.requirements.platformSupport.includes(systemCapabilities.platform)) {
+                errors.push(`Platform '${systemCapabilities.platform}' not supported. ` +
+                    `Supported platforms: ${modelInfo.requirements.platformSupport.join(', ')}`);
+            }
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings,
+            suggestions
+        };
+    }
+}
+// =============================================================================
+// UTILITY FUNCTIONS
+// =============================================================================
+/**
+ * Gets the generator type for a given model name
+ * @param modelName - Name of the model
+ * @returns Generator type or null if model not supported
+ */
+export function getGeneratorType(modelName) {
+    const modelInfo = GeneratorRegistry.getGeneratorInfo(modelName);
+    return modelInfo ? modelInfo.type : null;
+}
+/**
+ * Checks if a model is an instruction-tuned model
+ * @param modelName - Name of the model
+ * @returns True if the model is instruction-tuned
+ */
+export function isInstructionTunedModel(modelName) {
+    const modelInfo = GeneratorRegistry.getGeneratorInfo(modelName);
+    return modelInfo ? modelInfo.capabilities.instructionTuned : false;
+}
+/**
+ * Gets the maximum context length for a generator model
+ * @param modelName - Name of the model
+ * @returns Maximum context length or null if model not supported
+ */
+export function getMaxContextLength(modelName) {
+    const modelInfo = GeneratorRegistry.getGeneratorInfo(modelName);
+    return modelInfo ? modelInfo.capabilities.maxContextLength : null;
+}
+/**
+ * Gets recommended generation settings for a model
+ * @param modelName - Name of the model
+ * @returns Recommended settings or null if model not supported
+ */
+export function getRecommendedSettings(modelName) {
+    const modelInfo = GeneratorRegistry.getGeneratorInfo(modelName);
+    if (!modelInfo)
+        return null;
+    return {
+        temperature: modelInfo.capabilities.recommendedTemperature,
+        maxTokens: modelInfo.capabilities.defaultMaxOutputTokens,
+        maxChunksForContext: modelInfo.capabilities.defaultMaxChunksForContext
+    };
+}
+/**
+ * Gets the default maximum chunks for context for a generator model
+ * @param modelName - Name of the model
+ * @returns Default max chunks for context or null if model not supported
+ */
+export function getDefaultMaxChunksForContext(modelName) {
+    const modelInfo = GeneratorRegistry.getGeneratorInfo(modelName);
+    return modelInfo ? modelInfo.capabilities.defaultMaxChunksForContext : null;
+}
+//# sourceMappingURL=generator-registry.js.map

package/dist/esm/core/index.d.ts

@@ -56,4 +56,8 @@ export * from './path-manager.js';
 export { ContentManager, type MemoryContentMetadata, type ContentIngestionResult, type ContentManagerConfig } from './content-manager.js';
 export { ContentResolver, type ContentRequest, type ContentResult } from './content-resolver.js';
 export * from './error-handler.js';
+export { type ResponseGenerator, type GeneratorModelType, type GenerationRequest, type GenerationResult, type GeneratorCapabilities, type GeneratorRequirements, type GeneratorModelInfo, type GeneratorValidationResult, type GeneratorCreationOptions, type GenerateFunction, type CreateGeneratorFunction, GeneratorValidationError, GenerationError, ContextWindowError, supportsStreaming, isInstructModel, createGenerateFunction } from './response-generator.js';
+export { SUPPORTED_GENERATORS, DEFAULT_GENERATOR_MODEL, GeneratorRegistry, getGeneratorType, isInstructionTunedModel, getMaxContextLength, getRecommendedSettings, getDefaultMaxChunksForContext } from './generator-registry.js';
+export { DEFAULT_SYSTEM_PROMPT, DEFAULT_SYSTEM_PROMPT_WITH_ATTRIBUTION, SMOLLM2_CHAT_TEMPLATE, formatContextChunks, buildPrompt, estimateTokenCount, calculateContextBudget, getDefaultStopSequences, type ContextFormattingOptions, type FormattedContext, type PromptBuildOptions, type BuiltPrompt } from './prompt-templates.js';
+export { BaseResponseGenerator, createGeneratorOptions, type GeneratorOptions } from './abstract-generator.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/core/index.js

@@ -66,4 +66,15 @@ export { ContentManager } from './content-manager.js';
 export { ContentResolver } from './content-resolver.js';
 // Error handling framework - supports implementation-specific error contexts
 export * from './error-handler.js';
+// =============================================================================
+// EXPERIMENTAL: Response Generation
+// =============================================================================
+// Response generation types and interfaces (experimental)
+export { GeneratorValidationError, GenerationError, ContextWindowError, supportsStreaming, isInstructModel, createGenerateFunction } from './response-generator.js';
+// Generator registry (experimental)
+export { SUPPORTED_GENERATORS, DEFAULT_GENERATOR_MODEL, GeneratorRegistry, getGeneratorType, isInstructionTunedModel, getMaxContextLength, getRecommendedSettings, getDefaultMaxChunksForContext } from './generator-registry.js';
+// Prompt templates for generation (experimental)
+export { DEFAULT_SYSTEM_PROMPT, DEFAULT_SYSTEM_PROMPT_WITH_ATTRIBUTION, SMOLLM2_CHAT_TEMPLATE, formatContextChunks, buildPrompt, estimateTokenCount, calculateContextBudget, getDefaultStopSequences } from './prompt-templates.js';
+// Abstract base generator (experimental)
+export { BaseResponseGenerator, createGeneratorOptions } from './abstract-generator.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/core/ingestion.js

@@ -340,6 +340,9 @@ export class IngestionPipeline {
             // Phase 5: Vector Index Updates
             console.log('\n--- Phase 5: Vector Index Updates ---');
             await this.updateVectorIndex(embeddingResult.embeddings);
+            // Final save to ensure all vectors are persisted
+            console.log('Performing final index save...');
+            await this.indexManager.saveIndex();
             const endTime = Date.now();
             const processingTimeMs = endTime - startTime;
             const result = {

package/dist/esm/core/knowledge-base-manager.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Knowledge Base Manager
+ *
+ * Provides a unified API for managing the knowledge base (database + vector index).
+ * This module is designed to solve file locking issues on Windows by using
+ * in-place reset operations instead of file deletion.
+ *
+ * Key Features:
+ * - Reset database and index without file deletion (avoids EBUSY/EACCES errors)
+ * - Coordinated reset of both database and index in a single operation
+ * - Connection management to prevent orphaned handles
+ * - Cross-platform compatibility (especially Windows)
+ *
+ * @module knowledge-base-manager
+ */
+import { type DatabaseResetResult } from './db.js';
+/**
+ * Result of a knowledge base reset operation
+ */
+export interface KnowledgeBaseResetResult {
+    /** Whether the overall reset was successful */
+    success: boolean;
+    /** Database reset result */
+    database: DatabaseResetResult;
+    /** Index reset statistics */
+    index: {
+        /** Number of vectors cleared */
+        vectorsCleared: number;
+        /** Time taken for index reset in milliseconds */
+        resetTimeMs: number;
+    };
+    /** Total time for the complete reset operation */
+    totalTimeMs: number;
+    /** Any warnings that occurred during reset */
+    warnings: string[];
+}
+/**
+ * Options for knowledge base reset operation
+ */
+export interface KnowledgeBaseResetOptions {
+    /** Whether to preserve system_info (mode, model configuration) - default: false */
+    preserveSystemInfo?: boolean;
+    /** Whether to run VACUUM after database reset - default: true */
+    runVacuum?: boolean;
+    /** Model name to use for index recreation - default: from config */
+    modelName?: string;
+}
+/**
+ * Knowledge Base Manager
+ *
+ * Manages the complete knowledge base lifecycle including database and vector index.
+ * Provides safe reset operations that avoid file locking issues on Windows.
+ *
+ * @example
+ * ```typescript
+ * // Reset knowledge base for force rebuild
+ * const result = await KnowledgeBaseManager.reset('./db.sqlite', './index.bin');
+ * console.log(`Reset ${result.database.documentsDeleted} documents and ${result.index.vectorsCleared} vectors`);
+ *
+ * // Reset with options
+ * const result = await KnowledgeBaseManager.reset('./db.sqlite', './index.bin', {
+ *   preserveSystemInfo: true,  // Keep mode/model configuration
+ *   modelName: 'all-MiniLM-L6-v2'  // Specify model for index
+ * });
+ * ```
+ */
+export declare class KnowledgeBaseManager {
+    /**
+     * Reset the knowledge base by clearing all data while keeping files intact.
+     * This is a safer alternative to file deletion that avoids file locking issues on Windows.
+     *
+     * The reset operation:
+     * 1. Closes any existing connections via DatabaseConnectionManager
+     * 2. Opens a fresh connection to the database
+     * 3. Deletes all rows from documents, chunks, content_metadata tables
+     * 4. Optionally runs VACUUM to reclaim disk space
+     * 5. Reinitializes the vector index (clears all vectors)
+     * 6. Saves the empty index to disk (overwrites existing file content)
+     *
+     * This approach works because:
+     * - We don't delete files, so no EBUSY/EACCES errors
+     * - The same file handles can be reused or replaced safely
+     * - SQLite transactions ensure data integrity
+     * - Index overwrite uses standard file write operations
+     *
+     * @param dbPath - Path to the SQLite database file
+     * @param indexPath - Path to the vector index file
+     * @param options - Reset options
+     * @returns Promise resolving to reset result statistics
+     *
+     * @throws Error if database or index reset fails
+     */
+    static reset(dbPath: string, indexPath: string, options?: KnowledgeBaseResetOptions): Promise<KnowledgeBaseResetResult>;
+    /**
+     * Check if the knowledge base has any data
+     *
+     * @param dbPath - Path to the SQLite database file
+     * @returns Promise resolving to true if database has data, false if empty
+     */
+    static hasData(dbPath: string): Promise<boolean>;
+    /**
+     * Close all connections to the knowledge base
+     * Useful before operations that might conflict with open handles
+     *
+     * @param dbPath - Path to the SQLite database file
+     */
+    static closeAllConnections(dbPath: string): Promise<void>;
+}
+//# sourceMappingURL=knowledge-base-manager.d.ts.map

package/dist/esm/core/knowledge-base-manager.js

@@ -0,0 +1,256 @@
+/**
+ * Knowledge Base Manager
+ *
+ * Provides a unified API for managing the knowledge base (database + vector index).
+ * This module is designed to solve file locking issues on Windows by using
+ * in-place reset operations instead of file deletion.
+ *
+ * Key Features:
+ * - Reset database and index without file deletion (avoids EBUSY/EACCES errors)
+ * - Coordinated reset of both database and index in a single operation
+ * - Connection management to prevent orphaned handles
+ * - Cross-platform compatibility (especially Windows)
+ *
+ * @module knowledge-base-manager
+ */
+import { openDatabase, resetDatabase, hasDatabaseData } from './db.js';
+import { IndexManager } from '../index-manager.js';
+import { DatabaseConnectionManager } from './database-connection-manager.js';
+import { getModelDefaults, config } from './config.js';
+import { existsSync } from 'fs';
+/**
+ * Knowledge Base Manager
+ *
+ * Manages the complete knowledge base lifecycle including database and vector index.
+ * Provides safe reset operations that avoid file locking issues on Windows.
+ *
+ * @example
+ * ```typescript
+ * // Reset knowledge base for force rebuild
+ * const result = await KnowledgeBaseManager.reset('./db.sqlite', './index.bin');
+ * console.log(`Reset ${result.database.documentsDeleted} documents and ${result.index.vectorsCleared} vectors`);
+ *
+ * // Reset with options
+ * const result = await KnowledgeBaseManager.reset('./db.sqlite', './index.bin', {
+ *   preserveSystemInfo: true,  // Keep mode/model configuration
+ *   modelName: 'all-MiniLM-L6-v2'  // Specify model for index
+ * });
+ * ```
+ */
+export class KnowledgeBaseManager {
+    /**
+     * Reset the knowledge base by clearing all data while keeping files intact.
+     * This is a safer alternative to file deletion that avoids file locking issues on Windows.
+     *
+     * The reset operation:
+     * 1. Closes any existing connections via DatabaseConnectionManager
+     * 2. Opens a fresh connection to the database
+     * 3. Deletes all rows from documents, chunks, content_metadata tables
+     * 4. Optionally runs VACUUM to reclaim disk space
+     * 5. Reinitializes the vector index (clears all vectors)
+     * 6. Saves the empty index to disk (overwrites existing file content)
+     *
+     * This approach works because:
+     * - We don't delete files, so no EBUSY/EACCES errors
+     * - The same file handles can be reused or replaced safely
+     * - SQLite transactions ensure data integrity
+     * - Index overwrite uses standard file write operations
+     *
+     * @param dbPath - Path to the SQLite database file
+     * @param indexPath - Path to the vector index file
+     * @param options - Reset options
+     * @returns Promise resolving to reset result statistics
+     *
+     * @throws Error if database or index reset fails
+     */
+    static async reset(dbPath, indexPath, options = {}) {
+        const startTime = Date.now();
+        const warnings = [];
+        console.log('🔄 Starting knowledge base reset...');
+        console.log(`  Database: ${dbPath}`);
+        console.log(`  Index: ${indexPath}`);
+        // Step 1: Close any existing managed connections to prevent conflicts
+        console.log('\n📡 Step 1: Closing existing connections...');
+        try {
+            if (DatabaseConnectionManager.hasConnection(dbPath)) {
+                await DatabaseConnectionManager.forceCloseConnection(dbPath);
+                console.log('  ✓ Closed existing database connection');
+            }
+            else {
+                console.log('  ✓ No existing connection to close');
+            }
+        }
+        catch (error) {
+            const warning = `Warning: Error closing existing connection: ${error instanceof Error ? error.message : 'Unknown error'}`;
+            warnings.push(warning);
+            console.warn(`  ⚠️ ${warning}`);
+        }
+        // Small delay to ensure handles are fully released
+        await new Promise(resolve => setTimeout(resolve, 50));
+        // Step 2: Reset the database
+        console.log('\n💾 Step 2: Resetting database...');
+        let db = null;
+        let dbResetResult;
+        try {
+            // Open a fresh connection
+            db = await openDatabase(dbPath);
+            // Perform the reset
+            dbResetResult = await resetDatabase(db, {
+                preserveSystemInfo: options.preserveSystemInfo,
+                runVacuum: options.runVacuum
+            });
+            console.log('  ✓ Database reset complete');
+        }
+        catch (error) {
+            console.error('  ❌ Database reset failed:', error);
+            throw new Error(`Failed to reset database: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+        finally {
+            // Close the database connection
+            if (db) {
+                try {
+                    await db.close();
+                }
+                catch (closeError) {
+                    warnings.push(`Warning: Error closing database after reset: ${closeError}`);
+                }
+            }
+        }
+        // Step 3: Reset the vector index
+        console.log('\n📇 Step 3: Resetting vector index...');
+        let indexResetResult;
+        const indexStartTime = Date.now();
+        try {
+            // Determine model and dimensions
+            const modelName = options.modelName || config.embedding_model;
+            const modelDefaults = getModelDefaults(modelName);
+            // Check if index file exists
+            if (!existsSync(indexPath)) {
+                console.log('  Index file does not exist, will be created during ingestion');
+                indexResetResult = {
+                    vectorsCleared: 0,
+                    resetTimeMs: Date.now() - indexStartTime
+                };
+            }
+            else {
+                // Create IndexManager and reset
+                // We need to handle dimension mismatch gracefully since the user might be
+                // switching models (e.g., from MPNet 768D to MiniLM 384D)
+                const indexManager = new IndexManager(indexPath, dbPath, modelDefaults.dimensions, modelName);
+                let previousVectorCount = 0;
+                try {
+                    // Try to initialize with forceRecreate=false first to get the vector count
+                    // skipModelCheck=true since we're resetting anyway
+                    await indexManager.initialize(true, false);
+                    // Get current vector count before reset
+                    previousVectorCount = (await indexManager.hasVectors()) ?
+                        (await indexManager.getStats()).totalVectors : 0;
+                    // Perform the reset
+                    await indexManager.reset();
+                }
+                catch (initError) {
+                    // If initialization failed (e.g., dimension mismatch), force recreate the index
+                    // This handles the case where user is switching models
+                    const errorMessage = initError?.message || String(initError);
+                    if (errorMessage.includes('dimension mismatch') || errorMessage.includes('Vector dimension')) {
+                        console.log('  ⚠️ Dimension mismatch detected - forcing index recreation');
+                        console.log('  (This is expected when switching embedding models)');
+                        // Create a fresh IndexManager and force recreate
+                        const freshIndexManager = new IndexManager(indexPath, dbPath, modelDefaults.dimensions, modelName);
+                        await freshIndexManager.initialize(true, true); // skipModelCheck=true, forceRecreate=true
+                        await freshIndexManager.saveIndex();
+                        await freshIndexManager.close();
+                        // We don't know the previous count since we couldn't load the old index
+                        // But we can estimate it was non-zero since the file existed
+                        previousVectorCount = -1; // Indicate unknown
+                    }
+                    else {
+                        // Re-throw other errors
+                        throw initError;
+                    }
+                }
+                // Close the index manager
+                await indexManager.close();
+                indexResetResult = {
+                    vectorsCleared: previousVectorCount,
+                    resetTimeMs: Date.now() - indexStartTime
+                };
+                console.log('  ✓ Index reset complete');
+            }
+        }
+        catch (error) {
+            console.error('  ❌ Index reset failed:', error);
+            throw new Error(`Failed to reset index: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+        const totalTimeMs = Date.now() - startTime;
+        // Summary
+        console.log('\n✅ Knowledge base reset complete!');
+        console.log(`  Total time: ${totalTimeMs}ms`);
+        console.log(`  Documents deleted: ${dbResetResult.documentsDeleted}`);
+        console.log(`  Chunks deleted: ${dbResetResult.chunksDeleted}`);
+        console.log(`  Vectors cleared: ${indexResetResult.vectorsCleared === -1 ? '(unknown - index recreated due to model change)' : indexResetResult.vectorsCleared}`);
+        if (warnings.length > 0) {
+            console.log(`  Warnings: ${warnings.length}`);
+        }
+        return {
+            success: true,
+            database: dbResetResult,
+            index: indexResetResult,
+            totalTimeMs,
+            warnings
+        };
+    }
+    /**
+     * Check if the knowledge base has any data
+     *
+     * @param dbPath - Path to the SQLite database file
+     * @returns Promise resolving to true if database has data, false if empty
+     */
+    static async hasData(dbPath) {
+        let db = null;
+        try {
+            db = await openDatabase(dbPath);
+            return await hasDatabaseData(db);
+        }
+        catch (error) {
+            // If we can't open the database, assume no data
+            return false;
+        }
+        finally {
+            if (db) {
+                try {
+                    await db.close();
+                }
+                catch {
+                    // Ignore close errors
+                }
+            }
+        }
+    }
+    /**
+     * Close all connections to the knowledge base
+     * Useful before operations that might conflict with open handles
+     *
+     * @param dbPath - Path to the SQLite database file
+     */
+    static async closeAllConnections(dbPath) {
+        console.log('🔒 Closing all knowledge base connections...');
+        try {
+            if (DatabaseConnectionManager.hasConnection(dbPath)) {
+                await DatabaseConnectionManager.forceCloseConnection(dbPath);
+            }
+            // Also close WAL/SHM connections if they exist
+            const sidecars = [`${dbPath}-wal`, `${dbPath}-shm`];
+            for (const sidecar of sidecars) {
+                if (DatabaseConnectionManager.hasConnection(sidecar)) {
+                    await DatabaseConnectionManager.forceCloseConnection(sidecar);
+                }
+            }
+            console.log('✓ All connections closed');
+        }
+        catch (error) {
+            console.warn('⚠️ Error closing connections:', error);
+        }
+    }
+}
+//# sourceMappingURL=knowledge-base-manager.js.map