@ebowwa/claudecodehistory 1.6.0 → 1.7.0

package/rust/src/search/query.rs

@@ -1,458 +0,0 @@
-//! Query execution for conversation history search
-//!
-//! Provides high-performance indexed search using Tantivy BM25 scoring.
-
-use tantivy::{
-    collector::TopDocs,
-    query::*,
-    schema::{IndexRecordOption, Schema, Value},
-    Index, Term,
-};
-
-use super::schema::{HistoryFields, extract_project_name, timestamp_to_ms};
-use super::{SearchError, IndexedSearchOptions, AdvancedSearchOptions, SearchResults, SearchResultEntry};
-use crate::types::{ConversationEntry, MessageType};
-
-/// Build a combined query from text query and optional filters
-pub fn build_combined_query(
-    _schema: &Schema,
-    fields: &HistoryFields,
-    query: &str,
-    options: &IndexedSearchOptions,
-) -> Box<dyn tantivy::query::Query> {
-    let mut clauses: Vec<(tantivy::query::Occur, Box<dyn tantivy::query::Query>)> = Vec::new();
-
-    // Build text query from search terms
-    let trimmed = query.trim();
-    if !trimmed.is_empty() {
-        // Split query into terms and create term queries for each
-        let terms: Vec<&str> = trimmed.split_whitespace().collect();
-
-        if !terms.is_empty() {
-            // Use QueryParser for better text search
-            let mut text_clauses: Vec<(tantivy::query::Occur, Box<dyn tantivy::query::Query>)> = Vec::new();
-
-            for term in terms {
-                let term_query = Box::new(TermQuery::new(
-                    Term::from_field_text(fields.all_text, term),
-                    IndexRecordOption::Basic,
-                ));
-                text_clauses.push((tantivy::query::Occur::Should, term_query));
-            }
-
-            // Combine terms with OR (any term can match)
-            let text_query: Box<dyn tantivy::query::Query> = Box::new(BooleanQuery::new(text_clauses));
-            clauses.push((tantivy::query::Occur::Must, text_query));
-        }
-    }
-
-    // Add session filter
-    if let Some(ref session_id) = options.session_id {
-        let session_query = Box::new(TermQuery::new(
-            Term::from_field_text(fields.session_id, session_id),
-            IndexRecordOption::Basic,
-        ));
-        clauses.push((tantivy::query::Occur::Must, session_query));
-    }
-
-    // Add project path filter
-    if let Some(ref project_path) = options.project_path {
-        let project_query = Box::new(TermQuery::new(
-            Term::from_field_text(fields.project_path, project_path),
-            IndexRecordOption::Basic,
-        ));
-        clauses.push((tantivy::query::Occur::Must, project_query));
-    }
-
-    // Add message type filter
-    if let Some(ref message_types) = options.message_types {
-        if !message_types.is_empty() {
-            let mut type_clauses: Vec<(tantivy::query::Occur, Box<dyn tantivy::query::Query>)> = Vec::new();
-
-            for msg_type in message_types {
-                let type_query = Box::new(TermQuery::new(
-                    Term::from_field_text(fields.message_type, msg_type),
-                    IndexRecordOption::Basic,
-                ));
-                type_clauses.push((tantivy::query::Occur::Should, type_query));
-            }
-
-            let types_query: Box<dyn tantivy::query::Query> = Box::new(BooleanQuery::new(type_clauses));
-            clauses.push((tantivy::query::Occur::Must, types_query));
-        }
-    }
-
-    // Return combined query or match-all
-    if clauses.is_empty() {
-        Box::new(AllQuery)
-    } else {
-        Box::new(BooleanQuery::new(clauses))
-    }
-}
-
-/// Execute a search query and return results
-pub fn execute_search(
-    index: &Index,
-    schema: &Schema,
-    query: &str,
-    options: IndexedSearchOptions,
-) -> Result<SearchResults, SearchError> {
-    let start = std::time::Instant::now();
-    let fields = HistoryFields::new(schema);
-
-    let limit = options.limit.unwrap_or(10);
-    let offset = options.offset.unwrap_or(0);
-
-    // Build the query
-    let combined_query = build_combined_query(schema, &fields, query, &options);
-
-    // Create reader and searcher
-    let reader = index.reader()
-        .map_err(|e| SearchError::Query(e.to_string()))?;
-
-    let searcher = reader.searcher();
-
-    // Execute search with pagination
-    let collector = TopDocs::with_limit(limit + offset);
-
-    let top_docs = searcher.search(&combined_query, &collector)
-        .map_err(|e| SearchError::Query(e.to_string()))?;
-
-    // Collect results
-    let mut entries: Vec<SearchResultEntry> = Vec::with_capacity(limit);
-    let mut total_count = 0;
-
-    for (score, doc_address) in top_docs {
-        total_count += 1;
-
-        // Skip offset results
-        if total_count <= offset {
-            continue;
-        }
-
-        // Get document
-        if let Ok(doc) = searcher.doc(doc_address) {
-            if let Some(entry) = doc_to_entry(&doc, schema, &fields, score as f64) {
-                entries.push(entry);
-            }
-        }
-
-        // Stop after limit
-        if entries.len() >= limit {
-            break;
-        }
-    }
-
-    // Calculate index size
-    let index_size_bytes = get_index_size(index);
-
-    Ok(SearchResults {
-        entries,
-        total: total_count,
-        query: query.to_string(),
-        took_ms: start.elapsed().as_millis() as u64,
-        index_size_bytes,
-    })
-}
-
-/// Execute an advanced search with filters
-pub fn execute_advanced_search(
-    index: &Index,
-    schema: &Schema,
-    options: AdvancedSearchOptions,
-) -> Result<SearchResults, SearchError> {
-    let start = std::time::Instant::now();
-    let fields = HistoryFields::new(schema);
-
-    let limit = options.limit.unwrap_or(10);
-    let offset = options.offset.unwrap_or(0);
-
-    let mut clauses: Vec<(tantivy::query::Occur, Box<dyn tantivy::query::Query>)> = Vec::new();
-
-    // Add text query if provided
-    if let Some(ref query) = options.query {
-        let trimmed = query.trim();
-        if !trimmed.is_empty() {
-            let terms: Vec<&str> = trimmed.split_whitespace().collect();
-
-            if !terms.is_empty() {
-                let mut text_clauses: Vec<(tantivy::query::Occur, Box<dyn tantivy::query::Query>)> = Vec::new();
-
-                for term in terms {
-                    let term_query = Box::new(TermQuery::new(
-                        Term::from_field_text(fields.all_text, term),
-                        IndexRecordOption::Basic,
-                    ));
-                    text_clauses.push((tantivy::query::Occur::Should, term_query));
-                }
-
-                let text_query: Box<dyn tantivy::query::Query> = Box::new(BooleanQuery::new(text_clauses));
-                clauses.push((tantivy::query::Occur::Must, text_query));
-            }
-        }
-    }
-
-    // Add session filter
-    if let Some(ref session_id) = options.session_id {
-        let session_query = Box::new(TermQuery::new(
-            Term::from_field_text(fields.session_id, session_id),
-            IndexRecordOption::Basic,
-        ));
-        clauses.push((tantivy::query::Occur::Must, session_query));
-    }
-
-    // Add project path filter
-    if let Some(ref project_path) = options.project_path {
-        let project_query = Box::new(TermQuery::new(
-            Term::from_field_text(fields.project_path, project_path),
-            IndexRecordOption::Basic,
-        ));
-        clauses.push((tantivy::query::Occur::Must, project_query));
-    }
-
-    // Add message type filter
-    if let Some(ref message_types) = options.message_types {
-        if !message_types.is_empty() {
-            let mut type_clauses: Vec<(tantivy::query::Occur, Box<dyn tantivy::query::Query>)> = Vec::new();
-
-            for msg_type in message_types {
-                let type_query = Box::new(TermQuery::new(
-                    Term::from_field_text(fields.message_type, msg_type),
-                    IndexRecordOption::Basic,
-                ));
-                type_clauses.push((tantivy::query::Occur::Should, type_query));
-            }
-
-            let types_query: Box<dyn tantivy::query::Query> = Box::new(BooleanQuery::new(type_clauses));
-            clauses.push((tantivy::query::Occur::Must, types_query));
-        }
-    }
-
-    // Add date range filter
-    if options.start_date.is_some() || options.end_date.is_some() {
-        let start_ts = options.start_date.as_ref().map(|d| timestamp_to_ms(d)).unwrap_or(0);
-        let end_ts = options.end_date.as_ref().map(|d| timestamp_to_ms(d)).unwrap_or(i64::MAX);
-
-        let range_query = Box::new(RangeQuery::new_i64_bounds(
-            "timestamp_ms".to_string(),
-            std::ops::Bound::Included(start_ts),
-            std::ops::Bound::Included(end_ts),
-        ));
-        clauses.push((tantivy::query::Occur::Must, range_query));
-    }
-
-    // Build final query
-    let final_query: Box<dyn tantivy::query::Query> = if clauses.is_empty() {
-        Box::new(AllQuery)
-    } else {
-        Box::new(BooleanQuery::new(clauses))
-    };
-
-    // Create reader and searcher
-    let reader = index.reader()
-        .map_err(|e| SearchError::Query(e.to_string()))?;
-
-    let searcher = reader.searcher();
-
-    // Execute search
-    let collector = TopDocs::with_limit(limit + offset);
-
-    let top_docs = searcher.search(&final_query, &collector)
-        .map_err(|e| SearchError::Query(e.to_string()))?;
-
-    // Filter by min_score if specified
-    let min_score = options.min_score.unwrap_or(0.0);
-
-    // Collect results
-    let mut entries: Vec<SearchResultEntry> = Vec::with_capacity(limit);
-    let mut total_count = 0;
-
-    for (score, doc_address) in top_docs {
-        // Filter by minimum score
-        if (score as f64) < min_score {
-            continue;
-        }
-
-        total_count += 1;
-
-        // Skip offset results
-        if total_count <= offset {
-            continue;
-        }
-
-        // Get document
-        if let Ok(doc) = searcher.doc(doc_address) {
-            if let Some(entry) = doc_to_entry(&doc, schema, &fields, score as f64) {
-                entries.push(entry);
-            }
-        }
-
-        // Stop after limit
-        if entries.len() >= limit {
-            break;
-        }
-    }
-
-    // Calculate index size
-    let index_size_bytes = get_index_size(index);
-
-    Ok(SearchResults {
-        entries,
-        total: total_count,
-        query: options.query.unwrap_or_default(),
-        took_ms: start.elapsed().as_millis() as u64,
-        index_size_bytes,
-    })
-}
-
-/// Convert a Tantivy document to a SearchResultEntry
-fn doc_to_entry(
-    doc: &tantivy::TantivyDocument,
-    _schema: &Schema,
-    fields: &HistoryFields,
-    score: f64,
-) -> Option<SearchResultEntry> {
-    // Extract required fields
-    let uuid = doc.get_first(fields.uuid)
-        .and_then(|v| v.as_str().map(|s| s.to_string()))?;
-
-    let session_id = doc.get_first(fields.session_id)
-        .and_then(|v| v.as_str().map(|s| s.to_string()))?;
-
-    let project_path = doc.get_first(fields.project_path)
-        .and_then(|v| v.as_str().map(|s| s.to_string()))?;
-
-    let content = doc.get_first(fields.content)
-        .and_then(|v| v.as_str().map(|s| s.to_string()))?;
-
-    let message_type_str = doc.get_first(fields.message_type)
-        .and_then(|v| v.as_str().map(|s| s.to_string()))
-        .unwrap_or_else(|| "user".to_string());
-
-    let entry_type = MessageType::from(message_type_str.as_str());
-
-    // Extract timestamp - convert back to ISO string
-    let timestamp_ms = doc.get_first(fields.timestamp_ms)
-        .and_then(|v| v.as_i64())
-        .unwrap_or(0);
-
-    let timestamp = if timestamp_ms > 0 {
-        chrono::DateTime::from_timestamp_millis(timestamp_ms)
-            .map(|dt| dt.to_rfc3339())
-            .unwrap_or_else(|| "".to_string())
-    } else {
-        "".to_string()
-    };
-
-    // Build metadata from optional fields
-    let metadata = {
-        let model = doc.get_first(fields.model)
-            .and_then(|v| v.as_str().map(|s| s.to_string()));
-
-        let request_id = doc.get_first(fields.request_id)
-            .and_then(|v| v.as_str().map(|s| s.to_string()));
-
-        let cost_usd = doc.get_first(fields.cost_usd)
-            .and_then(|v| v.as_f64());
-
-        let duration_ms = doc.get_first(fields.duration_ms)
-            .and_then(|v| v.as_i64())
-            .map(|v| v as u64);
-
-        let is_error = doc.get_first(fields.is_error)
-            .and_then(|v| v.as_bool());
-
-        if model.is_some() || request_id.is_some() || cost_usd.is_some() || duration_ms.is_some() || is_error.is_some() {
-            Some(crate::types::EntryMetadata {
-                usage: None,
-                total_cost_usd: cost_usd,
-                num_turns: None,
-                duration_ms,
-                is_error,
-                error_type: None,
-                model,
-                request_id,
-            })
-        } else {
-            None
-        }
-    };
-
-    // Build conversation entry
-    let entry = ConversationEntry {
-        uuid,
-        session_id,
-        timestamp,
-        project_path: project_path.clone(),
-        entry_type,
-        content,
-        formatted_time: None,
-        time_ago: None,
-        local_date: None,
-        metadata,
-        project_name: Some(extract_project_name(&project_path)),
-    };
-
-    Some(SearchResultEntry {
-        entry,
-        score,
-        highlights: Vec::new(), // TODO: Add highlighting support
-    })
-}
-
-/// Get the size of the index directory in bytes
-/// Note: In Tantivy 0.22, ManagedDirectory doesn't expose path()
-/// This function returns 0 as a placeholder - index size can be tracked separately
-fn get_index_size(_index: &Index) -> u64 {
-    // Tantivy 0.22 doesn't expose directory path through ManagedDirectory
-    // Index size tracking would need to be done at a higher level
-    0
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use super::super::create_history_schema;
-
-    #[test]
-    fn test_build_combined_query_empty() {
-        let schema = create_history_schema();
-        let fields = HistoryFields::new(&schema);
-        let options = IndexedSearchOptions::default();
-
-        let query = build_combined_query(&schema, &fields, "", &options);
-
-        // Empty query should return match-all
-        assert!(format!("{:?}", query).contains("AllQuery"));
-    }
-
-    #[test]
-    fn test_build_combined_query_with_text() {
-        let schema = create_history_schema();
-        let fields = HistoryFields::new(&schema);
-        let options = IndexedSearchOptions::default();
-
-        let query = build_combined_query(&schema, &fields, "hello world", &options);
-
-        // Should contain BooleanQuery with terms
-        let query_str = format!("{:?}", query);
-        assert!(query_str.contains("Boolean") || query_str.contains("Term"));
-    }
-
-    #[test]
-    fn test_build_combined_query_with_filters() {
-        let schema = create_history_schema();
-        let fields = HistoryFields::new(&schema);
-        let options = IndexedSearchOptions {
-            session_id: Some("test-session".to_string()),
-            project_path: Some("/test/project".to_string()),
-            ..Default::default()
-        };
-
-        let query = build_combined_query(&schema, &fields, "test", &options);
-
-        // Should contain filters
-        let query_str = format!("{:?}", query);
-        assert!(query_str.contains("Boolean") || query_str.contains("Term"));
-    }
-}

