rag-lite-ts 2.2.0 → 2.3.1

package/dist/cjs/core/db.js

@@ -892,4 +892,109 @@ export async function updateStorageStats(connection, stats) {
         throw new Error(`Failed to update storage stats: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 }
+/**
+ * Reset the database by deleting all data while keeping the schema intact.
+ * This is a safer alternative to file deletion that avoids file locking issues on Windows.
+ *
+ * This function:
+ * 1. Deletes all rows from chunks, documents, content_metadata tables
+ * 2. Optionally clears system_info (mode/model configuration)
+ * 3. Resets storage_stats counters
+ * 4. Optionally runs VACUUM to reclaim disk space
+ *
+ * @param connection - Database connection object
+ * @param options - Reset options
+ * @returns Promise resolving to reset result statistics
+ *
+ * @example
+ * ```typescript
+ * const db = await openDatabase('./db.sqlite');
+ * const result = await resetDatabase(db, { preserveSystemInfo: false });
+ * console.log(`Deleted ${result.documentsDeleted} documents and ${result.chunksDeleted} chunks`);
+ * ```
+ */
+export async function resetDatabase(connection, options = {}) {
+    const startTime = Date.now();
+    const { preserveSystemInfo = false, runVacuum = true } = options;
+    try {
+        console.log('🔄 Starting database reset...');
+        // Get counts before deletion for reporting
+        const docCountResult = await connection.get('SELECT COUNT(*) as count FROM documents');
+        const chunkCountResult = await connection.get('SELECT COUNT(*) as count FROM chunks');
+        const contentMetadataCountResult = await connection.get('SELECT COUNT(*) as count FROM content_metadata');
+        const documentsDeleted = docCountResult?.count || 0;
+        const chunksDeleted = chunkCountResult?.count || 0;
+        const contentMetadataDeleted = contentMetadataCountResult?.count || 0;
+        // Delete in order respecting foreign key constraints
+        // chunks → documents → content_metadata (chunks reference documents, documents reference content_metadata)
+        console.log('  Deleting chunks...');
+        await connection.run('DELETE FROM chunks');
+        console.log('  Deleting documents...');
+        await connection.run('DELETE FROM documents');
+        console.log('  Deleting content_metadata...');
+        await connection.run('DELETE FROM content_metadata');
+        // Reset storage_stats counters
+        console.log('  Resetting storage_stats...');
+        await connection.run(`
+      UPDATE storage_stats SET 
+        content_dir_files = 0,
+        content_dir_size = 0,
+        filesystem_refs = 0,
+        updated_at = CURRENT_TIMESTAMP
+      WHERE id = 1
+    `);
+        // Optionally clear system_info
+        let systemInfoCleared = false;
+        if (!preserveSystemInfo) {
+            console.log('  Clearing system_info...');
+            await connection.run('DELETE FROM system_info WHERE id = 1');
+            systemInfoCleared = true;
+        }
+        else {
+            console.log('  Preserving system_info (mode/model configuration)');
+        }
+        // Run VACUUM to reclaim disk space
+        if (runVacuum) {
+            console.log('  Running VACUUM to reclaim disk space...');
+            await connection.run('VACUUM');
+        }
+        const resetTimeMs = Date.now() - startTime;
+        console.log(`✓ Database reset complete in ${resetTimeMs}ms`);
+        console.log(`  Documents deleted: ${documentsDeleted}`);
+        console.log(`  Chunks deleted: ${chunksDeleted}`);
+        console.log(`  Content metadata deleted: ${contentMetadataDeleted}`);
+        console.log(`  System info cleared: ${systemInfoCleared}`);
+        return {
+            success: true,
+            documentsDeleted,
+            chunksDeleted,
+            contentMetadataDeleted,
+            systemInfoCleared,
+            resetTimeMs
+        };
+    }
+    catch (error) {
+        const resetTimeMs = Date.now() - startTime;
+        console.error(`❌ Database reset failed after ${resetTimeMs}ms:`, error);
+        throw new Error(`Failed to reset database: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Check if the database has any data (documents, chunks, or content)
+ * Useful for determining if a reset is needed
+ *
+ * @param connection - Database connection object
+ * @returns Promise resolving to true if database has data, false if empty
+ */
+export async function hasDatabaseData(connection) {
+    try {
+        const docCount = await connection.get('SELECT COUNT(*) as count FROM documents');
+        const chunkCount = await connection.get('SELECT COUNT(*) as count FROM chunks');
+        return (docCount?.count || 0) > 0 || (chunkCount?.count || 0) > 0;
+    }
+    catch (error) {
+        // If tables don't exist, consider it empty
+        return false;
+    }
+}
 //# sourceMappingURL=db.js.map

package/dist/cjs/core/generator-registry.d.ts

@@ -0,0 +1,114 @@
+/**
+ * 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.
+ */
+import type { GeneratorModelInfo, GeneratorModelType, GeneratorValidationResult, GeneratorCapabilities } from './response-generator.js';
+/**
+ * Registry of supported generator models with their metadata and capabilities
+ */
+export declare const SUPPORTED_GENERATORS: Record<string, GeneratorModelInfo>;
+/** Default generator model name */
+export declare const DEFAULT_GENERATOR_MODEL = "HuggingFaceTB/SmolLM2-135M-Instruct";
+/**
+ * Generator registry class providing validation and model information services
+ */
+export declare 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: string): GeneratorModelInfo | 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: string): GeneratorValidationResult;
+    /**
+     * Lists all supported generator models
+     * @param modelType - Optional filter by model type
+     * @returns Array of supported generator model names
+     */
+    static getSupportedGenerators(modelType?: GeneratorModelType): string[];
+    /**
+     * Gets the default generator model name
+     * @returns Default generator model name
+     */
+    static getDefaultGenerator(): string;
+    /**
+     * Gets generators by type
+     * @param type - Generator type ('causal-lm' or 'instruct')
+     * @returns Array of model names matching the type
+     */
+    static getGeneratorsByType(type: GeneratorModelType): string[];
+    /**
+     * 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: string, capability: keyof GeneratorCapabilities): boolean;
+    /**
+     * Gets generators similar to the given model name (for suggestions)
+     * @private
+     */
+    private static getSimilarGenerators;
+    /**
+     * 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: string, systemCapabilities: {
+        availableMemory?: number;
+        platform?: string;
+        transformersJsVersion?: string;
+    }): GeneratorValidationResult;
+}
+/**
+ * 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 declare function getGeneratorType(modelName: string): GeneratorModelType | 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 declare function isInstructionTunedModel(modelName: string): boolean;
+/**
+ * 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 declare function getMaxContextLength(modelName: string): number | null;
+/**
+ * Gets recommended generation settings for a model
+ * @param modelName - Name of the model
+ * @returns Recommended settings or null if model not supported
+ */
+export declare function getRecommendedSettings(modelName: string): {
+    temperature: number;
+    maxTokens: number;
+    maxChunksForContext: number;
+} | null;
+/**
+ * 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 declare function getDefaultMaxChunksForContext(modelName: string): number | null;
+//# sourceMappingURL=generator-registry.d.ts.map

package/dist/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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