fix(cli): honor normalize output semantics and check safety

Author: WendellXY

langcodec-cli/src/main.rs

@@ -201,7 +201,7 @@ enum Commands {
     /// Normalize localization files.
     Normalize {
         /// The input files to normalize (supports glob patterns). Quote patterns to avoid shell expansion.
-        #[arg(short, long, num_args = 1.., help = "Input files. Supports glob patterns. Quote patterns to avoid slow shell-side expansion (e.g., '/path/**/*/Localizable.strings').")]
+        #[arg(short, long, required = true, num_args = 1.., help = "Input files. Supports glob patterns. Quote patterns to avoid slow shell-side expansion (e.g., '/path/**/*/Localizable.strings').")]
         inputs: Vec<String>,
 
         /// Optional output file (single-file mode only). If omitted, writes in-place.

langcodec-cli/src/normalize.rs

@@ -3,6 +3,7 @@ use crate::validation::{validate_file_path, validate_output_path};
 use langcodec::{
     Codec, FormatType, KeyStyle, NormalizeOptions as EngineNormalizeOptions, normalize_codec,
 };
+use std::path::Path;
 
 #[derive(Debug, Clone)]
 pub struct NormalizeCliOptions {
@@ -61,6 +62,12 @@ fn write_back(codec: &Codec, input_path: &str, output_path: &Option<String>) ->
     }
 }
 
+fn has_distinct_output_path(input_path: &str, output_path: &Option<String>) -> bool {
+    output_path
+        .as_ref()
+        .is_some_and(|output| Path::new(output) != Path::new(input_path))
+}
+
 pub fn run_normalize_command(opts: NormalizeCliOptions) -> Result<(), String> {
     let expanded = path_glob::expand_input_globs(&opts.inputs)
         .map_err(|e| format!("Failed to expand input patterns: {}", e))?;
@@ -73,9 +80,6 @@ pub fn run_normalize_command(opts: NormalizeCliOptions) -> Result<(), String> {
 
     let input = &expanded[0];
     validate_file_path(input)?;
-    if let Some(output) = &opts.output {
-        validate_output_path(output)?;
-    }
 
     let mut codec = Codec::new();
     codec
@@ -92,21 +96,44 @@ pub fn run_normalize_command(opts: NormalizeCliOptions) -> Result<(), String> {
     )
     .map_err(|e| e.to_string())?;
 
-    if !report.changed {
+    if opts.check {
+        if report.changed {
+            println!("would change: {}", input);
+            return Err(format!("would change: {}", input));
+        }
+
         println!("No changes needed: {}", input);
         return Ok(());
     }
 
-    if opts.check {
-        println!("would change: {}", input);
-        return Err(format!("would change: {}", input));
+    if opts.dry_run {
+        if report.changed {
+            println!("DRY-RUN: would change {}", input);
+        } else {
+            println!("No changes needed: {}", input);
+        }
+        return Ok(());
     }
 
-    if opts.dry_run {
-        println!("DRY-RUN: would change {}", input);
+    if !report.changed {
+        if has_distinct_output_path(input, &opts.output) {
+            if let Some(output) = &opts.output {
+                validate_output_path(output)?;
+            }
+            write_back(&codec, input, &opts.output)?;
+            println!("No changes needed: {}", input);
+            println!("✅ Wrote output: {}", opts.output.as_deref().unwrap_or(input));
+            return Ok(());
+        }
+
+        println!("No changes needed: {}", input);
         return Ok(());
     }
 
+    if let Some(output) = &opts.output {
+        validate_output_path(output)?;
+    }
+
     write_back(&codec, input, &opts.output)?;
     println!("✅ Normalized: {}", opts.output.as_deref().unwrap_or(input));
     Ok(())

langcodec-cli/tests/normalize_cli_tests.rs

@@ -14,6 +14,14 @@ fn test_main_help_lists_normalize() {
     assert!(stdout.contains("normalize"));
 }
 
+#[test]
+fn test_normalize_requires_inputs_argument() {
+    let output = langcodec_cmd().args(["normalize"]).output().unwrap();
+    assert!(!output.status.success());
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(stderr.contains("--inputs"));
+}
+
 #[test]
 fn test_normalize_command_executes_successfully() {
     let temp_dir = TempDir::new().unwrap();
@@ -79,3 +87,78 @@ fn test_normalize_dry_run_does_not_write() {
     let after = fs::read_to_string(&input).unwrap();
     assert_eq!(after, before);
 }
+
+#[test]
+fn test_normalize_output_written_even_when_unchanged() {
+    let temp_dir = TempDir::new().unwrap();
+    let input = temp_dir.path().join("en.strings");
+    let output_path = temp_dir.path().join("out").join("normalized.strings");
+    fs::write(&input, "\"a\" = \"A\";\n\"b\" = \"B\";\n").unwrap();
+
+    let output = langcodec_cmd()
+        .args([
+            "normalize",
+            "-i",
+            input.to_str().unwrap(),
+            "-o",
+            output_path.to_str().unwrap(),
+        ])
+        .output()
+        .unwrap();
+
+    assert!(
+        output.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+    assert!(output_path.exists(), "expected output file to be created");
+
+    let written = fs::read_to_string(&output_path).unwrap();
+    assert!(written.contains("\"a\" = \"A\";"));
+    assert!(written.contains("\"b\" = \"B\";"));
+}
+
+#[test]
+fn test_normalize_check_and_dry_run_with_output_do_not_create_directories() {
+    for mode in ["--check", "--dry-run"] {
+        let temp_dir = TempDir::new().unwrap();
+        let input = temp_dir.path().join("en.strings");
+        let missing_parent = temp_dir.path().join("missing").join("nested");
+        let output_path = missing_parent.join("out.strings");
+        fs::write(&input, "\"z\" = \"%@\";\n\"a\" = \"A\";\n").unwrap();
+
+        let output = langcodec_cmd()
+            .args([
+                "normalize",
+                "-i",
+                input.to_str().unwrap(),
+                "-o",
+                output_path.to_str().unwrap(),
+                mode,
+            ])
+            .output()
+            .unwrap();
+
+        if mode == "--check" {
+            assert!(
+                !output.status.success(),
+                "check mode should fail when drift is detected"
+            );
+        } else {
+            assert!(
+                output.status.success(),
+                "dry-run failed with stderr: {}",
+                String::from_utf8_lossy(&output.stderr)
+            );
+        }
+
+        assert!(
+            !missing_parent.exists(),
+            "mode {mode} unexpectedly created output directory"
+        );
+        assert!(
+            !output_path.exists(),
+            "mode {mode} unexpectedly created output file"
+        );
+    }
+}