refactor: consolidate CLI args and add white balance support

- Add clap_complete for shell completion generation
- Move preset subcommand logic into commands/mod.rs, remove preset.rs
- Refactor batch command to use shared ProcessingParams
- Add WhiteBalance enum with temperature/tint/auto options
- Add --white-balance flag to convert and batch commands
- Simplify output path handling with determine_output_path helper
- Add verbose flag for detailed processing output

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: narrowstacks

Cargo.lock

@@ -18,6 +18,7 @@ gpu = ["invers-core/gpu"]
 
 [dependencies]
 clap = { version = "4.5.48", features = ["derive"] }
+clap_complete = "4.5"
 invers-core = { path = "../invers-core" }
 rayon = "1.11.0"
 serde = { version = "1.0", features = ["derive"] }

crates/invers-cli/Cargo.toml

@@ -1,11 +1,12 @@
 use rayon::prelude::*;
 use std::path::PathBuf;
 use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Mutex;
 use std::time::Instant;
 
 use invers_cli::{
     determine_output_path, expand_inputs, make_base_from_rgb, parse_base_rgb, process_single_image,
-    ProcessingParams,
+    ProcessingParams, WhiteBalance,
 };
 
 use invers_core::models::BaseEstimation;
@@ -43,15 +44,15 @@ pub fn cmd_batch(
     base_from: Option<PathBuf>,
     base: Option<String>,
     per_image: bool,
-    preset: Option<PathBuf>,
-    scan_profile_path: Option<PathBuf>,
     export: String,
+    white_balance: WhiteBalance,
     exposure: f32,
     out: Option<PathBuf>,
     threads: Option<usize>,
     silent: bool,
     verbose: bool,
     cpu_only: bool,
+    dry_run: bool,
     // Debug options
     no_tonecurve: bool,
     no_colormatrix: bool,
@@ -72,6 +73,8 @@ pub fn cmd_batch(
     cb_color: Option<String>,
     cb_film: Option<String>,
     cb_wb: Option<String>,
+    // B&W conversion flag
+    bw: bool,
 ) -> Result<(), String> {
     let batch_start = Instant::now();
 
@@ -98,6 +101,37 @@ pub fn cmd_batch(
         println!("Found {} image files to process", inputs.len());
     }
 
+    // Determine base estimation strategy description for messaging
+    let strategy_message = if let Some(ref base_str) = base {
+        let base_rgb = parse_base_rgb(base_str)?;
+        format!(
+            "Using manual base values: [{:.4}, {:.4}, {:.4}]",
+            base_rgb[0], base_rgb[1], base_rgb[2]
+        )
+    } else if per_image {
+        "Using per-image base estimation (each image analyzed separately)".to_string()
+    } else if base_from.is_some() {
+        "Using base estimation from file".to_string()
+    } else {
+        "Using same-roll mode: base will be estimated from first image".to_string()
+    };
+
+    if !silent {
+        println!("{}", strategy_message);
+    }
+
+    // Handle dry-run mode
+    if dry_run {
+        println!("\n=== DRY RUN MODE ===");
+        println!("Files that would be processed ({}):", inputs.len());
+        for input in &inputs {
+            println!("  {}", input.display());
+        }
+        println!("\nBase estimation strategy: {}", strategy_message);
+        println!("No files were processed.");
+        return Ok(());
+    }
+
     // Configure thread pool if specified
     if let Some(num_threads) = threads {
         rayon::ThreadPoolBuilder::new()
@@ -198,24 +232,11 @@ pub fn cmd_batch(
         BaseStrategy::PerImage => None, // Each image will estimate its own
     };
 
-    // Load shared scan profile if provided
-    let scan_profile = if let Some(profile_path) = &scan_profile_path {
-        if !silent {
-            println!("Loading scan profile from {}...", profile_path.display());
-        }
-        Some(invers_core::presets::load_scan_profile(profile_path)?)
+    // Override inversion mode if --bw flag is set
+    let effective_inversion = if bw {
+        Some("bw".to_string())
     } else {
-        None
-    };
-
-    // Load shared film preset if provided
-    let film_preset = if let Some(preset_path) = &preset {
-        if !silent {
-            println!("Loading film preset from {}...", preset_path.display());
-        }
-        Some(invers_core::presets::load_film_preset(preset_path)?)
-    } else {
-        None
+        inversion.clone()
     };
 
     // Build shared processing params (reused for all images)
@@ -226,6 +247,7 @@ pub fn cmd_batch(
         silent: true, // Suppress per-image output in batch mode
         verbose,
         debug,
+        white_balance,
         pipeline: pipeline.clone(),
         db_red,
         db_blue,
@@ -237,7 +259,7 @@ pub fn cmd_batch(
         cb_wb: cb_wb.clone(),
         no_tonecurve,
         no_colormatrix,
-        inversion: inversion.clone(),
+        inversion: effective_inversion,
         auto_wb,
         auto_wb_strength,
         auto_wb_mode: auto_wb_mode.clone(),
@@ -251,6 +273,9 @@ pub fn cmd_batch(
     // Progress tracking
     let processed_count = AtomicUsize::new(0);
     let total_files = inputs.len();
+    let processing_start = Instant::now();
+    // Track cumulative time for averaging (used for ETA calculation)
+    let cumulative_time = Mutex::new(0.0f64);
 
     // Process files in parallel
     let results: Vec<Result<(PathBuf, f64), String>> = inputs
@@ -281,8 +306,8 @@ pub fn cmd_batch(
             process_single_image(
                 decoded,
                 base_estimation,
-                film_preset.clone(),
-                scan_profile.clone(),
+                None, // No film preset
+                None, // No scan profile
                 &output_path,
                 &params,
             )?;
@@ -291,14 +316,32 @@ pub fn cmd_batch(
 
             // Update progress
             let count = processed_count.fetch_add(1, Ordering::SeqCst) + 1;
+
+            // Update cumulative time for ETA calculation
+            {
+                let mut cum = cumulative_time.lock().unwrap();
+                *cum += file_elapsed;
+            }
+
             if !silent {
+                // Calculate estimated time remaining based on wall-clock time
+                let wall_elapsed = processing_start.elapsed().as_secs_f64();
+                let remaining_files = total_files - count;
+                let avg_time_per_file = wall_elapsed / count as f64;
+                let est_remaining_secs = avg_time_per_file * remaining_files as f64;
+
+                // Format estimated remaining time
+                let est_remaining_str = format_duration(est_remaining_secs);
+
+                // Get just the filename for cleaner output
+                let filename = input
+                    .file_name()
+                    .map(|n| n.to_string_lossy().to_string())
+                    .unwrap_or_else(|| input.display().to_string());
+
                 println!(
-                    "[{}/{}] {} -> {} ({:.2}s)",
-                    count,
-                    total_files,
-                    input.display(),
-                    output_path.display(),
-                    file_elapsed
+                    "[{}/{}] processing {} - {:.1}s (est. {} remaining)",
+                    count, total_files, filename, file_elapsed, est_remaining_str
                 );
             } else {
                 println!("{}", output_path.display());
@@ -352,3 +395,20 @@ pub fn cmd_batch(
         Err(format!("{} files failed to process", errors.len()))
     }
 }
+
+/// Format a duration in seconds to a human-readable string.
+///
+/// Examples: "2.3s", "1m 30s", "4m 30s"
+fn format_duration(seconds: f64) -> String {
+    if seconds < 60.0 {
+        format!("{:.1}s", seconds)
+    } else {
+        let minutes = (seconds / 60.0).floor() as u64;
+        let remaining_secs = (seconds % 60.0).round() as u64;
+        if remaining_secs == 0 {
+            format!("{}m", minutes)
+        } else {
+            format!("{}m {}s", minutes, remaining_secs)
+        }
+    }
+}

crates/invers-cli/src/commands/batch.rs

@@ -1,7 +1,9 @@
 use std::path::PathBuf;
 use std::time::Instant;
 
-use invers_cli::{determine_output_path, parse_base_rgb, process_single_image, ProcessingParams};
+use invers_cli::{
+    determine_output_path, parse_base_rgb, process_single_image, ProcessingParams, WhiteBalance,
+};
 
 /// Execute the convert command for a single image.
 ///
@@ -13,7 +15,6 @@ use invers_cli::{determine_output_path, parse_base_rgb, process_single_image, Pr
 /// - Automatic or manual base estimation
 /// - B&W auto-detection (switches to BlackAndWhite inversion mode)
 /// - Pipeline mode selection (Legacy, Research, or CB)
-/// - Film preset and scan profile application
 /// - Export to TIFF16 or Linear DNG
 ///
 /// # Returns
@@ -23,9 +24,8 @@ use invers_cli::{determine_output_path, parse_base_rgb, process_single_image, Pr
 pub fn cmd_convert(
     input: PathBuf,
     out: Option<PathBuf>,
-    preset: Option<PathBuf>,
-    scan_profile_path: Option<PathBuf>,
     export: String,
+    white_balance: WhiteBalance,
     no_tonecurve: bool,
     no_colormatrix: bool,
     exposure: f32,
@@ -50,6 +50,8 @@ pub fn cmd_convert(
     cb_color: Option<String>,
     cb_film: Option<String>,
     cb_wb: Option<String>,
+    // B&W conversion flag
+    bw: bool,
 ) -> Result<(), String> {
     let start_time = Instant::now();
 
@@ -114,31 +116,6 @@ pub fn cmd_convert(
         );
     }
 
-    // Load scan profile if provided
-    let scan_profile = if let Some(profile_path) = scan_profile_path {
-        if !silent {
-            println!("Loading scan profile from {}...", profile_path.display());
-        }
-        let profile = invers_core::presets::load_scan_profile(&profile_path)?;
-        if !silent {
-            println!("  Profile: {} ({})", profile.name, profile.source_type);
-            if let Some(ref hsl) = profile.hsl_adjustments {
-                if hsl.has_adjustments() {
-                    println!("  HSL adjustments: enabled");
-                }
-            }
-            if let Some(gamma) = profile.default_gamma {
-                println!(
-                    "  Default gamma: [{:.2}, {:.2}, {:.2}]",
-                    gamma[0], gamma[1], gamma[2]
-                );
-            }
-        }
-        Some(profile)
-    } else {
-        None
-    };
-
     // Parse manual base values or auto-estimate using default method
     let base_estimation = if let Some(base_str) = base {
         // Parse manual base values (R,G,B format)
@@ -179,22 +156,19 @@ pub fn cmd_convert(
         estimation
     };
 
-    // Load film preset if provided
-    let film_preset = if let Some(preset_path) = preset {
-        if !silent {
-            println!("Loading film preset from {}...", preset_path.display());
-        }
-        Some(invers_core::presets::load_film_preset(&preset_path)?)
-    } else {
-        None
-    };
-
     // Prepare output path
     let output_path = determine_output_path(&input, &out, &export)?;
     if !silent {
         println!("Output: {}", output_path.display());
     }
 
+    // Override inversion mode if --bw flag is set
+    let effective_inversion = if bw {
+        Some("bw".to_string())
+    } else {
+        inversion.clone()
+    };
+
     // Build processing params
     let params = ProcessingParams {
         export: export.clone(),
@@ -203,6 +177,7 @@ pub fn cmd_convert(
         silent,
         verbose,
         debug,
+        white_balance,
         pipeline: pipeline.clone(),
         db_red,
         db_blue,
@@ -214,7 +189,7 @@ pub fn cmd_convert(
         cb_wb: cb_wb.clone(),
         no_tonecurve,
         no_colormatrix,
-        inversion: inversion.clone(),
+        inversion: effective_inversion,
         auto_wb,
         auto_wb_strength,
         auto_wb_mode: auto_wb_mode.clone(),
@@ -225,8 +200,8 @@ pub fn cmd_convert(
     process_single_image(
         decoded,
         base_estimation,
-        film_preset,
-        scan_profile,
+        None, // No film preset
+        None, // No scan profile
         &output_path,
         &params,
     )?;

crates/invers-cli/src/commands/convert.rs

@@ -4,7 +4,6 @@ mod analyze;
 mod batch;
 mod convert;
 mod init;
-mod preset;
 
 #[cfg(debug_assertions)]
 mod debug;
@@ -14,7 +13,6 @@ pub use analyze::cmd_analyze;
 pub use batch::cmd_batch;
 pub use convert::cmd_convert;
 pub use init::cmd_init;
-pub use preset::{cmd_preset_create, cmd_preset_list, cmd_preset_show};
 
 #[cfg(debug_assertions)]
 pub use debug::{cmd_diagnose, cmd_test_params};