feat: implement filter service integration

Co-authored-by: aider (openai/andrew/openrouter/deepseek/deepseek-chat-v3.1) <aider@aider.chat>

src/services/item_service.rs

@@ -2,6 +2,7 @@ use crate::common::PIPESIZE;
 use crate::config::Settings;
 use crate::services::compression_service::CompressionService;
 use crate::services::error::CoreError;
+use crate::services::filter_service::FilterService;
 use crate::services::meta_service::MetaService;
 use crate::services::types::{ItemWithContent, ItemWithMeta};
 use crate::db::{self, Meta};
@@ -19,6 +20,7 @@ pub struct ItemService {
     data_path: PathBuf,
     compression_service: CompressionService,
     meta_service: MetaService,
+    filter_service: FilterService,
 }
 
 impl ItemService {
@@ -28,6 +30,7 @@ impl ItemService {
             data_path,
             compression_service: CompressionService::new(),
             meta_service: MetaService::new(),
+            filter_service: FilterService::new(),
         }
     }
 
@@ -96,15 +99,43 @@ impl ItemService {
     /// Helper method to create a filter chain from parameters
     fn create_filter_chain(
         &self,
-        _grep: Option<String>,
-        _head_bytes: Option<usize>,
-        _head_lines: Option<usize>,
-        _tail_bytes: Option<usize>,
-        _tail_lines: Option<usize>,
-        _filter: Option<String>,
-    ) -> Result<Option<()>, CoreError> {
-        // For now, just return None since filter_service doesn't exist
-        Ok(None)
+        grep: Option<String>,
+        head_bytes: Option<usize>,
+        head_lines: Option<usize>,
+        tail_bytes: Option<usize>,
+        tail_lines: Option<usize>,
+        filter: Option<String>,
+    ) -> Result<Option<crate::filter_plugin::FilterChain>, CoreError> {
+        // Build filter string from individual parameters (for backward compatibility)
+        let mut filter_parts = Vec::new();
+        if let Some(pattern) = grep {
+            filter_parts.push(format!("grep('{}')", pattern.replace('\'', "\\'")));
+        }
+        if let Some(bytes) = head_bytes {
+            filter_parts.push(format!("head_bytes({})", bytes));
+        }
+        if let Some(lines) = head_lines {
+            filter_parts.push(format!("head_lines({})", lines));
+        }
+        if let Some(bytes) = tail_bytes {
+            filter_parts.push(format!("tail_bytes({})", bytes));
+        }
+        if let Some(lines) = tail_lines {
+            filter_parts.push(format!("tail_lines({})", lines));
+        }
+
+        // Use the provided filter string if available, otherwise build from parts
+        let filter_str = filter.or_else(|| {
+            if filter_parts.is_empty() {
+                None
+            } else {
+                Some(filter_parts.join(" | "))
+            }
+        });
+
+        // Create filter chain
+        self.filter_service.create_filter_chain(filter_str.as_deref())
+            .map_err(|e| CoreError::InvalidInput(format!("Failed to create filter chain: {}", e)))
     }
 
     /// Helper method to determine if content is binary
@@ -133,15 +164,15 @@ impl ItemService {
         &self,
         conn: &Connection,
         id: i64,
-        _head_bytes: Option<usize>,
-        _head_words: Option<usize>,
-        _head_lines: Option<usize>,
-        _tail_bytes: Option<usize>,
-        _tail_words: Option<usize>,
-        _tail_lines: Option<usize>,
-        _line_start: Option<usize>,
-        _line_end: Option<usize>,
-        _grep: Option<String>,
+        head_bytes: Option<usize>,
+        head_words: Option<usize>,
+        head_lines: Option<usize>,
+        tail_bytes: Option<usize>,
+        tail_words: Option<usize>,
+        tail_lines: Option<usize>,
+        line_start: Option<usize>,
+        line_end: Option<usize>,
+        grep: Option<String>,
     ) -> Result<(Box<dyn Read + Send>, String, bool), CoreError> {
         let item_with_meta = self.get_item(conn, id)?;
         let item_id = item_with_meta.item.id.ok_or_else(|| CoreError::InvalidInput("Item missing ID".to_string()))?;
@@ -159,12 +190,12 @@ impl ItemService {
         )?;
 
         // Create filter chain
-        let _filter_chain = self.create_filter_chain(
+        let filter_chain = self.create_filter_chain(
             grep, head_bytes, head_lines, tail_bytes, tail_lines, None
         )?;
 
-        // For now, just use the original reader since filtering isn't implemented
-        let filtered_reader = Box::new(reader);
+        // Wrap the reader with filtering
+        let filtered_reader = Box::new(FilteringReader::new(reader, filter_chain));
 
         let metadata = item_with_meta.meta_as_map();
         let mime_type = metadata