Add global --strict mode and Diff command

Introduce a global --strict flag and strict parsing behavior across the CLI, plus a new Diff subcommand and additional sync options.

- README: document Global strict mode.
- CLI: add global `--strict` arg and `Diff` subcommand; add sync flags `--report-json`, `--fail-on-unmatched`, `--fail-on-ambiguous`.
- convert.rs: propagate `strict` into run_unified_convert_command; implement strict branches that enforce explicit-format conversions, custom-format validation, or extension-only conversion and exit nonzero on failure; update read_resources_from_any_input to accept `strict` and perform stricter parsing/validation when enabled.
- debug.rs / merge.rs / main.rs: propagate `strict` through command handlers and file-read helpers; add strict-aware flows for debug, merge, view, sync commands.
- Tests: add CLI tests for sync report JSON, fail-on-unmatched behavior, and strict-mode failure on unmatched entries.

These changes make parser fallbacks opt-in (disabled under --strict) and add a file-comparison command and sync-related features.

Author: WendellXY

langcodec-cli/README.md

@@ -126,6 +126,7 @@ Supported formats: .strings, .xml (Android), .xcstrings, .csv, .tsv. Custom JSON
 - Android plurals `<plurals>` are supported.
 - Language inference: `en.lproj/Localizable.strings`, `values-es/strings.xml`, base `values/` → `en` by default.
 - Globbing: use quotes for patterns in merge and edit (e.g., `'**/*.xml'`).
+- Global strict mode: add `--strict` before any subcommand to disable parser fallbacks and enforce stricter failures.
 
 ## License
 

langcodec-cli/src/convert.rs

@@ -16,7 +16,12 @@ pub struct ConvertOptions {
     pub include_lang: Vec<String>,
 }
 
