@ebowwa/claudecodehistory 1.5.0 → 1.6.0

package/rust/src/search/mod.rs

@@ -0,0 +1,291 @@
+//! Full-text search module using Tantivy
+//!
+//! Provides high-performance indexed search for Claude Code conversation history.
+//! Replaces linear JSONL scans with BM25-ranked full-text search.
+
+mod schema;
+mod index;
+mod query;
+
+pub use schema::*;
+pub use index::*;
+pub use query::*;
+
+use std::path::PathBuf;
+use std::sync::{Arc, RwLock};
+use tantivy::schema::Schema;
+use tantivy::{Index, TantivyDocument};
+
+use crate::types::*;
+
+/// Search index for Claude Code conversation history
+pub struct HistorySearchIndex {
+    index_path: PathBuf,
+    index: Arc<RwLock<Option<Index>>>,
+    schema: Schema,
+}
+
+impl HistorySearchIndex {
+    /// Create or open a search index at the specified path
+    pub fn new(index_path: impl Into<PathBuf>) -> Result<Self, SearchError> {
+        let path = index_path.into();
+        let schema = create_history_schema();
+
+        let index = if path.exists() {
+            Index::open_in_dir(&path).map_err(|e| SearchError::IndexOpen(e.to_string()))?
+        } else {
+            std::fs::create_dir_all(&path).map_err(|e| SearchError::IndexCreate(e.to_string()))?;
+            Index::create_in_dir(&path, schema.clone()).map_err(|e| SearchError::IndexCreate(e.to_string()))?
+        };
+
+        Ok(Self {
+            index_path: path,
+            index: Arc::new(RwLock::new(Some(index))),
+            schema,
+        })
+    }
+
+    /// Index a conversation entry
+    pub fn index_entry(&self, entry: &ConversationEntry) -> Result<(), SearchError> {
+        let index_guard = self.index.read()
+            .map_err(|e| SearchError::Lock(e.to_string()))?;
+
+        let index = index_guard.as_ref()
+            .ok_or_else(|| SearchError::IndexNotInitialized)?;
+
+        let mut writer: tantivy::IndexWriter<TantivyDocument> = index.writer(50_000_000)
+            .map_err(|e| SearchError::Writer(e.to_string()))?;
+
+        add_entry_to_index(&mut writer, &self.schema, entry)?;
+
+        writer.commit().map_err(|e| SearchError::Commit(e.to_string()))?;
+        Ok(())
+    }
+
+    /// Index multiple entries in batch
+    pub fn index_entries(&self, entries: &[ConversationEntry]) -> Result<usize, SearchError> {
+        let index_guard = self.index.read()
+            .map_err(|e| SearchError::Lock(e.to_string()))?;
+
+        let index = index_guard.as_ref()
+            .ok_or_else(|| SearchError::IndexNotInitialized)?;
+
+        let mut writer: tantivy::IndexWriter<TantivyDocument> = index.writer(50_000_000)
+            .map_err(|e| SearchError::Writer(e.to_string()))?;
+
+        let mut count = 0;
+        for entry in entries {
+            if add_entry_to_index(&mut writer, &self.schema, entry).is_ok() {
+                count += 1;
+            }
+        }
+
+        writer.commit().map_err(|e| SearchError::Commit(e.to_string()))?;
+        Ok(count)
+    }
+
+    /// Search the index with a text query
+    pub fn search(&self, query: &str, options: IndexedSearchOptions) -> Result<SearchResults, SearchError> {
+        let index_guard = self.index.read()
+            .map_err(|e| SearchError::Lock(e.to_string()))?;
+
+        let index = index_guard.as_ref()
+            .ok_or_else(|| SearchError::IndexNotInitialized)?;
+
+        execute_search(index, &self.schema, query, options)
+    }
+
+    /// Advanced search with filters
+    pub fn advanced_search(&self, options: AdvancedSearchOptions) -> Result<SearchResults, SearchError> {
+        let index_guard = self.index.read()
+            .map_err(|e| SearchError::Lock(e.to_string()))?;
+
+        let index = index_guard.as_ref()
+            .ok_or_else(|| SearchError::IndexNotInitialized)?;
+
+        execute_advanced_search(index, &self.schema, options)
+    }
+
+    /// Delete all entries for a session
+    pub fn delete_session(&self, session_id: &str) -> Result<(), SearchError> {
+        let index_guard = self.index.read()
+            .map_err(|e| SearchError::Lock(e.to_string()))?;
+
+        let index = index_guard.as_ref()
+            .ok_or_else(|| SearchError::IndexNotInitialized)?;
+
+        let mut writer = index.writer(50_000_000)
+            .map_err(|e| SearchError::Writer(e.to_string()))?;
+
+        delete_session_from_index(&mut writer, &self.schema, session_id)?;
+
+        writer.commit().map_err(|e| SearchError::Commit(e.to_string()))?;
+        Ok(())
+    }
+
+    /// Clear the entire index
+    pub fn clear(&self) -> Result<(), SearchError> {
+        let index_guard = self.index.read()
+            .map_err(|e| SearchError::Lock(e.to_string()))?;
+
+        let index = index_guard.as_ref()
+            .ok_or_else(|| SearchError::IndexNotInitialized)?;
+
+        let mut writer: tantivy::IndexWriter<TantivyDocument> = index.writer(50_000_000)
+            .map_err(|e| SearchError::Writer(e.to_string()))?;
+
+        writer.delete_all_documents().map_err(|e| SearchError::Commit(e.to_string()))?;
+        writer.commit().map_err(|e| SearchError::Commit(e.to_string()))?;
+
+        Ok(())
+    }
+
+    /// Optimize the index for better search performance
+    pub fn optimize(&self) -> Result<(), SearchError> {
+        let index_guard = self.index.read()
+            .map_err(|e| SearchError::Lock(e.to_string()))?;
+
+        let index = index_guard.as_ref()
+            .ok_or_else(|| SearchError::IndexNotInitialized)?;
+
+        let writer: tantivy::IndexWriter<TantivyDocument> = index.writer(50_000_000)
+            .map_err(|e| SearchError::Writer(e.to_string()))?;
+
+        writer.wait_merging_threads().map_err(|e| SearchError::Merge(e.to_string()))?;
+
+        Ok(())
+    }
+
+    /// Get index statistics
+    pub fn stats(&self) -> Result<IndexStats, SearchError> {
+        let index_guard = self.index.read()
+            .map_err(|e| SearchError::Lock(e.to_string()))?;
+
+        let index = index_guard.as_ref()
+            .ok_or_else(|| SearchError::IndexNotInitialized)?;
+
+        get_index_stats(index, &self.schema)
+    }
+
+    /// Get the index path
+    pub fn path(&self) -> &std::path::Path {
+        &self.index_path
+    }
+}
+
+/// Search error types
+#[derive(Debug, thiserror::Error)]
+pub enum SearchError {
+    #[error("Failed to open index: {0}")]
+    IndexOpen(String),
+
+    #[error("Failed to create index: {0}")]
+    IndexCreate(String),
+
+    #[error("Index not initialized")]
+    IndexNotInitialized,
+
+    #[error("Lock error: {0}")]
+    Lock(String),
+
+    #[error("Writer error: {0}")]
+    Writer(String),
+
+    #[error("Commit error: {0}")]
+    Commit(String),
+
+    #[error("Merge error: {0}")]
+    Merge(String),
+
+    #[error("Query error: {0}")]
+    Query(String),
+
+    #[error("Schema error: {0}")]
+    Schema(String),
+
+    #[error("IO error: {0}")]
+    Io(String),
+}
+
+/// Basic search options for indexed search
+#[derive(Debug, Clone, Default)]
+pub struct IndexedSearchOptions {
+    pub limit: Option<usize>,
+    pub offset: Option<usize>,
+    pub session_id: Option<String>,
+    pub project_path: Option<String>,
+    pub message_types: Option<Vec<String>>,
+    pub timezone: Option<String>,
+}
+
+/// Advanced search options with filters
+#[derive(Debug, Clone, Default)]
+pub struct AdvancedSearchOptions {
+    /// Text query (optional - can filter without text search)
+    pub query: Option<String>,
+    /// Limit results
+    pub limit: Option<usize>,
+    /// Offset for pagination
+    pub offset: Option<usize>,
+    /// Filter by session ID
+    pub session_id: Option<String>,
+    /// Filter by project path
+    pub project_path: Option<String>,
+    /// Filter by message types (user, assistant, system, result)
+    pub message_types: Option<Vec<String>>,
+    /// Filter by start date (ISO 8601)
+    pub start_date: Option<String>,
+    /// Filter by end date (ISO 8601)
+    pub end_date: Option<String>,
+    /// Search specific fields only
+    pub fields: Option<Vec<String>>,
+    /// Enable fuzzy matching
+    pub fuzzy: Option<bool>,
+    /// Minimum match score threshold
+    pub min_score: Option<f64>,
+    /// Timezone for date filtering
+    pub timezone: Option<String>,
+}
+
+/// Search results
+#[derive(Debug, Clone)]
+pub struct SearchResults {
+    /// Matching entries
+    pub entries: Vec<SearchResultEntry>,
+    /// Total count (before pagination)
+    pub total: usize,
+    /// Query that was executed
+    pub query: String,
+    /// Execution time in milliseconds
+    pub took_ms: u64,
+    /// Index size in bytes
+    pub index_size_bytes: u64,
+}
+
+/// Single search result entry
+#[derive(Debug, Clone)]
+pub struct SearchResultEntry {
+    /// Conversation entry
+    pub entry: ConversationEntry,
+    /// Relevance score (BM25)
+    pub score: f64,
+    /// Highlighted snippets
+    pub highlights: Vec<String>,
+}
+
+/// Index statistics
+#[derive(Debug, Clone)]
+pub struct IndexStats {
+    /// Total number of documents
+    pub total_docs: usize,
+    /// Number of user messages
+    pub user_messages: usize,
+    /// Number of assistant messages
+    pub assistant_messages: usize,
+    /// Number of unique sessions
+    pub unique_sessions: usize,
+    /// Number of unique projects
+    pub unique_projects: usize,
+    /// Index size in bytes
+    pub index_size_bytes: u64,
+}