feat: add read_file_lines

Author: hashemix

src/fs_service.rs

@@ -1297,59 +1297,67 @@ impl FileSystemService {
         Ok(result)
     }
 
-    /// Reads specific lines from a text file starting at the given offset.
+    /// Reads lines from a text file starting at the specified offset (0-based), preserving line endings.
     /// Args:
     ///     path: Path to the file
-    ///     offset: Line offset (0-based, starts at first line)
-    ///     limit: Maximum number of lines to read (None for all remaining)
-    /// Returns a vector of lines or an error if the path is invalid or file cannot be read.
+    ///     offset: Number of lines to skip (0-based)
+    ///     limit: Optional maximum number of lines to read
+    /// Returns a String containing the selected lines with original line endings or an error if the path is invalid or file cannot be read.
     pub async fn read_file_lines(
         &self,
         path: &Path,
         offset: usize,
         limit: Option<usize>,
-    ) -> ServiceResult<Vec<String>> {
+    ) -> ServiceResult<String> {
         // Validate file path against allowed directories
         let allowed_directories = self.allowed_directories().await;
         let valid_path = self.validate_path(path, allowed_directories)?;
 
-        // Open file asynchronously and create a BufReader
+        // Open file and get metadata before moving into BufReader
         let file = File::open(&valid_path).await?;
-        let reader = BufReader::new(file);
-        let mut lines = Vec::new();
-
-        // Read lines asynchronously
-        let mut line_iter = reader.lines();
-        let mut current_line = 0;
-
-        // Skip lines until the offset is reached
-        while current_line < offset {
-            match line_iter.next_line().await? {
-                Some(_) => current_line += 1,
-                None => return Ok(lines), // EOF before reaching offset
+        let file_size = file.metadata().await?.len();
+        let mut reader = BufReader::new(file);
+
+        // If file is empty or limit is 0, return empty string
+        if file_size == 0 || limit == Some(0) {
+            return Ok(String::new());
+        }
+
+        // Skip offset lines (0-based indexing)
+        let mut buffer = Vec::new();
+        for _ in 0..offset {
+            buffer.clear();
+            if reader.read_until(b'\n', &mut buffer).await? == 0 {
+                return Ok(String::new()); // EOF before offset
             }
         }
 
-        // Read lines up to the limit (or all remaining if limit is None)
+        // Read lines up to limit (or all remaining if limit is None)
+        let mut result = String::with_capacity(limit.unwrap_or(100) * 100); // Estimate capacity
         match limit {
             Some(max_lines) => {
-                let remaining = max_lines; // No need to add offset, track lines read
-                for _ in 0..remaining {
-                    match line_iter.next_line().await? {
-                        Some(line) => lines.push(line),
-                        None => break, // Reached EOF
+                for _ in 0..max_lines {
+                    buffer.clear();
+                    let bytes_read = reader.read_until(b'\n', &mut buffer).await?;
+                    if bytes_read == 0 {
+                        break; // Reached EOF
                     }
+                    result.push_str(&String::from_utf8_lossy(&buffer));
                 }
             }
             None => {
-                // Read all remaining lines
-                while let Some(line) = line_iter.next_line().await? {
-                    lines.push(line);
+                loop {
+                    buffer.clear();
+                    let bytes_read = reader.read_until(b'\n', &mut buffer).await?;
+                    if bytes_read == 0 {
+                        break; // Reached EOF
+                    }
+                    result.push_str(&String::from_utf8_lossy(&buffer));
                 }
             }
         }
 
-        Ok(lines)
+        Ok(result)
     }
 
     pub async fn calculate_directory_size(&self, root_path: &Path) -> ServiceResult<u64> {

src/handler.rs

@@ -254,6 +254,9 @@ impl ServerHandler for FileSystemHandler {
             FileSystemTools::TailFileTool(params) => {
                 TailFileTool::run_tool(params, &self.fs_service).await
             }
+            FileSystemTools::ReadFileLinesTool(params) => {
+                ReadFileLinesTool::run_tool(params, &self.fs_service).await
+            }
         }
     }
 }

src/tools.rs

@@ -30,6 +30,7 @@ pub use list_allowed_directories::ListAllowedDirectoriesTool;
 pub use list_directory::ListDirectoryTool;
 pub use list_directory_with_sizes::ListDirectoryWithSizesTool;
 pub use move_file::MoveFileTool;
+pub use read_file_lines::ReadFileLinesTool;
 pub use read_media_file::ReadMediaFileTool;
 pub use read_multiple_media_files::ReadMultipleMediaFilesTool;
 pub use read_multiple_text_files::ReadMultipleTextFilesTool;
@@ -64,7 +65,8 @@ tool_box!(
         ReadMediaFileTool,
         ReadMultipleMediaFilesTool,
         HeadFileTool,
-        TailFileTool
+        TailFileTool,
+        ReadFileLinesTool
     ]
 );
 
@@ -92,6 +94,7 @@ impl FileSystemTools {
             | FileSystemTools::HeadFileTool(_)
             | FileSystemTools::ReadMultipleMediaFilesTool(_)
             | FileSystemTools::TailFileTool(_)
+            | FileSystemTools::ReadFileLinesTool(_)
             | FileSystemTools::SearchFilesTool(_) => false,
         }
     }

src/tools/read_file_lines.rs

@@ -1 +1,51 @@
-// read_file_lines
+use std::path::Path;
+
+use rust_mcp_sdk::{
+    macros::{JsonSchema, mcp_tool},
+    schema::{CallToolResult, TextContent, schema_utils::CallToolError},
+};
+
+use crate::fs_service::FileSystemService;
+
+// head_file
+#[mcp_tool(
+    name = "read_file_lines",
+    title="Read File Lines",
+    description = concat!("Reads lines from a text file starting at a specified line offset (0-based).",
+    "This function skips the first 'offset' lines and then reads up to 'limit' lines if specified, or reads until the end of the file otherwise.",
+    "It's useful for partial reads, pagination, or previewing sections of large text files.",
+    "Only works within allowed directories."),
+    destructive_hint = false,
+    idempotent_hint = false,
+    open_world_hint = false,
+    read_only_hint = true
+)]
+#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug, JsonSchema)]
+pub struct ReadFileLinesTool {
+    /// The path of the file to get information for.
+    pub path: String,
+    /// Number of lines to skip from the start (0-based).
+    pub offset: u64,
+    ///  Optional maximum number of lines to read after the offset.
+    pub limit: Option<u64>,
+}
+
+impl ReadFileLinesTool {
+    pub async fn run_tool(
+        params: Self,
+        context: &FileSystemService,
+    ) -> std::result::Result<CallToolResult, CallToolError> {
+        let result = context
+            .read_file_lines(
+                &Path::new(&params.path),
+                params.offset as usize,
+                params.limit.map(|v| v as usize),
+            )
+            .await
+            .map_err(CallToolError::new)?;
+
+        Ok(CallToolResult::text_content(vec![TextContent::from(
+            result,
+        )]))
+    }
+}

