feat: add filter progress percentage and streaming filter

- Show filter progress as percentage in status bar
- Add streaming_filter module with SIMD-accelerated search (memmem)
- Grep-style search for case-sensitive patterns (lazy line counting)
- Track lines_processed instead of match count for accurate progress
- Reuse buffer for case-insensitive search to reduce allocations

Author: raaymax

src/app.rs

@@ -21,7 +21,7 @@ pub enum FilterState {
     #[default]
     Inactive,
     Processing {
-        progress: usize,
+        lines_processed: usize,
     },
     Complete {
         matches: usize,
@@ -217,7 +217,11 @@ impl App {
     }
 
     /// Merge partial filter results (for immediate display while filtering continues)
-    pub fn merge_partial_filter_results(&mut self, new_indices: Vec<usize>) {
+    pub fn merge_partial_filter_results(
+        &mut self,
+        new_indices: Vec<usize>,
+        lines_processed: usize,
+    ) {
         let tab = self.active_tab_mut();
 
         // Check if we need to clear old results (new filter started)
@@ -275,10 +279,8 @@ impl App {
             tab.viewport.adjust_scroll_for_prepend(prepended_count);
         }
 
-        // Update filter state to show partial match count
-        tab.filter.state = FilterState::Processing {
-            progress: tab.line_indices.len(),
-        };
+        // Update filter state with lines processed for progress display
+        tab.filter.state = FilterState::Processing { lines_processed };
     }
 
     /// Clear filter
@@ -589,13 +591,14 @@ impl App {
 
             // Filter progress events
             AppEvent::FilterProgress(lines_processed) => {
-                self.active_tab_mut().filter.state = FilterState::Processing {
-                    progress: lines_processed,
-                };
+                self.active_tab_mut().filter.state = FilterState::Processing { lines_processed };
             }
-            AppEvent::FilterPartialResults(indices) => {
+            AppEvent::FilterPartialResults {
+                matches,
+                lines_processed,
+            } => {
                 // Merge partial results for immediate display
-                self.merge_partial_filter_results(indices);
+                self.merge_partial_filter_results(matches, lines_processed);
             }
             AppEvent::FilterComplete {
                 indices,
@@ -732,7 +735,7 @@ impl App {
                     // Defer clearing until first results arrive (prevents blink)
                     let tab = self.active_tab_mut();
                     tab.filter.needs_clear = true;
-                    tab.filter.state = FilterState::Processing { progress: 0 };
+                    tab.filter.state = FilterState::Processing { lines_processed: 0 };
                 }
                 // Actual filter execution is handled in main loop
             }

src/event.rs

@@ -34,7 +34,10 @@ pub enum AppEvent {
     },
     FilterProgress(usize),
     /// Partial filter results (for immediate display while filtering continues)
-    FilterPartialResults(Vec<usize>),
+    FilterPartialResults {
+        matches: Vec<usize>,
+        lines_processed: usize,
+    },
     FilterComplete {
         indices: Vec<usize>,
         incremental: bool,

src/filter/engine.rs

@@ -12,7 +12,10 @@ pub enum FilterProgress {
     /// Currently processing (lines processed so far)
     Processing(usize),
     /// Partial results found (sent periodically so UI can show matches immediately)
-    PartialResults(Vec<usize>),
+    PartialResults {
+        matches: Vec<usize>,
+        lines_processed: usize,
+    },
     /// Filtering complete (final matching line indices)
     Complete(Vec<usize>),
     /// Error occurred
@@ -245,6 +248,9 @@ impl FilterEngine {
                 }
             }
 
+            // Calculate lines processed (we process from end to start)
+            let lines_processed = end - batch_start;
+
             // Send partial results immediately if we found matches
             if !batch_matches.is_empty() {
                 // Sort this batch (it's from a contiguous range, so already mostly sorted)
@@ -255,7 +261,10 @@ impl FilterEngine {
                     return Ok(());
                 }
                 // Send these matches so UI can show them right away
-                let _ = tx.send(FilterProgress::PartialResults(batch_matches));
+                let _ = tx.send(FilterProgress::PartialResults {
+                    matches: batch_matches,
+                    lines_processed,
+                });
             }
 
             current_end = batch_start;
@@ -344,6 +353,9 @@ impl FilterEngine {
                 }
             }
 
+            // Calculate lines processed (we process from end to start)
+            let lines_processed = end - batch_start;
+
             // Send partial results immediately if we found matches
             if !batch_matches.is_empty() {
                 batch_matches.sort_unstable();
@@ -352,7 +364,10 @@ impl FilterEngine {
                 if cancel.is_cancelled() {
                     return Ok(());
                 }
-                let _ = tx.send(FilterProgress::PartialResults(batch_matches));
+                let _ = tx.send(FilterProgress::PartialResults {
+                    matches: batch_matches,
+                    lines_processed,
+                });
             }
 
             current_end = batch_start;
@@ -524,7 +539,7 @@ mod tests {
                 FilterProgress::Processing(line_num) => {
                     progress_updates.push(line_num);
                 }
-                FilterProgress::PartialResults(_) => {
+                FilterProgress::PartialResults { .. } => {
                     // Partial results are fine, just continue
                 }
                 FilterProgress::Complete(indices) => {

src/filter/mod.rs

@@ -2,6 +2,7 @@ pub mod cancel;
 pub mod engine;
 pub mod parallel_engine;
 pub mod regex_filter;
+pub mod streaming_filter;
 pub mod string_filter;
 
 /// Trait for extensible filtering