feat(xtool): add compressed-size

ex:

```
xtool --repo-type dataset --repo-id $REPO compressed-size $HASH
Compressed Size:   6181022260 bytes 5.757 GiB 6.181 GB
Uncompressed Size: 9710109696 bytes 9.043 GiB 9.710 GB
Compression Ratio:  63.66%
```

Signed-off-by: Adrien Delorme <[email protected]>

Author: azr

Cargo.lock

@@ -57,6 +57,7 @@ getrandom = "0.3"
 git-url-parse = "0.4"
 git2 = "0.20"
 half = "2.4"
+humansize = "2.1"
 heapify = "0.2"
 heed = "0.11"
 http = "1"

Cargo.toml

@@ -42,6 +42,7 @@ xet_runtime = { path = "../xet_runtime" }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 bytes = { workspace = true }
+humansize = { workspace = true }
 chrono = { workspace = true }
 clap = { workspace = true }
 jsonwebtoken = { workspace = true }

data/Cargo.toml

@@ -12,6 +12,7 @@ use data::data_client::default_config;
 use data::migration_tool::hub_client_token_refresher::HubClientTokenRefresher;
 use data::migration_tool::migrate::migrate_files_impl;
 use hub_client::{BearerCredentialHelper, HubClient, Operation, RepoInfo};
+use humansize::{BINARY, DECIMAL, format_size};
 use merklehash::MerkleHash;
 use utils::auth::TokenRefresher;
 use walkdir::WalkDir;
@@ -76,6 +77,8 @@ enum Command {
     Dedup(DedupArg),
     /// Queries reconstruction information about a file.
     Query(QueryArg),
+    /// Calculates the compressed size of a xet-file by summing url_range sizes.
+    CompressedSize(CompressedSizeArg),
 }
 
 #[derive(Args)]
@@ -116,6 +119,12 @@ struct QueryArg {
     bytes_range: Option<FileRange>,
 }
 
+#[derive(Args)]
+struct CompressedSizeArg {
+    /// Xet-hash of a file.
+    hash: String,
+}
+
 impl Command {
     async fn run(self, hub_client: HubClient) -> Result<()> {
         match self {
@@ -161,6 +170,43 @@ impl Command {
 
                 Ok(())
             },
+            Command::CompressedSize(arg) => {
+                let file_hash = MerkleHash::from_hex(&arg.hash)?;
+                // Query reconstruction for full file (no Range header)
+                let ret = query_reconstruction(file_hash, None, hub_client).await?;
+
+                match ret {
+                    Some(response) => {
+                        let mut total_compressed_size = 0u64;
+
+                        // Iterate through all fetch_info items (HashMap of arrays)
+                        for fetch_infos in response.fetch_info.values() {
+                            for fetch_info in fetch_infos {
+                                // Calculate end - start for each url_range as specified
+                                let range_size = fetch_info.url_range.end - fetch_info.url_range.start;
+                                total_compressed_size += range_size;
+                            }
+                        }
+
+                        // Calculate uncompressed size by summing unpacked_length from all terms
+                        let total_uncompressed_size: u64 =
+                            response.terms.iter().map(|term| term.unpacked_length as u64).sum();
+
+                        // Display sizes on single lines
+                        println!("Compressed Size:   {}", format_bytes_with_units(total_compressed_size));
+                        println!("Uncompressed Size: {}", format_bytes_with_units(total_uncompressed_size));
+                        println!(
+                            "Compression Ratio:  {:.2}%",
+                            (total_compressed_size as f64 / total_uncompressed_size as f64) * 100.0
+                        );
+                        Ok(())
+                    },
+                    None => {
+                        eprintln!("No reconstruction information found for hash {}", arg.hash);
+                        Ok(())
+                    },
+                }
+            },
         }
     }
 }
@@ -193,6 +239,13 @@ fn is_git_special_files(path: &str) -> bool {
     matches!(path, ".git" | ".gitignore" | ".gitattributes")
 }
 
+/// Format bytes with binary and decimal units on one line
+fn format_bytes_with_units(bytes: u64) -> String {
+    let binary = format_size(bytes, BINARY);
+    let decimal = format_size(bytes, DECIMAL);
+    format!("{} bytes {} {}", bytes, binary, decimal)
+}
+
 async fn query_reconstruction(
     file_hash: MerkleHash,
     bytes_range: Option<FileRange>,