feat: add infer_drive_from_path utility to uffs-mft

Add a reusable utility function to extract drive letters from paths:
- Absolute paths: C:\foo\bar.parquet → 'C'
- Relative paths: falls back to current directory's drive

This is now used by the index command and can be used by other
commands that need drive inference from paths.

Exported from uffs_mft::infer_drive_from_path (Windows only).

Author: githubrobbi

Cargo.lock

@@ -629,66 +629,36 @@ async fn search_multi_drive_filtered(
 /// Supports both single drive (`--drive C`) and multiple drives (`--drives
 /// C,D,E`). When multiple drives are specified, they are read concurrently and
 /// merged into a single `DataFrame` with a `drive` column.
-/// Infer drive letter from a path.
-///
-/// - Absolute path with drive: `C:\foo\bar.parquet` → Some('C')
-/// - Relative path: `bar.parquet` → infer from current directory
-/// - UNC path or no drive: → None
-#[cfg(windows)]
-fn infer_drive_from_path(path: &Path) -> Option<char> {
-    use std::path::Component;
-
-    // Check if path has a drive prefix (e.g., C:)
-    if let Some(Component::Prefix(prefix)) = path.components().next() {
-        use std::path::Prefix;
-        if let Prefix::Disk(drive_byte) | Prefix::VerbatimDisk(drive_byte) = prefix.kind() {
-            return Some((drive_byte as char).to_ascii_uppercase());
-        }
-    }
-
-    // For relative paths, get drive from current directory
-    if let Ok(cwd) = std::env::current_dir() {
-        return infer_drive_from_path(&cwd);
-    }
-
-    None
-}
-
-/// Stub for non-Windows platforms.
-#[cfg(not(windows))]
-const fn infer_drive_from_path(_path: &Path) -> Option<char> {
-    None
-}
-
-/// Ensure path has an extension, defaulting to `.parquet`.
-fn ensure_extension(path: PathBuf) -> PathBuf {
-    if path.extension().is_some() {
-        path
-    } else {
-        path.with_extension("parquet")
-    }
-}
 
 /// Build an index from a drive's MFT.
 ///
-/// The drive is inferred from the output path if not explicitly specified.
-// CLI command handler - separate function for testability and maintainability.
-#[allow(clippy::shadow_unrelated, clippy::single_call_fn)]
+/// The drive is inferred from the output path if not explicitly specified:
+/// - Absolute path with drive: `C:\foo\bar.parquet` → indexes C:
+/// - Relative path: `bar.parquet` → indexes drive of current directory
 pub async fn index(
-    output: PathBuf,
+    output_path: PathBuf,
     single_drive: Option<char>,
     multi_drives: Option<Vec<char>>,
 ) -> Result<()> {
     // Ensure output has an extension (default to .parquet)
-    let output = ensure_extension(output);
+    let output = if output_path.extension().is_some() {
+        output_path
+    } else {
+        output_path.with_extension("parquet")
+    };
 
     // Determine which drives to index
     let drive_list: Vec<char> = match (single_drive, multi_drives) {
         (Some(drv), None) => vec![drv],
         (None, Some(drvs)) => drvs,
         (None, None) => {
             // Infer drive from output path
-            if let Some(drive) = infer_drive_from_path(&output) {
+            #[cfg(windows)]
+            let inferred = uffs_mft::infer_drive_from_path(&output);
+            #[cfg(not(windows))]
+            let inferred: Option<char> = None;
+
+            if let Some(drive) = inferred {
                 info!(drive = %drive, "Inferred drive from output path");
                 vec![drive]
             } else {

crates/uffs-cli/src/commands.rs

@@ -122,7 +122,7 @@ pub use ntfs::{
 #[cfg(windows)]
 pub use platform::{
     DriveType, MftBitmap, MftExtent, NtfsVolumeData, VolumeHandle, detect_drive_type,
-    detect_ntfs_drives, is_elevated,
+    detect_ntfs_drives, infer_drive_from_path, is_elevated,
 };
 pub use raw::{
     LoadRawOptions, RawMftData, RawMftHeader, SaveRawOptions, load_raw_mft, load_raw_mft_header,

crates/uffs-mft/src/lib.rs

@@ -1086,6 +1086,64 @@ pub fn volume_root_path(volume: char) -> PathBuf {
     PathBuf::from(format!("{}:\\", volume.to_ascii_uppercase()))
 }
 
+/// Infer drive letter from a file path.
+///
+/// Extracts the drive letter from absolute paths (e.g., `C:\foo\bar.parquet` →
+/// `'C'`). For relative paths, falls back to the current working directory's
+/// drive.
+///
+/// # Arguments
+///
+/// * `path` - Any file path (absolute or relative)
+///
+/// # Returns
+///
+/// - `Some(char)` - Uppercase drive letter if found
+/// - `None` - If path has no drive prefix and current directory cannot be
+///   determined
+///
+/// # Example
+///
+/// ```rust,ignore
+/// use std::path::Path;
+/// use uffs_mft::infer_drive_from_path;
+///
+/// // Absolute path
+/// assert_eq!(infer_drive_from_path(Path::new("C:\\data\\index.parquet")), Some('C'));
+///
+/// // Relative path (uses current directory's drive)
+/// // If cwd is D:\work, returns Some('D')
+/// let drive = infer_drive_from_path(Path::new("index.parquet"));
+/// ```
+#[must_use]
+pub fn infer_drive_from_path(path: &Path) -> Option<char> {
+    use std::path::{Component, Prefix};
+
+    // Try to get drive from the path itself (absolute paths like C:\foo)
+    if let Some(Component::Prefix(prefix)) = path.components().next() {
+        match prefix.kind() {
+            Prefix::Disk(drive_byte) | Prefix::VerbatimDisk(drive_byte) => {
+                return Some((drive_byte as char).to_ascii_uppercase());
+            }
+            _ => {} // UNC paths, device paths, etc. - no drive letter
+        }
+    }
+
+    // For relative paths, get drive from current working directory
+    std::env::current_dir().ok().and_then(|cwd| {
+        if let Some(Component::Prefix(prefix)) = cwd.components().next() {
+            match prefix.kind() {
+                Prefix::Disk(drive_byte) | Prefix::VerbatimDisk(drive_byte) => {
+                    Some((drive_byte as char).to_ascii_uppercase())
+                }
+                _ => None,
+            }
+        } else {
+            None
+        }
+    })
+}
+
 /// Detects all available NTFS drives on the system.
 ///
 /// This function iterates through all possible drive letters (A-Z) and