feat: add detailed update statistics and improve CLI output

QaidVoid · QaidVoid · commit b69cdeea094a · 2026-03-22T10:07:52.000+05:45
diff --git a/src/lib.rs b/src/lib.rs
@@ -4,4 +4,4 @@ pub mod update_info;
 pub mod updater;
 
 pub use error::Error;
-pub use updater::Updater;
+pub use updater::{UpdateStats, Updater};
diff --git a/src/main.rs b/src/main.rs
@@ -37,11 +37,27 @@ fn main() {
     let cli = Cli::parse();
 
     if let Err(e) = run(cli) {
-        eprintln!("Error: {}", e);
+        eprintln!("\nError: {}", e);
         std::process::exit(1);
     }
 }
 
+fn format_size(bytes: u64) -> String {
+    const KB: u64 = 1024;
+    const MB: u64 = 1024 * KB;
+    const GB: u64 = 1024 * MB;
+
+    if bytes >= GB {
+        format!("{:.1} GB", bytes as f64 / GB as f64)
+    } else if bytes >= MB {
+        format!("{:.1} MB", bytes as f64 / MB as f64)
+    } else if bytes >= KB {
+        format!("{:.1} KB", bytes as f64 / KB as f64)
+    } else {
+        format!("{} B", bytes)
+    }
+}
+
 fn run(cli: Cli) -> Result<(), Error> {
     match cli.command {
         Commands::Update {
@@ -59,23 +75,74 @@ fn run(cli: Cli) -> Result<(), Error> {
                 updater = updater.output_dir(dir);
             }
 
-            println!("Checking for update...");
+            let source_path = updater.source_path();
+            let source_size = updater.source_size();
+            let (target_path, target_size) = updater.target_info()?;
+
+            println!(
+                "Source:   {} ({})",
+                source_path.display(),
+                format_size(source_size)
+            );
+            println!(
+                "Target:   {} ({})",
+                target_path.display(),
+                format_size(target_size)
+            );
+            println!();
+
             if updater.check_for_update()? {
-                println!("Update available. Performing delta update...");
-                let new_path = updater.perform_update()?;
-                println!("Updated AppImage: {}", new_path.display());
+                println!("Performing delta update...");
+                let (new_path, stats) = updater.perform_update()?;
+
+                if stats.blocks_reused > 0 || stats.blocks_downloaded > 0 {
+                    println!();
+                    println!(
+                        "Reused:      {:>10}  ({} blocks)",
+                        format_size(stats.bytes_reused()),
+                        stats.blocks_reused
+                    );
+                    println!(
+                        "Downloaded:  {:>10}  ({} blocks)",
+                        format_size(stats.bytes_downloaded()),
+                        stats.blocks_downloaded
+                    );
+                    println!(
+                        "Saved:       {:>10}  ({}%)",
+                        format_size(stats.bytes_reused()),
+                        stats.saved_percentage()
+                    );
+                }
+
+                println!();
+                println!("Updated: {}", new_path.display());
             } else {
-                let output_path = updater.output_path()?;
-                println!("Already up to date: {}", output_path.display());
+                println!("Already up to date!");
             }
         }
         Commands::Check { path } => {
             let updater = Updater::new(&path)?;
 
+            let source_path = updater.source_path();
+            let source_size = updater.source_size();
+            let (target_path, target_size) = updater.target_info()?;
+
+            println!(
+                "Source:   {} ({})",
+                source_path.display(),
+                format_size(source_size)
+            );
+            println!(
+                "Target:   {} ({})",
+                target_path.display(),
+                format_size(target_size)
+            );
+            println!();
+
             if updater.check_for_update()? {
-                println!("Update available.");
+                println!("Status: Update available");
             } else {
-                println!("No update available.");
+                println!("Status: Up to date");
             }
         }
     }
diff --git a/src/updater.rs b/src/updater.rs
@@ -7,6 +7,34 @@ use crate::appimage::AppImage;
 use crate::error::{Error, Result};
 use crate::update_info::UpdateInfo;
 
+#[derive(Debug)]
+pub struct UpdateStats {
+    pub source_path: PathBuf,
+    pub source_size: u64,
+    pub target_path: PathBuf,
+    pub target_size: u64,
+    pub blocks_reused: usize,
+    pub blocks_downloaded: usize,
+    pub block_size: usize,
+}
+
+impl UpdateStats {
+    pub fn bytes_reused(&self) -> u64 {
+        (self.blocks_reused * self.block_size) as u64
+    }
+
+    pub fn bytes_downloaded(&self) -> u64 {
+        (self.blocks_downloaded * self.block_size) as u64
+    }
+
+    pub fn saved_percentage(&self) -> u64 {
+        if self.target_size == 0 {
+            return 0;
+        }
+        (self.bytes_reused() * 100 / self.target_size).min(100)
+    }
+}
+
 pub struct Updater {
     appimage: AppImage,
     update_info: UpdateInfo,
@@ -107,15 +135,40 @@ impl Updater {
         Ok(true)
     }
 
-    pub fn perform_update(&self) -> Result<PathBuf> {
+    pub fn source_path(&self) -> &Path {
+        self.appimage.path()
+    }
+
+    pub fn source_size(&self) -> u64 {
+        fs::metadata(self.appimage.path())
+            .map(|m| m.len())
+            .unwrap_or(0)
+    }
+
+    pub fn target_info(&self) -> Result<(PathBuf, u64)> {
+        let (control, _zsync_url) = self.fetch_control_file()?;
+        let output_path = self.resolve_output_path(&control)?;
+        Ok((output_path, control.length))
+    }
+
+    pub fn perform_update(&self) -> Result<(PathBuf, UpdateStats)> {
         let (control, zsync_url) = self.fetch_control_file()?;
         let output_path = self.resolve_output_path(&control)?;
 
         if output_path.exists() {
             if let Some(ref expected_sha1) = control.sha1
                 && self.verify_existing_file(&output_path, expected_sha1)?
             {
-                return Ok(output_path);
+                let stats = UpdateStats {
+                    source_path: self.appimage.path().to_path_buf(),
+                    source_size: self.source_size(),
+                    target_path: output_path.clone(),
+                    target_size: control.length,
+                    blocks_reused: 0,
+                    blocks_downloaded: 0,
+                    block_size: control.blocksize,
+                };
+                return Ok((output_path, stats));
             }
 
             if !self.overwrite {
@@ -130,20 +183,25 @@ impl Updater {
             .map(|m| m.permissions())
             .ok();
 
+        let source_size = self.source_size();
+        let target_size = control.length;
+        let block_size = control.blocksize;
+
         let assembly = ZsyncAssembly::from_url(&zsync_url, &output_path)
             .map_err(|e| Error::Zsync(format!("Failed to initialize zsync: {}", e)))?;
 
         let mut assembly = assembly;
 
-        assembly
+        let blocks_reused = assembly
             .submit_source_file(self.appimage.path())
             .map_err(|e| Error::Zsync(format!("Failed to submit source file: {}", e)))?;
 
-        assembly
+        let self_blocks = assembly
             .submit_self_referential()
             .map_err(|e| Error::Zsync(format!("Self-referential scan failed: {}", e)))?;
+        let blocks_reused = blocks_reused.saturating_add(self_blocks);
 
-        assembly
+        let blocks_downloaded = assembly
             .download_missing_blocks()
             .map_err(|e| Error::Zsync(format!("Failed to download blocks: {}", e)))?;
 
@@ -155,7 +213,17 @@ impl Updater {
             fs::set_permissions(&output_path, perms)?;
         }
 
-        Ok(output_path)
+        let stats = UpdateStats {
+            source_path: self.appimage.path().to_path_buf(),
+            source_size,
+            target_path: output_path.clone(),
+            target_size,
+            blocks_reused,
+            blocks_downloaded,
+            block_size,
+        };
+
+        Ok((output_path, stats))
     }
 
     pub fn output_path(&self) -> Result<PathBuf> {
