/**
 * Persistent storage implementation using SQLite + Drizzle ORM (LibSQL WASM-compatible)
 * Now supports chunk-level indexing for better search granularity
 */
import { type DbConfig } from './db/client.js';
import type { CodebaseFile, Storage } from './storage.js';
/**
 * Chunk data for storage
 */
export interface ChunkData {
    content: string;
    type: string;
    startLine: number;
    endLine: number;
    metadata?: Record<string, unknown>;
}
/**
 * Stored chunk with ID
 */
export interface StoredChunk extends ChunkData {
    id: number;
    fileId: number;
    filePath: string;
}
export declare class PersistentStorage implements Storage {
    private dbInstance;
    private initPromise;
    constructor(config?: DbConfig);
    private initialize;
    /**
     * Ensure database is initialized before operations
     */
    private ensureInit;
    /**
     * Get the LibSQL client for raw SQL operations
     */
    private get client();
    /**
     * Store a file
     */
    storeFile(file: CodebaseFile): Promise<void>;
    /**
     * Store multiple files in a single transaction (batch operation)
     * Much faster than storing one by one for large datasets
     */
    storeFiles(files: CodebaseFile[]): Promise<void>;
    /**
     * Get a file by path
     */
    getFile(path: string): Promise<CodebaseFile | null>;
    /**
     * Get all files
     */
    getAllFiles(): Promise<CodebaseFile[]>;
    /**
     * Delete a file
     */
    deleteFile(path: string): Promise<void>;
    /**
     * Clear all files
     */
    clear(): Promise<void>;
    /**
     * Store chunks for a file (replaces existing chunks)
     */
    storeChunks(filePath: string, chunks: ChunkData[]): Promise<number[]>;
    /**
     * Store chunks for multiple files in batch
     */
    storeManyChunks(fileChunks: Array<{
        filePath: string;
        chunks: ChunkData[];
    }>): Promise<Map<string, number[]>>;
    /**
     * Get chunks for a file
     */
    getChunksForFile(filePath: string): Promise<StoredChunk[]>;
    /**
     * Get total chunk count
     */
    getChunkCount(): Promise<number>;
    /**
     * Get file count
     */
    count(): Promise<number>;
    /**
     * Check if file exists
     */
    exists(path: string): Promise<boolean>;
    /**
     * Store document vectors (TF-IDF) for a CHUNK
     */
    storeChunkVectors(chunkId: number, terms: Map<string, {
        tf: number;
        tfidf: number;
        rawFreq: number;
    }>, tokenCount?: number): Promise<void>;
    /**
     * Store document vectors for multiple CHUNKS in a single transaction (batch operation)
     * Much faster than storing one by one for large datasets
     */
    storeManyChunkVectors(chunkVectors: Array<{
        chunkId: number;
        terms: Map<string, {
            tf: number;
            tfidf: number;
            rawFreq: number;
        }>;
        tokenCount?: number;
    }>): Promise<void>;
    /**
     * Store IDF scores
     */
    storeIdfScores(idf: Map<string, number>, docFreq: Map<string, number>): Promise<void>;
    /**
     * Get IDF scores
     */
    getIdfScores(): Promise<Map<string, number>>;
    /**
     * Get document vectors for a chunk
     */
    getChunkVectors(chunkId: number): Promise<Map<string, {
        tf: number;
        tfidf: number;
        rawFreq: number;
    }> | null>;
    /**
     * Get all chunk vectors in a single batch query (CPU + Memory optimization)
     * Avoids N+1 query pattern when loading index from storage
     * Returns Map<chunkId, Map<term, {tf, tfidf, rawFreq}>>
     */
    getAllChunkVectors(): Promise<Map<number, Map<string, {
        tf: number;
        tfidf: number;
        rawFreq: number;
    }>>>;
    /**
     * Search chunks by terms using SQL (Memory optimization)
     * Returns matching chunks with their content for direct display
     * Uses pre-computed magnitude from chunks table
     */
    searchByTerms(queryTerms: string[], options?: {
        limit?: number;
    }): Promise<Array<{
        chunkId: number;
        filePath: string;
        content: string;
        type: string;
        startLine: number;
        endLine: number;
        matchedTerms: Map<string, {
            tfidf: number;
            rawFreq: number;
        }>;
        magnitude: number;
        tokenCount: number;
    }>>;
    /**
     * Get IDF scores for specific terms only (Memory optimization)
     */
    getIdfScoresForTerms(terms: string[]): Promise<Map<string, number>>;
    /**
     * Get total chunk count (for IDF calculation)
     * BM25/TF-IDF now operates at chunk level, not file level
     */
    getTotalDocuments(): Promise<number>;
    /**
     * Get all file metadata (path, mtime, hash) without content
     * Used for incremental diff detection
     */
    getAllFileMetadata(): Promise<Map<string, {
        mtime: number;
        hash: string;
    }>>;
    /**
     * Delete multiple files in a single transaction (batch operation)
     */
    deleteFiles(paths: string[]): Promise<void>;
    /**
     * Store metadata
     */
    setMetadata(key: string, value: string): Promise<void>;
    /**
     * Get metadata
     */
    getMetadata(key: string): Promise<string | null>;
    /**
     * Get average chunk length (token count) for BM25 scoring
     * Returns cached value from metadata if available, otherwise calculates from chunks table
     */
    getAverageDocLength(): Promise<number>;
    /**
     * Update average chunk length in metadata (call after indexing)
     */
    updateAverageDocLength(): Promise<number>;
    /**
     * Rebuild IDF scores from document vectors using SQL (Memory optimization)
     * Calculates document frequency for each term across CHUNKS and computes IDF
     */
    rebuildIdfScoresFromVectors(): Promise<void>;
    /**
     * Recalculate TF-IDF scores for all documents using current IDF values (Memory optimization)
     * Updates document_vectors.tfidf = document_vectors.tf * idf_scores.idf
     */
    recalculateTfidfScores(): Promise<void>;
    /**
     * Update pre-computed magnitude for all chunks (Memory optimization for search)
     * magnitude = sqrt(sum(tfidf^2)) for each chunk
     * Called after TF-IDF recalculation to keep magnitude in sync
     */
    updateChunkMagnitudes(): Promise<void>;
    /**
     * Get terms for chunks of files (for tracking affected terms during incremental updates)
     * When files are deleted, we need to know which terms were affected
     */
    getTermsForFiles(paths: string[]): Promise<Set<string>>;
    /**
     * Get all chunks with their file paths (for bulk operations)
     */
    getAllChunks(): Promise<StoredChunk[]>;
    /**
     * Close database connection
     */
    close(): void;
}
//# sourceMappingURL=storage-persistent.d.ts.map