package/rust/src/search/schema.rs

@@ -1,115 +0,0 @@
-//! Schema definitions for conversation history search index
-
-use tantivy::schema::*;
-
-/// Create the schema for conversation history search
-pub fn create_history_schema() -> Schema {
-    let mut schema_builder = Schema::builder();
-
-    // Primary identifiers
-    schema_builder.add_text_field("uuid", STRING | STORED);
-    schema_builder.add_text_field("session_id", STRING | STORED | FAST);
-    schema_builder.add_text_field("project_path", STRING | STORED | FAST);
-
-    // Message type and role
-    schema_builder.add_text_field("message_type", STRING | STORED | FAST);
-    schema_builder.add_text_field("role", STRING | STORED | FAST);
-
-    // Timestamp for range queries
-    schema_builder.add_i64_field("timestamp_ms", STORED | FAST | INDEXED);
-
-    // Content fields
-    schema_builder.add_text_field("content", TEXT | STORED);
-    schema_builder.add_text_field("all_text", TEXT); // Combined searchable field
-
-    // Metadata
-    schema_builder.add_text_field("model", STRING | STORED);
-    schema_builder.add_text_field("request_id", STRING | STORED | FAST);
-    schema_builder.add_f64_field("cost_usd", STORED | FAST);
-    schema_builder.add_i64_field("duration_ms", STORED | FAST | INDEXED);
-    schema_builder.add_bool_field("is_error", STORED | FAST);
-
-    // Project name for faceted search
-    schema_builder.add_text_field("project_name", STRING | STORED | FAST);
-
-    schema_builder.build()
-}
-
-/// Field accessors for the history schema
-pub struct HistoryFields {
-    pub uuid: Field,
-    pub session_id: Field,
-    pub project_path: Field,
-    pub message_type: Field,
-    pub role: Field,
-    pub timestamp_ms: Field,
-    pub content: Field,
-    pub all_text: Field,
-    pub model: Field,
-    pub request_id: Field,
-    pub cost_usd: Field,
-    pub duration_ms: Field,
-    pub is_error: Field,
-    pub project_name: Field,
-}
-
-impl HistoryFields {
-    /// Create field accessors from a schema
-    pub fn new(schema: &Schema) -> Self {
-        Self {
-            uuid: schema.get_field("uuid").expect("uuid field missing"),
-            session_id: schema.get_field("session_id").expect("session_id field missing"),
-            project_path: schema.get_field("project_path").expect("project_path field missing"),
-            message_type: schema.get_field("message_type").expect("message_type field missing"),
-            role: schema.get_field("role").expect("role field missing"),
-            timestamp_ms: schema.get_field("timestamp_ms").expect("timestamp_ms field missing"),
-            content: schema.get_field("content").expect("content field missing"),
-            all_text: schema.get_field("all_text").expect("all_text field missing"),
-            model: schema.get_field("model").expect("model field missing"),
-            request_id: schema.get_field("request_id").expect("request_id field missing"),
-            cost_usd: schema.get_field("cost_usd").expect("cost_usd field missing"),
-            duration_ms: schema.get_field("duration_ms").expect("duration_ms field missing"),
-            is_error: schema.get_field("is_error").expect("is_error field missing"),
-            project_name: schema.get_field("project_name").expect("project_name field missing"),
-        }
-    }
-}
-
-/// Convert timestamp string to milliseconds since epoch
-pub fn timestamp_to_ms(ts: &str) -> i64 {
-    chrono::DateTime::parse_from_rfc3339(ts)
-        .map(|dt| dt.timestamp_millis())
-        .unwrap_or(0)
-}
-
-/// Extract project name from path
-pub fn extract_project_name(project_path: &str) -> String {
-    project_path
-        .split('/')
-        .last()
-        .unwrap_or(project_path)
-        .to_string()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_schema_creation() {
-        let schema = create_history_schema();
-        assert!(schema.get_field("uuid").is_ok());
-        assert!(schema.get_field("content").is_ok());
-        assert!(schema.get_field("session_id").is_ok());
-    }
-
-    #[test]
-    fn test_fields_access() {
-        let schema = create_history_schema();
-        let fields = HistoryFields::new(&schema);
-
-        // Verify all fields are accessible
-        assert!(schema.get_field_name(fields.uuid) == "uuid");
-        assert!(schema.get_field_name(fields.content) == "content");
-    }
-}