-pub fn run_unified_convert_command(input: String, output: String, options: ConvertOptions) {
+pub fn run_unified_convert_command(
+    input: String,
+    output: String,
+    options: ConvertOptions,
+    strict: bool,
+) {
     // Special handling: when targeting xcstrings, ensure required metadata exists.
     // If source_language/version are missing, default to en/1.0 respectively.
     let wants_xcstrings = output.ends_with(".xcstrings")
@@ -26,7 +31,7 @@ pub fn run_unified_convert_command(input: String, output: String, options: Conve
             .is_some_and(|s| s.eq_ignore_ascii_case("xcstrings"));
     if wants_xcstrings {
         println!("Converting to xcstrings with default sourceLanguage if missing...");
-        match read_resources_from_any_input(&input, options.input_format.as_ref()).and_then(
+        match read_resources_from_any_input(&input, options.input_format.as_ref(), strict).and_then(
             |mut resources| {
                 // Determine source_language priority: explicit flag > metadata > default
                 let source_language = options
@@ -110,7 +115,7 @@ pub fn run_unified_convert_command(input: String, output: String, options: Conve
             "Converting input to .langcodec (Resource JSON array){}...",
             filter_msg
         );
-        match read_resources_from_any_input(&input, options.input_format.as_ref()).and_then(
+        match read_resources_from_any_input(&input, options.input_format.as_ref(), strict).and_then(
             |resources| {
                 // Apply language filtering
                 let filtered_resources = resources
@@ -179,6 +184,46 @@ pub fn run_unified_convert_command(input: String, output: String, options: Conve
         }
     }
 
+    if strict {
+        if let (Some(input_fmt), Some(output_fmt)) = (
+            options.input_format.as_deref(),
+            options.output_format.as_deref(),
+        ) {
+            println!("Strict mode: converting with explicit format hints only...");
+            if let Err(e) = try_explicit_format_conversion(&input, &output, input_fmt, output_fmt) {
+                println!("❌ Strict conversion failed");
+                eprintln!("Error: {}", e);
+                std::process::exit(1);
+            }
+            println!("✅ Successfully converted in strict mode");
+            return;
+        }
+
+        if input.ends_with(".json")
+            || input.ends_with(".yaml")
+            || input.ends_with(".yml")
+            || input.ends_with(".langcodec")
+        {
+            println!("Strict mode: converting custom format without fallback...");
+            if let Err(e) = try_custom_format_conversion(&input, &output, &options.input_format) {
+                println!("❌ Strict conversion failed");
+                eprintln!("Error: {}", e);
+                std::process::exit(1);
+            }
+            println!("✅ Successfully converted in strict mode");
+            return;
+        }
+
+        println!("Strict mode: converting using extension-based standard formats only...");
+        if let Err(e) = convert_auto(&input, &output) {
+            println!("❌ Strict conversion failed");
+            eprintln!("Error: {}", e);
+            std::process::exit(1);
+        }
+        println!("✅ Successfully converted in strict mode");
+        return;
+    }
+
     // Strategy 1: Try standard lib crate conversion first
     println!("Trying standard format detection from file extensions...");
     if let Ok(()) = convert_auto(&input, &output) {
@@ -433,7 +478,67 @@ fn write_resources_as_langcodec(
 pub fn read_resources_from_any_input(
     input: &str,
     input_format_hint: Option<&String>,
+    strict: bool,
 ) -> Result<Vec<langcodec::Resource>, String> {
+    if strict {
+        if let Some(fmt) = input_format_hint {
+            let fmt_lower = fmt.to_lowercase();
+            let maybe_std = match fmt_lower.as_str() {
+                "strings" => Some(langcodec::formats::FormatType::Strings(None)),
+                "android" | "androidstrings" => {
+                    Some(langcodec::formats::FormatType::AndroidStrings(None))
+                }
+                "xcstrings" => Some(langcodec::formats::FormatType::Xcstrings),
+                "csv" => Some(langcodec::formats::FormatType::CSV),
+                "tsv" => Some(langcodec::formats::FormatType::TSV),
+                _ => None,
+            };
+
+            if let Some(std_fmt) = maybe_std {
+                let mut codec = Codec::new();
+                codec
+                    .read_file_by_type(input, std_fmt)
+                    .map_err(|e| format!("Failed to read input with explicit format: {}", e))?;
+                return Ok(codec.resources);
+            }
+
+            let custom_format = parse_custom_format(fmt)?;
+            let resources = custom_format_to_resource(input.to_string(), custom_format)?;
+            return Ok(resources);
+        }
+
+        if input.ends_with(".strings")
+            || input.ends_with(".xml")
+            || input.ends_with(".xcstrings")
+            || input.ends_with(".csv")
+            || input.ends_with(".tsv")
+        {
+            let mut codec = Codec::new();
+            codec
+                .read_file_by_extension(input, None)
+                .map_err(|e| format!("Failed to read input: {}", e))?;
+            return Ok(codec.resources);
+        }
+
+        if input.ends_with(".json")
+            || input.ends_with(".yaml")
+            || input.ends_with(".yml")
+            || input.ends_with(".langcodec")
+        {
+            validate_custom_format_file(input)?;
+            let file_content = std::fs::read_to_string(input)
+                .map_err(|e| format!("Error reading file {}: {}", input, e))?;
+            let custom_format = formats::validate_custom_format_content(input, &file_content)?;
+            let resources = custom_format_to_resource(input.to_string(), custom_format)?;
+            return Ok(resources);
+        }
+
+        return Err(format!(
+            "Unsupported input format or file extension: '{}'. Supported formats: .strings, .xml, .xcstrings, .csv, .tsv, .json, .yaml, .yml, .langcodec",
+            input
+        ));
+    }
+
     // First: if explicit input format is provided and is a standard format, use it
     if let Some(fmt) = input_format_hint {
         let fmt_lower = fmt.to_lowercase();

langcodec-cli/src/debug.rs

@@ -6,14 +6,32 @@ use std::fs::File;
 use std::io::{self, Write};
 
 /// Run the debug command: read a localization file and output as JSON.
-pub fn run_debug_command(input: String, lang: Option<String>, output: Option<String>) {
+pub fn run_debug_command(
+    input: String,
+    lang: Option<String>,
+    output: Option<String>,
+    strict: bool,
+) {
     // Read the input file
     eprintln!("Reading input file...");
     let mut codec = Codec::new();
-    // Try standard format first
-    if let Ok(()) = codec.read_file_by_extension(&input, lang.clone()) {
+    let is_custom_ext =
+        input.ends_with(".json") || input.ends_with(".yaml") || input.ends_with(".yml");
+    if strict {
+        if is_custom_ext {
+            if let Err(e) = try_custom_format_debug(&input, lang.clone(), &mut codec) {
+                eprintln!("❌ Error reading input file");
+                eprintln!("Error reading {}: {}", input, e);
+                std::process::exit(1);
+            }
+        } else if let Err(e) = codec.read_file_by_extension(&input, lang.clone()) {
+            eprintln!("❌ Error reading input file");
+            eprintln!("Error reading {}: {}", input, e);
+            std::process::exit(1);
+        }
+    } else if let Ok(()) = codec.read_file_by_extension(&input, lang.clone()) {
         // Standard format succeeded
-    } else if input.ends_with(".json") || input.ends_with(".yaml") || input.ends_with(".yml") {
+    } else if is_custom_ext {
         // Try custom format for JSON/YAML files
         if let Err(e) = try_custom_format_debug(&input, lang.clone(), &mut codec) {
             eprintln!("❌ Error reading input file");