Route logs to stderr and handle Broken Pipe on stdout

- Move status/progress and summary output to stderr so stdout contains only JSON
- Write a marker line ("✅ Debug output:") to stdout before JSON for test compatibility
- Use explicit stdout write + flush and treat io::ErrorKind::BrokenPipe as a quiet exit (0)
- Preserve behavior for file output; only stdout path is changed

This prevents panics when piping (e.g., ) and keeps pipelines clean while satisfying existing tests.

Author: WendellXY

langcodec-cli/src/debug.rs

@@ -3,25 +3,25 @@ use crate::transformers::custom_format_to_resource;
 
 use langcodec::Codec;
 use std::fs::File;
-use std::io::Write;
+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>) {
     // Read the input file
-    println!("Reading 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()) {
         // Standard format succeeded
     } else if input.ends_with(".json") || input.ends_with(".yaml") || input.ends_with(".yml") {
         // Try custom format for JSON/YAML files
         if let Err(e) = try_custom_format_debug(&input, lang.clone(), &mut codec) {
-            println!("❌ Error reading input file");
+            eprintln!("❌ Error reading input file");
             eprintln!("Error reading {}: {}", input, e);
             std::process::exit(1);
         }
     } else {
-        println!("❌ Error reading input file");
+        eprintln!("❌ Error reading input file");
         // Provide a hint about encoding issues for common Apple .strings files
         eprintln!(
             "Error reading {}: unsupported format or invalid text encoding",
@@ -31,56 +31,78 @@ pub fn run_debug_command(input: String, lang: Option<String>, output: Option<Str
     }
 
     // Validate the codec using the new validation method
-    println!("Validating resources...");
+    eprintln!("Validating resources...");
     if let Err(validation_error) = codec.validate() {
-        println!("⚠️  Validation warnings found");
+        eprintln!("⚠️  Validation warnings found");
         eprintln!("Warning: {}", validation_error);
         // Continue anyway for debug purposes
     } else {
-        println!("✅ Resources validated successfully");
+        eprintln!("✅ Resources validated successfully");
     }
 
     // Convert to JSON
-    println!("Converting to JSON...");
+    eprintln!("Converting to JSON...");
     let json = serde_json::to_string_pretty(&*codec.resources).unwrap_or_else(|e| {
-        println!("❌ Error serializing to JSON");
+        eprintln!("❌ Error serializing to JSON");
         eprintln!("Error serializing to JSON: {}", e);
         std::process::exit(1);
     });
 
     // Output to file or stdout
     let output_to_file = match output {
         Some(output_path) => {
-            println!("Writing output file...");
+            eprintln!("Writing output file...");
             if let Err(e) =
                 File::create(&output_path).and_then(|mut f| f.write_all(json.as_bytes()))
             {
-                println!("❌ Error writing output file");
+                eprintln!("❌ Error writing output file");
                 eprintln!("Error writing to {}: {}", output_path, e);
                 std::process::exit(1);
             }
-            println!("✅ Debug output written to: {}", output_path);
+            eprintln!("✅ Debug output written to: {}", output_path);
             true
         }
         None => {
-            println!("✅ Debug output:");
-            println!("{}", json);
+            // Write marker + JSON to stdout and gracefully handle Broken Pipe
+            let mut stdout = io::stdout().lock();
+            if let Err(e) = stdout.write_all("✅ Debug output:\n".as_bytes()) {
+                if e.kind() == io::ErrorKind::BrokenPipe {
+                    std::process::exit(0);
+                }
+                eprintln!("Error writing to stdout: {}", e);
+                std::process::exit(1);
+            }
+            if let Err(e) = stdout.write_all(json.as_bytes()) {
+                if e.kind() == io::ErrorKind::BrokenPipe {
+                    // Downstream closed the pipe (e.g., `| head`). Exit quietly.
+                    std::process::exit(0);
+                }
+                eprintln!("Error writing to stdout: {}", e);
+                std::process::exit(1);
+            }
+            if let Err(e) = stdout.flush() {
+                if e.kind() == io::ErrorKind::BrokenPipe {
+                    std::process::exit(0);
+                }
+                eprintln!("Error flushing stdout: {}", e);
+                std::process::exit(1);
+            }
             false
         }
     };
 
     // Show additional debug information using the new high-level methods
     if !output_to_file {
-        println!("\n=== Debug Summary ===");
-        println!(
+        eprintln!("\n=== Debug Summary ===");
+        eprintln!(
             "Languages: {}",
             codec.languages().collect::<Vec<_>>().join(", ")
         );
-        println!("Total entries: {}", codec.all_keys().count());
+        eprintln!("Total entries: {}", codec.all_keys().count());
 
         for lang in codec.languages() {
             let count = codec.entry_count(lang);
-            println!("  {}: {} entries", lang, count);
+            eprintln!("  {}: {} entries", lang, count);
         }
     }
 }