chore: ignore os metadata files

Author: hashemix

src/fs_service.rs

@@ -2,6 +2,7 @@ pub mod file_info;
 pub mod utils;
 use crate::{
     error::{ServiceError, ServiceResult},
+    fs_service::utils::is_system_metadata_file,
     tools::EditOperation,
 };
 use async_zip::tokio::{read::seek::ZipFileReader, write::ZipFileWriter};
@@ -1398,9 +1399,10 @@ impl FileSystemService {
 
     /// Recursively finds all empty directories within the given root path.
     ///
-    /// A directory is considered empty if it contains no files or subdirectories.
-    /// You can optionally provide a list of glob-style patterns in `exclude_patterns`
-    /// to ignore certain paths during the search (e.g., to skip system folders or hidden directories).
+    /// A directory is considered empty if it contains no files in itself or any of its subdirectories
+    /// except OS metadata files: `.DS_Store` (macOS) and `Thumbs.db` (Windows)
+    /// Empty subdirectories are allowed. You can optionally provide a list of glob-style patterns in
+    /// `exclude_patterns` to ignore certain paths during the search (e.g., to skip system folders or hidden directories).
     ///
     /// # Arguments
     /// - `root_path`: The starting directory to search.
@@ -1411,7 +1413,23 @@ impl FileSystemService {
     /// Returns an error if the root path is invalid or inaccessible.
     ///
     /// # Returns
-    /// A list of paths to empty directories, relative to the root path.
+    /// A list of paths to empty directories, as strings, including parent directories that contain only empty subdirectories.
+    /// Recursively finds all empty directories within the given root path.
+    ///
+    /// A directory is considered empty if it contains no files in itself or any of its subdirectories.
+    /// Empty subdirectories are allowed. You can optionally provide a list of glob-style patterns in
+    /// `exclude_patterns` to ignore certain paths during the search (e.g., to skip system folders or hidden directories).
+    ///
+    /// # Arguments
+    /// - `root_path`: The starting directory to search.
+    /// - `exclude_patterns`: Optional list of glob patterns to exclude from the search.
+    ///                       Directories matching these patterns will be ignored.
+    ///
+    /// # Errors
+    /// Returns an error if the root path is invalid or inaccessible.
+    ///
+    /// # Returns
+    /// A list of paths to all empty directories, as strings, including parent directories that contain only empty subdirectories.
     pub async fn find_empty_directories(
         &self,
         root_path: &Path,
@@ -1433,11 +1451,9 @@ impl FileSystemService {
         // Check each directory for emptiness
         for entry in walker {
             let is_empty = WalkDir::new(entry.path())
-                .min_depth(1)
-                .max_depth(1)
                 .into_iter()
-                .next()
-                .is_none(); // Directory is empty if it has no entries
+                .filter_map(|e| e.ok())
+                .all(|e| !e.file_type().is_file() || is_system_metadata_file(&e.file_name())); // Directory is empty if no files are found in it or subdirs, ".DS_Store" will be ignores on Mac
 
             if is_empty {
                 if let Some(path_str) = entry.path().to_str() {

src/fs_service/utils.rs

@@ -7,6 +7,7 @@ use std::os::unix::fs::PermissionsExt;
 #[cfg(windows)]
 use std::os::windows::fs::MetadataExt;
 use std::{
+    ffi::OsStr,
     fs::{self},
     path::{Component, Path, PathBuf, Prefix},
     time::SystemTime,
@@ -145,3 +146,14 @@ pub fn contains_symlink<P: AsRef<Path>>(path: P) -> std::io::Result<bool> {
 
     Ok(false)
 }
+
+/// Checks if a given filename is a system metadata file commonly
+/// used by operating systems to store folder metadata.
+///
+/// Specifically detects:
+/// - `.DS_Store` (macOS)
+/// - `Thumbs.db` (Windows)
+///
+pub fn is_system_metadata_file(filename: &OsStr) -> bool {
+    filename == ".DS_Store" || filename == "Thumbs.db"
+}

src/tools/find_duplicate_files.rs

@@ -33,7 +33,7 @@ pub struct FindDuplicateFilesTool {
     /// Maximum file size (in bytes) to include in the search (optional).
     pub max_bytes: Option<u64>,
     /// Specify the output format, accepts either `text` or `json` (default: text).
-    pub output_format: OutputFormat,
+    pub output_format: Option<OutputFormat>,
 }
 
 impl FindDuplicateFilesTool {
@@ -90,8 +90,11 @@ impl FindDuplicateFilesTool {
             .await
             .map_err(CallToolError::new)?;
 
-        let result_content = Self::format_output(duplicate_files, params.output_format)
-            .map_err(CallToolError::new)?;
+        let result_content = Self::format_output(
+            duplicate_files,
+            params.output_format.unwrap_or(OutputFormat::Text),
+        )
+        .map_err(CallToolError::new)?;
 
         Ok(CallToolResult::text_content(vec![TextContent::from(
             result_content,

src/tools/find_empty_directories.rs

@@ -1,18 +1,19 @@
-use std::path::Path;
-
 use rust_mcp_sdk::{
     macros::{JsonSchema, mcp_tool},
     schema::{CallToolResult, TextContent, schema_utils::CallToolError},
 };
+use std::fmt::Write;
+use std::path::Path;
 
-use crate::fs_service::{FileSystemService, OS_LINE_ENDING};
+use crate::fs_service::{FileSystemService, utils::OutputFormat};
 
 // head_file
 #[mcp_tool(
     name = "find_empty_directories",
     title="Find Empty Directories",
     description = concat!("Recursively finds all empty directories within the given root path.",
-    "A directory is considered empty if it contains no files or subdirectories.",
+    "A directory is considered empty if it contains no files in itself or any of its subdirectories.",
+    "Operating system metadata files `.DS_Store` (macOS) and `Thumbs.db` (Windows) will be ignored.",
     "The optional exclude_patterns argument accepts glob-style patterns to exclude specific paths from the search.",
     "Only works within allowed directories."),
     destructive_hint = false,
@@ -26,6 +27,8 @@ pub struct FindEmptyDirectoriesTool {
     pub path: String,
     /// Optional list of glob patterns to exclude from the search. Directories matching these patterns will be ignored.
     pub exclude_patterns: Option<Vec<String>>,
+    /// Specify the output format, accepts either `text` or `json` (default: text).
+    pub output_format: Option<OutputFormat>,
 }
 
 impl FindEmptyDirectoriesTool {
@@ -37,9 +40,45 @@ impl FindEmptyDirectoriesTool {
             .find_empty_directories(&Path::new(&params.path), params.exclude_patterns)
             .await
             .map_err(CallToolError::new)?;
-        let content = result.join(OS_LINE_ENDING);
+
+        let content =
+            Self::format_output(result, params.output_format.unwrap_or(OutputFormat::Text))
+                .map_err(CallToolError::new)?;
+
         Ok(CallToolResult::text_content(vec![TextContent::from(
             content,
         )]))
     }
+
+    fn format_output(
+        empty_dirs: Vec<String>,
+        output_format: OutputFormat,
+    ) -> std::result::Result<String, CallToolError> {
+        let output = match output_format {
+            OutputFormat::Text => {
+                let mut output = String::new();
+
+                let header = if empty_dirs.len() == 0 {
+                    "No empty directories were found.".to_string()
+                } else {
+                    format!(
+                        "Found {} empty directorie{}:\n",
+                        empty_dirs.len(),
+                        (if empty_dirs.len() == 1 { "" } else { "s" }),
+                    )
+                };
+                output.push_str(&header);
+
+                for dir in empty_dirs {
+                    writeln!(output, "  {}", dir).map_err(CallToolError::new)?;
+                }
+                output
+            }
+            OutputFormat::Json => {
+                serde_json::to_string_pretty(&empty_dirs).map_err(CallToolError::new)?
+            }
+        };
+
+        Ok(output)
+    }
 }