refactor: optimize tail filter to use ring buffer directly

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

src/services/item_service.rs

@@ -683,67 +683,70 @@ impl<R: Read + Send> TailFilter<R> {
     }
     
     fn process_tail(&mut self) {
-        // Convert the ring buffer to a Vec for easier processing
-        let buffer_contents: Vec<u8> = self.ring_buffer.iter().copied().collect();
+        let buffer_len = self.ring_buffer.len();
         
         if let Some(bytes) = self.tail_bytes {
-            self.output_start = if buffer_contents.len() > bytes {
-                buffer_contents.len() - bytes
-            } else {
-                0
-            };
-            self.output_remaining = buffer_contents.len() - self.output_start;
+            self.output_remaining = std::cmp::min(bytes, buffer_len);
+            // The start position in the ring buffer
+            self.output_start = (self.ring_buffer.write_index() as isize - self.output_remaining as isize)
+                .rem_euclid(self.ring_buffer.capacity() as isize) as usize;
         } else if let Some(lines) = self.tail_lines {
-            // Count lines from the end
+            // Count lines from the end by iterating through the ring buffer
             let mut lines_found = 0;
-            let mut start_index = buffer_contents.len();
+            let mut bytes_to_keep = 0;
             
-            for (i, &byte) in buffer_contents.iter().enumerate().rev() {
+            // Iterate backwards through the ring buffer
+            let mut pos = (self.ring_buffer.write_index() as isize - 1).rem_euclid(self.ring_buffer.capacity() as isize) as usize;
+            for _ in 0..buffer_len {
+                let byte = self.ring_buffer[pos];
+                bytes_to_keep += 1;
+                
                 if byte == b'\n' {
                     lines_found += 1;
                     if lines_found == lines {
-                        start_index = i + 1; // Start after the newline
                         break;
                     }
                 }
+                
+                pos = (pos as isize - 1).rem_euclid(self.ring_buffer.capacity() as isize) as usize;
             }
-            // If we didn't find enough newlines, start from the beginning
-            if lines_found < lines {
-                self.output_start = 0;
-            } else {
-                self.output_start = start_index;
-            }
-            self.output_remaining = buffer_contents.len() - self.output_start;
+            
+            self.output_remaining = bytes_to_keep;
+            self.output_start = (self.ring_buffer.write_index() as isize - self.output_remaining as isize)
+                .rem_euclid(self.ring_buffer.capacity() as isize) as usize;
         } else if let Some(words) = self.tail_words {
             // Count words from the end
             let mut words_found = 0;
-            let mut start_index = buffer_contents.len();
+            let mut bytes_to_keep = 0;
             let mut in_word = false;
             
-            for (i, &byte) in buffer_contents.iter().enumerate().rev() {
-                let is_whitespace = byte.is_ascii_whitespace();
+            // Iterate backwards through the ring buffer
+            let mut pos = (self.ring_buffer.write_index() as isize - 1).rem_euclid(self.ring_buffer.capacity() as isize) as usize;
+            for _ in 0..buffer_len {
+                let byte = self.ring_buffer[pos];
+                bytes_to_keep += 1;
                 
+                let is_whitespace = byte.is_ascii_whitespace();
                 if !in_word && !is_whitespace {
                     in_word = true;
                     words_found += 1;
                     if words_found == words {
-                        start_index = i;
                         break;
                     }
                 } else if is_whitespace {
                     in_word = false;
                 }
+                
+                pos = (pos as isize - 1).rem_euclid(self.ring_buffer.capacity() as isize) as usize;
             }
-            // If we didn't find enough words, start from the beginning
-            if words_found < words {
-                self.output_start = 0;
-            } else {
-                self.output_start = start_index;
-            }
-            self.output_remaining = buffer_contents.len() - self.output_start;
+            
+            self.output_remaining = bytes_to_keep;
+            self.output_start = (self.ring_buffer.write_index() as isize - self.output_remaining as isize)
+                .rem_euclid(self.ring_buffer.capacity() as isize) as usize;
         } else {
-            self.output_start = 0;
-            self.output_remaining = buffer_contents.len();
+            self.output_remaining = buffer_len;
+            self.output_start = (self.ring_buffer.write_index() as isize - self.output_remaining as isize)
+                .rem_euclid(self.ring_buffer.capacity() as isize) as usize;
         }
     }
     
@@ -784,18 +787,17 @@ impl<R: Read + Send> Read for TailFilter<R> {
             return Ok(0);
         }
         
-        // Convert the ring buffer to a Vec for easier slicing
-        let buffer_contents: Vec<u8> = self.ring_buffer.iter().copied().collect();
-        
         // Calculate how many bytes to copy
         let bytes_to_copy = std::cmp::min(buf.len(), self.output_remaining);
-        let end_index = self.output_start + bytes_to_copy;
         
-        // Copy the slice to the output buffer
-        buf[..bytes_to_copy].copy_from_slice(&buffer_contents[self.output_start..end_index]);
+        // Copy directly from the ring buffer
+        for i in 0..bytes_to_copy {
+            let index = (self.output_start + i) % self.ring_buffer.capacity();
+            buf[i] = self.ring_buffer[index];
+        }
         
         // Update the remaining bytes
-        self.output_start += bytes_to_copy;
+        self.output_start = (self.output_start + bytes_to_copy) % self.ring_buffer.capacity();
         self.output_remaining -= bytes_to_copy;
         
         Ok(bytes_to_copy)