feat: improve save/load command output formatting

- Match the styled output format used by 'info' command
- Show MFT structure details (records, utilization, fragmentation)
- Display absolute file paths
- Show compression ratio and space saved
- Add timing information
- Use box-drawing characters and emoji for visual clarity

Author: githubrobbi

crates/uffs-mft/src/main.rs

@@ -1888,10 +1888,52 @@ async fn cmd_save(
     compress: bool,
     compression_level: i32,
 ) -> Result<()> {
+    use std::time::Instant;
+
+    use uffs_mft::platform::{VolumeHandle, detect_drive_type};
     use uffs_mft::{MftReader, SaveRawOptions};
 
-    info!(drive = %drive, "Reading raw MFT from drive");
+    let start_time = Instant::now();
+    let drive_upper = drive.to_ascii_uppercase();
+
+    info!(drive = %drive_upper, "Reading raw MFT from drive");
 
+    // Get volume info for display
+    let handle =
+        VolumeHandle::open(drive).with_context(|| format!("Failed to open {}:", drive))?;
+    let vol_data = handle.volume_data();
+
+    let drive_type = detect_drive_type(drive_upper);
+    let drive_type_str = match drive_type {
+        uffs_mft::DriveType::Ssd => "SSD",
+        uffs_mft::DriveType::Hdd => "HDD",
+        uffs_mft::DriveType::Unknown => "Unknown",
+    };
+
+    // Calculate metrics
+    let record_count =
+        vol_data.mft_valid_data_length / vol_data.bytes_per_file_record_segment as u64;
+
+    // Fragmentation analysis
+    let mut extent_count = 1;
+    let is_fragmented;
+    if let Ok(extents) = handle.get_mft_extents() {
+        extent_count = extents.len();
+        is_fragmented = extent_count > 1;
+    } else {
+        is_fragmented = false;
+    }
+
+    // Bitmap analysis
+    let mut in_use_records = 0u64;
+    let mut utilization = 0.0f64;
+    if let Ok(bitmap) = handle.get_mft_bitmap() {
+        in_use_records = bitmap.count_in_use() as u64;
+        utilization = (in_use_records as f64 / record_count as f64) * 100.0;
+    }
+    let free_records = record_count.saturating_sub(in_use_records);
+
+    // Open reader and save
     let reader = MftReader::open(drive)
         .await
         .with_context(|| format!("Failed to open drive {drive}:"))?;
@@ -1906,20 +1948,62 @@ async fn cmd_save(
         .await
         .with_context(|| format!("Failed to save raw MFT to {}", output.display()))?;
 
+    let elapsed = start_time.elapsed();
+
+    // Get absolute path for display
+    let abs_path = std::fs::canonicalize(output).unwrap_or_else(|_| output.to_path_buf());
+
+    // Print formatted output
+    println!("═══════════════════════════════════════════════════════════════");
+    println!("                         MFT SAVED");
+    println!(
+        "                    Drive: {}: ({})",
+        drive_upper, drive_type_str
+    );
+    println!("═══════════════════════════════════════════════════════════════");
     println!();
-    println!("=== Raw MFT Saved ===");
-    println!("Output:          {}", output.display());
-    println!("Records:         {}", header.record_count);
-    println!("Record size:     {} bytes", header.record_size);
-    println!("Original size:   {}", format_bytes(header.original_size));
+    println!("📁 MFT STRUCTURE");
+    println!(
+        "  Total records:        {}",
+        format_number_commas(record_count)
+    );
+    println!(
+        "  In-use records:       {}",
+        format_number_commas(in_use_records)
+    );
+    println!(
+        "  Free records:         {}",
+        format_number_commas(free_records)
+    );
+    println!("  Utilization:          {:.1}%", utilization);
+    println!(
+        "  Fragmentation:        {} extent(s) {}",
+        extent_count,
+        if is_fragmented { "⚠️" } else { "✅" }
+    );
+    println!();
+    println!("💾 OUTPUT FILE");
+    println!("  Path:                 {}", abs_path.display());
+    println!(
+        "  Original size:       {}",
+        format_bytes(header.original_size)
+    );
     if header.is_compressed() {
-        println!("Compressed size: {}", format_bytes(header.compressed_size));
+        println!(
+            "  Compressed size:     {}",
+            format_bytes(header.compressed_size)
+        );
         #[allow(clippy::cast_precision_loss, clippy::float_arithmetic)]
         let ratio = header.compressed_size as f64 / header.original_size as f64 * 100.0_f64;
-        println!("Compression:     {ratio:.1}%");
+        println!("  Compression ratio:    {ratio:.1}%");
+        #[allow(clippy::cast_precision_loss, clippy::float_arithmetic)]
+        let savings = 100.0_f64 - ratio;
+        println!("  Space saved:          {savings:.1}%");
     } else {
-        println!("Compression:     none");
+        println!("  Compression:          none");
     }
+    println!();
+    println!("⏱️  Completed in {}", format_duration(elapsed));
 
     Ok(())
 }
@@ -1939,66 +2023,107 @@ async fn cmd_save(
 /// Load MFT from a saved file and optionally export.
 #[cfg(windows)]
 async fn cmd_load(input: &Path, output: Option<&Path>, info_only: bool) -> Result<()> {
+    use std::time::Instant;
+
     use uffs_mft::{MftReader, load_raw_mft_header};
 
+    let start_time = Instant::now();
+
     // Load header first
     let header = load_raw_mft_header(input)
         .with_context(|| format!("Failed to load raw MFT header from {}", input.display()))?;
 
-    println!("=== Raw MFT File Info ===");
-    println!("File:            {}", input.display());
-    println!("Version:         {}", header.version);
-    println!("Records:         {}", header.record_count);
-    println!("Record size:     {} bytes", header.record_size);
-    println!("Original size:   {}", format_bytes(header.original_size));
+    // Get absolute path for display
+    let abs_path = std::fs::canonicalize(input).unwrap_or_else(|_| input.to_path_buf());
+
+    // Print formatted output
+    println!("═══════════════════════════════════════════════════════════════");
+    println!("                         MFT FILE INFO");
+    println!("═══════════════════════════════════════════════════════════════");
+    println!();
+    println!("📁 FILE DETAILS");
+    println!("  Path:                 {}", abs_path.display());
+    println!("  Format version:       {}", header.version);
+    println!();
+    println!("📊 MFT CONTENTS");
+    println!(
+        "  Total records:        {}",
+        format_number_commas(header.record_count.into())
+    );
+    println!(
+        "  Record size:          {} bytes",
+        format_number_commas(header.record_size.into())
+    );
+    println!(
+        "  Original size:       {}",
+        format_bytes(header.original_size)
+    );
     if header.is_compressed() {
-        println!("Compressed size: {}", format_bytes(header.compressed_size));
+        println!(
+            "  Compressed size:     {}",
+            format_bytes(header.compressed_size)
+        );
         #[allow(clippy::cast_precision_loss, clippy::float_arithmetic)]
         let ratio = header.compressed_size as f64 / header.original_size as f64 * 100.0_f64;
-        println!("Compression:     {ratio:.1}%");
+        println!("  Compression ratio:    {ratio:.1}%");
     } else {
-        println!("Compression:     none");
+        println!("  Compression:          none");
     }
 
     if info_only {
+        println!();
+        let elapsed = start_time.elapsed();
+        println!("⏱️  Completed in {}", format_duration(elapsed));
         return Ok(());
     }
 
     // Parse and export
     let output = output.context("--output is required when not using --info-only")?;
 
-    info!("Parsing MFT records");
+    println!();
+    println!("📤 EXPORTING...");
 
     let df = MftReader::load_raw_to_dataframe(input)
         .with_context(|| format!("Failed to parse raw MFT from {}", input.display()))?;
 
-    info!(records = df.height(), "Parsed records");
+    let parsed_count = df.height();
 
     // Determine output format from extension
     let ext = output
         .extension()
         .and_then(|e| e.to_str())
         .unwrap_or("parquet");
 
+    let output_abs = std::fs::canonicalize(output).unwrap_or_else(|_| output.to_path_buf());
+
     match ext {
         "csv" => {
             use std::fs::File;
             use std::io::Write;
 
             let mut file = File::create(output)?;
-            // Simple CSV export
             let mut df = df;
             let csv_str = uffs_polars::write_csv_to_string(&mut df)?;
             file.write_all(csv_str.as_bytes())?;
-            info!(path = %output.display(), "Exported to CSV");
+            println!("  Format:               CSV");
         }
         _ => {
             let mut df = df;
             MftReader::save_parquet(&mut df, output)?;
-            info!(path = %output.display(), "Exported to Parquet");
+            println!("  Format:               Parquet");
         }
     }
 
+    println!("  Output path:          {}", output_abs.display());
+    println!(
+        "  Records exported:     {}",
+        format_number_commas(parsed_count as u64)
+    );
+
+    let elapsed = start_time.elapsed();
+    println!();
+    println!("⏱️  Completed in {}", format_duration(elapsed));
+
     Ok(())
 }