tests/test_fs_service.rs

@@ -1330,7 +1330,7 @@ async fn test_read_file_lines_normal() {
         .read_file_lines(&file_path, 1, Some(2))
         .await
         .unwrap();
-    assert_eq!(result, vec!["line2", "line3"]);
+    assert_eq!(result, "line2\nline3\n"); // No trailing newline
 }
 
 #[tokio::test]
@@ -1342,7 +1342,7 @@ async fn test_read_file_lines_empty_file() {
         .read_file_lines(&file_path, 0, Some(5))
         .await
         .unwrap();
-    assert_eq!(result, Vec::<String>::new());
+    assert_eq!(result, "");
 }
 
 #[tokio::test]
@@ -1354,7 +1354,7 @@ async fn test_read_file_lines_offset_beyond_file() {
         .read_file_lines(&file_path, 5, Some(3))
         .await
         .unwrap();
-    assert_eq!(result, Vec::<String>::new());
+    assert_eq!(result, "");
 }
 
 #[tokio::test]
@@ -1368,7 +1368,7 @@ async fn test_read_file_lines_no_limit() {
     .await;
 
     let result = service.read_file_lines(&file_path, 2, None).await.unwrap();
-    assert_eq!(result, vec!["line3", "line4"]);
+    assert_eq!(result, "line3\nline4"); // No trailing newline
 }
 
 #[tokio::test]
@@ -1381,29 +1381,65 @@ async fn test_read_file_lines_limit_zero() {
         .read_file_lines(&file_path, 1, Some(0))
         .await
         .unwrap();
-    assert_eq!(result, Vec::<String>::new());
+    assert_eq!(result, "");
 }
 
 #[tokio::test]
-async fn test_read_file_lines_invalid_path() {
+async fn test_read_file_lines_exact_file_length() {
     let (temp_dir, service, _allowed_dirs) = setup_service(vec!["dir1".to_string()]);
-    let invalid_path = temp_dir.join("dir2/test.txt"); // Outside allowed_dirs
+    let file_path =
+        create_test_file(&temp_dir, "dir1/test.txt", vec!["line1", "line2", "line3"]).await;
 
-    let result = service.read_file_lines(&invalid_path, 0, Some(3)).await;
-    assert!(result.is_err(), "Expected error for invalid path");
+    let result = service
+        .read_file_lines(&file_path, 0, Some(3))
+        .await
+        .unwrap();
+    assert_eq!(result, "line1\nline2\nline3"); // No trailing newline
 }
 
 #[tokio::test]
-async fn test_read_file_lines_exact_file_length() {
+async fn test_read_file_lines_no_newline_at_end() {
+    let (temp_dir, service, _allowed_dirs) = setup_service(vec!["dir1".to_string()]);
+    let file_path = create_temp_file(
+        &temp_dir.join("dir1"),
+        "test.txt",
+        "line1\nline2\nline3", // No newline at end
+    );
+
+    let result = service
+        .read_file_lines(&file_path, 1, Some(2))
+        .await
+        .unwrap();
+    assert_eq!(result, "line2\nline3"); // No trailing newline
+}
+
+#[tokio::test]
+async fn test_read_file_lines_windows_line_endings() {
     let (temp_dir, service, _allowed_dirs) = setup_service(vec!["dir1".to_string()]);
     let file_path =
         create_test_file(&temp_dir, "dir1/test.txt", vec!["line1", "line2", "line3"]).await;
 
+    // Override to use \r\n explicitly
+    let file_path = create_temp_file(
+        &temp_dir.join("dir1"),
+        "test.txt",
+        "line1\r\nline2\r\nline3",
+    );
+
     let result = service
-        .read_file_lines(&file_path, 0, Some(3))
+        .read_file_lines(&file_path, 1, Some(2))
         .await
         .unwrap();
-    assert_eq!(result, vec!["line1", "line2", "line3"]);
+    assert_eq!(result, "line2\r\nline3"); // No trailing newline
+}
+
+#[tokio::test]
+async fn test_read_file_lines_invalid_path() {
+    let (temp_dir, service, _allowed_dirs) = setup_service(vec!["dir1".to_string()]);
+    let invalid_path = temp_dir.join("dir2/test.txt"); // Outside allowed_dirs
+
+    let result = service.read_file_lines(&invalid_path, 0, Some(3)).await;
+    assert!(result.is_err(), "Expected error for invalid path");
 }
 
 #[test]