/**
 * Semantic Search Interface
 * Combines vector store and embedding generation for conversation search
 */
import type { SQLiteManager } from "../storage/SQLiteManager.js";
import type { Message, Conversation } from "../parsers/ConversationParser.js";
import type { Decision } from "../parsers/DecisionExtractor.js";
import type { Mistake } from "../parsers/MistakeExtractor.js";
export interface SearchFilter {
    date_range?: [number, number];
    message_type?: string[];
    conversation_id?: string;
}
export interface SearchResult {
    message: Message;
    conversation: Conversation;
    similarity: number;
    snippet: string;
}
export interface DecisionSearchResult {
    decision: Decision;
    conversation: Conversation;
    similarity: number;
}
export interface MistakeSearchResult {
    mistake: Mistake;
    conversation: Conversation;
    similarity: number;
}
export declare class SemanticSearch {
    private vectorStore;
    private db;
    constructor(sqliteManager: SQLiteManager);
    /**
     * Index all messages for semantic search
     * Uses chunking for long messages that exceed the embedding model's token limit
     * @param messages - Messages to index
     * @param incremental - If true, skip messages that already have embeddings (default: true for fast re-indexing)
     */
    indexMessages(messages: Array<{
        id: number;
        content?: string;
    }>, incremental?: boolean): Promise<void>;
    /**
     * Index messages using chunking for long content
     */
    private indexMessagesWithChunking;
    /**
     * Index decisions for semantic search
     * @param decisions - Decisions to index
     * @param incremental - If true, skip decisions that already have embeddings (default: true for fast re-indexing)
     */
    indexDecisions(decisions: Array<{
        id: number;
        decision_text: string;
        rationale?: string;
        context?: string | null;
    }>, incremental?: boolean): Promise<void>;
    /**
     * Index all decisions in the database that don't have embeddings.
     * This catches decisions that were stored before embeddings were available.
     */
    indexMissingDecisionEmbeddings(): Promise<number>;
    /**
     * Index mistakes for semantic search
     * @param mistakes - Mistakes to index
     * @param incremental - If true, skip mistakes that already have embeddings (default: true)
     */
    indexMistakes(mistakes: Array<{
        id: number;
        what_went_wrong: string;
        correction?: string | null;
        mistake_type: string;
    }>, incremental?: boolean): Promise<void>;
    /**
     * Index all mistakes in the database that don't have embeddings.
     * This catches mistakes that were stored before embeddings were available.
     */
    indexMissingMistakeEmbeddings(): Promise<number>;
    /**
     * Search for mistakes using semantic search
     */
    searchMistakes(query: string, limit?: number): Promise<MistakeSearchResult[]>;
    /**
     * Search conversations using natural language query
     * Uses chunk search for better coverage of long messages
     * @param query - The search query text
     * @param limit - Maximum results to return
     * @param filter - Optional filter criteria
     * @param precomputedEmbedding - Optional pre-computed embedding to avoid re-embedding
     */
    searchConversations(query: string, limit?: number, filter?: SearchFilter, precomputedEmbedding?: Float32Array): Promise<SearchResult[]>;
    /**
     * Search using chunk aggregation for better coverage of long messages
     * Now includes hybrid re-ranking with FTS results
     */
    private searchWithChunkAggregation;
    /**
     * Get message IDs from FTS search (for re-ranking)
     */
    private getFtsMessageIds;
    /**
     * Calculate dynamic similarity threshold based on query length
     * Longer queries should have higher thresholds (more context = better matching)
     */
    private calculateDynamicThreshold;
    /**
     * Search for decisions
     */
    searchDecisions(query: string, limit?: number): Promise<DecisionSearchResult[]>;
    /**
     * Sanitize query for FTS5 MATCH syntax.
     * FTS5 has special characters that need escaping: . * " - + ( ) OR AND NOT
     * We wrap each word in double quotes to treat them as literal strings.
     */
    private sanitizeFtsQuery;
    /**
     * Fallback to full-text search when embeddings unavailable
     */
    private fallbackFullTextSearch;
    /**
     * Fallback decision search
     */
    private fallbackDecisionSearch;
    /**
     * Fallback mistake search using FTS
     */
    private fallbackMistakeSearch;
    /**
     * Apply filter to message
     */
    private applyFilter;
    /**
     * Snippet generator instance
     */
    private snippetGenerator;
    /**
     * Generate snippet from content using advanced snippet generation
     */
    private generateSnippet;
    /**
     * Get message by ID
     */
    private getMessage;
    /**
     * Get conversation by ID
     */
    private getConversation;
    /**
     * Get search statistics
     */
    getStats(): {
        total_embeddings: number;
        vec_enabled: boolean;
        model_info: Record<string, unknown>;
    };
}
//# sourceMappingURL=SemanticSearch.d.ts.map