chore: update .gitignore and enhance code safety with clippy lints

- Added .claude/settings.local.json to .gitignore to prevent local configuration files from being tracked.
- Introduced clippy lints to suppress warnings for functions with too many arguments in invers-cli and invers-core.
- Improved code formatting and readability in various files, including adjustments to arithmetic operations and test data initialization.

Author: narrowstacks

.claude/settings.local.json

@@ -34,7 +34,8 @@
       "Bash(curl:*)",
       "Bash(./scripts/update-formula.sh:*)",
       "Bash(tar:*)",
-      "Bash(cargo check:*)"
+      "Bash(cargo check:*)",
+      "Bash(cargo clippy:*)"
     ],
     "deny": [],
     "ask": []

.gitignore

@@ -31,3 +31,4 @@ target/
 OPTIMIZATION_SUMMARY.md
 
 docs/
+.claude/settings.local.json

crates/invers-cli/src/lib.rs

@@ -163,6 +163,7 @@ pub fn parse_inversion_mode(
 ///
 /// This function centralizes the logic for building ConvertOptions with all
 /// pipeline defaults, making it reusable across CLI and GUI applications.
+#[allow(clippy::too_many_arguments)]
 pub fn build_convert_options(
     input: PathBuf,
     output_dir: PathBuf,
@@ -191,6 +192,7 @@ pub fn build_convert_options(
 }
 
 /// Build a ConvertOptions struct with explicit inversion mode override
+#[allow(clippy::too_many_arguments)]
 pub fn build_convert_options_with_inversion(
     input: PathBuf,
     output_dir: PathBuf,
@@ -225,6 +227,7 @@ pub fn build_convert_options_with_inversion(
 }
 
 /// Build a ConvertOptions struct with all options
+#[allow(clippy::too_many_arguments)]
 pub fn build_convert_options_full(
     input: PathBuf,
     output_dir: PathBuf,
@@ -266,6 +269,7 @@ pub fn build_convert_options_full(
 }
 
 /// Build a ConvertOptions struct with all options including GPU control
+#[allow(clippy::too_many_arguments)]
 pub fn build_convert_options_full_with_gpu(
     input: PathBuf,
     output_dir: PathBuf,

crates/invers-cli/src/main.rs

@@ -428,6 +428,7 @@ fn main() {
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn cmd_convert(
     input: PathBuf,
     out: Option<PathBuf>,
@@ -824,7 +825,7 @@ fn cmd_analyze(
     // Parse base estimation method
     let method = match base_method.to_lowercase().as_str() {
         "border" => invers_core::models::BaseEstimationMethod::Border,
-        "regions" | _ => invers_core::models::BaseEstimationMethod::Regions,
+        _ => invers_core::models::BaseEstimationMethod::Regions,
     };
 
     // Estimate base
@@ -927,6 +928,7 @@ fn cmd_analyze(
     Ok(())
 }
 
+#[allow(clippy::too_many_arguments)]
 fn cmd_batch(
     inputs: Vec<PathBuf>,
     base_from: Option<PathBuf>,
@@ -1299,8 +1301,8 @@ fn cmd_init(force: bool) -> Result<(), String> {
 }
 
 fn copy_dir_contents(
-    src: &PathBuf,
-    dst: &PathBuf,
+    src: &std::path::Path,
+    dst: &std::path::Path,
     force: bool,
     indent: &str,
 ) -> Result<(), String> {
@@ -1335,6 +1337,7 @@ fn copy_dir_contents(
     Ok(())
 }
 
+#[allow(clippy::too_many_arguments)]
 fn cmd_diagnose(
     original: PathBuf,
     third_party: PathBuf,
@@ -1459,6 +1462,7 @@ fn cmd_diagnose(
     Ok(())
 }
 
+#[allow(clippy::too_many_arguments)]
 fn cmd_test_params(
     original: PathBuf,
     reference: PathBuf,

crates/invers-core/src/auto_adjust.rs

@@ -1238,7 +1238,7 @@ fn auto_exposure_impl(
         }
     } else {
         for value in data.iter_mut() {
-            *value = *value * gain;
+            *value *= gain;
         }
     }
 
@@ -1329,15 +1329,8 @@ mod tests {
     fn test_otsu_threshold_bimodal() {
         // Create truly bimodal distribution with clear separation
         // All low values exactly at 0.2, all high values exactly at 0.8
-        let mut data = Vec::new();
-        // Low cluster: 500 samples at 0.2
-        for _ in 0..500 {
-            data.push(0.2);
-        }
-        // High cluster: 500 samples at 0.8
-        for _ in 0..500 {
-            data.push(0.8);
-        }
+        let mut data = vec![0.2; 500]; // Low cluster: 500 samples at 0.2
+        data.extend(vec![0.8; 500]); // High cluster: 500 samples at 0.8
 
         let result = otsu_threshold(&data);
 
@@ -1364,19 +1357,9 @@ mod tests {
     #[test]
     fn test_measure_dark_mid_light() {
         // Create data with known distribution
-        let mut data = Vec::new();
-        // 25% dark (0.0-0.25)
-        for _ in 0..25 {
-            data.push(0.1);
-        }
-        // 50% mid (0.25-0.75)
-        for _ in 0..50 {
-            data.push(0.5);
-        }
-        // 25% light (0.75-1.0)
-        for _ in 0..25 {
-            data.push(0.9);
-        }
+        let mut data = vec![0.1; 25]; // 25% dark (0.0-0.25)
+        data.extend(vec![0.5; 50]); // 50% mid (0.25-0.75)
+        data.extend(vec![0.9; 25]); // 25% light (0.75-1.0)
 
         let (dark, mid, light) = measure_dark_mid_light(&data);
 

crates/invers-core/src/color.rs

@@ -229,13 +229,13 @@ const D65_Z: f32 = 1.08883;
 const SRGB_TO_XYZ: [[f32; 3]; 3] = [
     [0.4124564, 0.3575761, 0.1804375],
     [0.2126729, 0.7151522, 0.0721750],
-    [0.0193339, 0.1191920, 0.9503041],
+    [0.0193339, 0.119_192, 0.9503041],
 ];
 
 /// XYZ to sRGB matrix (D65)
 const XYZ_TO_SRGB: [[f32; 3]; 3] = [
     [3.2404542, -1.5371385, -0.4985314],
-    [-0.9692660, 1.8760108, 0.0415560],
+    [-0.969_266, 1.8760108, 0.0415560],
     [0.0556434, -0.2040259, 1.0572252],
 ];
 

crates/invers-core/src/gpu/context.rs

@@ -154,13 +154,15 @@ impl GpuContext {
 
         // Request device with required features and higher buffer limits for large images
         // Large scans (e.g., 4000x6000 @ 48-bit) can exceed 200MB
-        let mut limits = wgpu::Limits::default();
-        // Request max storage buffer size from adapter (for image data)
-        limits.max_storage_buffer_binding_size = adapter_limits.max_storage_buffer_binding_size;
-        // Also increase uniform buffer size if needed
-        limits.max_uniform_buffer_binding_size = adapter_limits.max_uniform_buffer_binding_size;
-        // Increase buffer size limit
-        limits.max_buffer_size = adapter_limits.max_buffer_size;
+        let limits = wgpu::Limits {
+            // Request max storage buffer size from adapter (for image data)
+            max_storage_buffer_binding_size: adapter_limits.max_storage_buffer_binding_size,
+            // Also increase uniform buffer size if needed
+            max_uniform_buffer_binding_size: adapter_limits.max_uniform_buffer_binding_size,
+            // Increase buffer size limit
+            max_buffer_size: adapter_limits.max_buffer_size,
+            ..Default::default()
+        };
 
         let (device, queue) = adapter
             .request_device(

crates/invers-core/src/gpu/pipeline.rs

@@ -401,7 +401,7 @@ fn clear_histogram(ctx: &GpuContext, histogram: &GpuHistogram) -> Result<(), Gpu
         pass.set_pipeline(&ctx.pipelines.histogram_clear);
         pass.set_bind_group(0, &bind_group, &[]);
 
-        let workgroups = (NUM_HISTOGRAM_BUCKETS as u32 + WORKGROUP_SIZE - 1) / WORKGROUP_SIZE;
+        let workgroups = (NUM_HISTOGRAM_BUCKETS as u32).div_ceil(WORKGROUP_SIZE);
         pass.dispatch_workgroups(workgroups, 1, 1);
     }
 
@@ -501,14 +501,14 @@ fn accumulate_histogram(
         pass.set_bind_group(0, &bind_group, &[]);
 
         let pixel_count = image.pixel_count();
-        let total_workgroups = (pixel_count + WORKGROUP_SIZE - 1) / WORKGROUP_SIZE;
+        let total_workgroups = pixel_count.div_ceil(WORKGROUP_SIZE);
 
         // Use 2D dispatch for large images
         let (workgroups_x, workgroups_y) = if total_workgroups <= MAX_WORKGROUPS_PER_DIM {
             (total_workgroups, 1)
         } else {
             let side = ((total_workgroups as f64).sqrt().ceil() as u32).min(MAX_WORKGROUPS_PER_DIM);
-            let other = (total_workgroups + side - 1) / side;
+            let other = total_workgroups.div_ceil(side);
             (side, other.min(MAX_WORKGROUPS_PER_DIM))
         };
         pass.dispatch_workgroups(workgroups_x, workgroups_y, 1);
@@ -784,6 +784,7 @@ fn clamp_working_range(
 const MAX_WORKGROUPS_PER_DIM: u32 = 65535;
 
 /// Maximum pixels per single dispatch (65535 workgroups * 256 threads)
+#[allow(dead_code)]
 const MAX_PIXELS_PER_DISPATCH: u32 = MAX_WORKGROUPS_PER_DIM * WORKGROUP_SIZE;
 
 /// Generic compute dispatch for storage + uniform pattern
@@ -838,7 +839,7 @@ fn dispatch_compute(
         ],
     });
 
-    let total_workgroups = (pixel_count + WORKGROUP_SIZE - 1) / WORKGROUP_SIZE;
+    let total_workgroups = pixel_count.div_ceil(WORKGROUP_SIZE);
 
     // If within limits, do a single dispatch
     if total_workgroups <= MAX_WORKGROUPS_PER_DIM {
@@ -865,7 +866,7 @@ fn dispatch_compute(
         // This allows up to 65535 * 65535 workgroups = ~4 billion workgroups
         // Calculate grid dimensions: try to make it roughly square for efficiency
         let side = ((total_workgroups as f64).sqrt().ceil() as u32).min(MAX_WORKGROUPS_PER_DIM);
-        let workgroups_y = (total_workgroups + side - 1) / side;
+        let workgroups_y = total_workgroups.div_ceil(side);
 
         if workgroups_y > MAX_WORKGROUPS_PER_DIM {
             return Err(GpuError::Other(format!(
@@ -902,7 +903,7 @@ fn dispatch_compute(
 /// CPU-side base estimation (statistical analysis)
 fn estimate_base_cpu(decoded: &DecodedImage, _options: &ConvertOptions) -> BaseEstimation {
     // Delegate to the existing CPU implementation
-    crate::pipeline::estimate_base(decoded, None, None, None).unwrap_or_else(|_| BaseEstimation {
+    crate::pipeline::estimate_base(decoded, None, None, None).unwrap_or(BaseEstimation {
         roi: None,
         medians: [0.5, 0.5, 0.5],
         noise_stats: None,
@@ -978,10 +979,10 @@ fn compute_auto_color_gains(
         let mut sum: f64 = 0.0;
         let mut count: u64 = 0;
 
-        for i in low_idx..=high_idx.min(buckets - 1) {
+        for (i, &bin_count) in hist.iter().enumerate().take(high_idx.min(buckets - 1) + 1).skip(low_idx) {
             let value = i as f64 / buckets as f64;
-            sum += value * hist[i] as f64;
-            count += hist[i] as u64;
+            sum += value * bin_count as f64;
+            count += bin_count as u64;
         }
 
         if count > 0 {

crates/invers-core/src/gpu/tests.rs

@@ -3,6 +3,7 @@
 use super::*;
 use crate::decoders::DecodedImage;
 
+#[allow(dead_code)]
 const TOLERANCE: f32 = 1e-4; // Allow small floating-point variance
 
 /// Generate a test gradient image
@@ -28,6 +29,8 @@ fn generate_test_gradient(width: u32, height: u32) -> DecodedImage {
         black_level: None,
         white_level: None,
         color_matrix: None,
+        is_monochrome: false,
+        source_is_grayscale: false,
     }
 }
 
@@ -205,6 +208,8 @@ fn generate_test_negative(width: u32, height: u32) -> DecodedImage {
         black_level: None,
         white_level: None,
         color_matrix: None,
+        is_monochrome: false,
+        source_is_grayscale: false,
     }
 }
 
@@ -253,6 +258,7 @@ fn create_test_options(use_gpu: bool) -> crate::models::ConvertOptions {
         auto_exposure_max_gain: 2.0,
         no_clip: true, // Preserve full range for comparison
         enable_auto_wb: false,
+        auto_wb_strength: 0.5,
         use_gpu,
     }
 }

crates/invers-core/src/pipeline.rs

@@ -270,7 +270,7 @@ pub fn process_image(
             let safe_exposure = options.exposure_compensation.min(1.0);
             if safe_exposure < 1.0 {
                 for value in data.iter_mut() {
-                    *value = *value * safe_exposure;
+                    *value *= safe_exposure;
                 }
             }
             if options.debug && options.exposure_compensation > 1.0 {
@@ -507,6 +507,7 @@ fn estimate_base_from_manual_roi(
 /// - Near-white clipped pixels (all channels > 0.95)
 /// - Very dark pixels (all channels < 0.05)
 /// - Bright grayscale pixels without color variation (not orange mask)
+///
 /// Filter results from base pixel filtering
 struct FilteredBasePixels {
     /// Valid pixels that passed filtering
@@ -1084,9 +1085,9 @@ fn estimate_base_from_histogram(image: &DecodedImage) -> Result<BaseEstimation,
         let mut peak_bin = min_bin;
         let mut peak_count = 0u32;
 
-        for bin in min_bin..=max_bin {
-            if hist[bin] > peak_count {
-                peak_count = hist[bin];
+        for (bin, &count) in hist.iter().enumerate().take(max_bin + 1).skip(min_bin) {
+            if count > peak_count {
+                peak_count = count;
                 peak_bin = bin;
             }
         }
@@ -1503,7 +1504,7 @@ pub fn invert_negative(
             let mask_profile = base
                 .mask_profile
                 .clone()
-                .unwrap_or_else(crate::models::MaskProfile::default);
+                .unwrap_or_default();
 
             // Calculate shadow floor values
             let (_red_floor, green_floor, blue_floor) = mask_profile.calculate_shadow_floors();