Add stats command to show translation coverage

Introduces a new `stats` subcommand to the CLI for displaying translation coverage and per-status counts, with support for JSON output. Implements the core logic in a new `stats.rs` module and adds integration tests for the feature.

Author: WendellXY

ROADMAP.md

@@ -11,6 +11,7 @@ Legend: [ ] todo, [x] done, [~] in progress
 - [x] Symmetric language matching for multi‑language formats (`xcstrings`, `csv`, `tsv`)
 - [x] CLI view prints “Type: Plural” and plural categories
 - [x] Conversion tests: CSV→Android, XCStrings→Android (with plurals)
+- [x] CLI `stats` subcommand (per-language counts, completion %, JSON output)
 
 ---
 
@@ -59,8 +60,10 @@ For each new format:
 - [ ] `diff` subcommand
   - [ ] Compare two files; output added/removed/changed keys by language
   - [ ] Machine‑readable JSON output and pretty mode
-- [ ] `stats` subcommand
-  - [ ] Per‑language counts by `EntryStatus`, completion %, missing plurals
+- [x] `stats` subcommand
+  - [x] Per‑language counts by `EntryStatus`
+  - [x] Completion percent (excludes DoNotTranslate)
+  - [ ] Missing plurals (depends on plural rules engine in M1)
 - [ ] `normalize` subcommand
   - [ ] Canonicalize whitespace, escapes, key casing; optional rules
 - [ ] Filters and export

langcodec-cli/src/main.rs

@@ -6,6 +6,7 @@ mod path_glob;
 mod transformers;
 mod validation;
 mod view;
+mod stats;
 
 use crate::convert::{ConvertOptions, run_unified_convert_command, try_custom_format_view};
 use crate::debug::run_debug_command;
@@ -101,6 +102,19 @@ enum Commands {
         version: Option<String>,
     },
 
+    /// Show translation coverage and per-status counts.
+    Stats {
+        /// The input file to analyze
+        #[arg(short, long)]
+        input: String,
+        /// Optional language code to filter by
+        #[arg(short, long)]
+        lang: Option<String>,
+        /// Output JSON instead of human-readable text
+        #[arg(long)]
+        json: bool,
+    },
+
     /// Debug: Read a localization file and output as JSON.
     Debug {
         /// The input file to debug
@@ -287,5 +301,34 @@ fn main() {
             cmd = cmd.bin_name("langcodec");
             generate(shell, &mut cmd, "langcodec", &mut std::io::stdout());
         }
+        Commands::Stats { input, lang, json } => {
+            // Validate
+            let mut context = ValidationContext::new().with_input_file(input.clone());
+            if let Some(l) = &lang { context = context.with_language_code(l.clone()); }
+            if let Err(e) = validate_context(&context) {
+                eprintln!("❌ Validation failed: {}", e);
+                std::process::exit(1);
+            }
+
+            // Load file using the same logic as view
+            let mut codec = Codec::new();
+            if let Ok(()) = codec.read_file_by_extension(&input, lang.clone()) {
+                // ok
+            } else if input.ends_with(".json")
+                || input.ends_with(".yaml")
+                || input.ends_with(".yml")
+                || input.ends_with(".langcodec")
+            {
+                if let Err(e) = try_custom_format_view(&input, lang.clone(), &mut codec) {
+                    eprintln!("Failed to read file: {}", e);
+                    std::process::exit(1);
+                }
+            } else {
+                eprintln!("Failed to read file: unsupported format");
+                std::process::exit(1);
+            }
+
+            stats::print_stats(&codec, &lang, json);
+        }
     }
 }

langcodec-cli/src/stats.rs

@@ -0,0 +1,108 @@
+use langcodec::{Codec, types::EntryStatus};
+use serde_json::json;
+use std::collections::HashMap;
+
+#[derive(Default)]
+struct LangStats {
+    total: usize,
+    by_status: HashMap<&'static str, usize>,
+    translated: usize,
+    denominator: usize,
+}
+
+fn accumulate(lang_stats: &mut LangStats, status: &EntryStatus) {
+    lang_stats.total += 1;
+    let key: &'static str = match status {
+        EntryStatus::DoNotTranslate => "do_not_translate",
+        EntryStatus::New => "new",
+        EntryStatus::Stale => "stale",
+        EntryStatus::NeedsReview => "needs_review",
+        EntryStatus::Translated => "translated",
+    };
+    *lang_stats.by_status.entry(key).or_insert(0) += 1;
+    if matches!(status, EntryStatus::Translated) {
+        lang_stats.translated += 1;
+    }
+    if !matches!(status, EntryStatus::DoNotTranslate) {
+        lang_stats.denominator += 1;
+    }
+}
+
+pub fn print_stats(codec: &Codec, lang_filter: &Option<String>, json_output: bool) {
+    let resources: Vec<_> = match lang_filter {
+        Some(lang) => codec.resources.iter().filter(|r| r.metadata.language == *lang).collect(),
+        None => codec.resources.iter().collect(),
+    };
+
+    if json_output {
+        // Build JSON object
+        let mut per_lang = Vec::new();
+        for res in &resources {
+            let mut stats = LangStats::default();
+            for e in &res.entries {
+                accumulate(&mut stats, &e.status);
+            }
+            let percent = if stats.denominator == 0 {
+                100.0
+            } else {
+                (stats.translated as f64) * 100.0 / (stats.denominator as f64)
+            };
+            per_lang.push(json!({
+                "language": res.metadata.language,
+                "total": stats.total,
+                "by_status": stats.by_status,
+                "completion_percent": (percent * 100.0).round() / 100.0,
+            }));
+        }
+        let summary = json!({
+            "languages": resources.len(),
+            "unique_keys": codec.all_keys().count(),
+        });
+        let body = json!({
+            "summary": summary,
+            "languages": per_lang,
+        });
+        println!("{}", serde_json::to_string_pretty(&body).unwrap());
+        return;
+    }
+
+    println!("=== Stats ===");
+    println!("Languages: {}", resources.len());
+    println!("Unique keys: {}", codec.all_keys().count());
+
+    for res in &resources {
+        let mut stats = LangStats::default();
+        for e in &res.entries {
+            accumulate(&mut stats, &e.status);
+        }
+        let percent = if stats.denominator == 0 {
+            100.0
+        } else {
+            (stats.translated as f64) * 100.0 / (stats.denominator as f64)
+        };
+        println!("\nLanguage: {}", res.metadata.language);
+        println!("  Total: {}", stats.total);
+        println!("  By status:");
+        for (k, v) in [
+            ("translated", stats.by_status.get("translated").copied().unwrap_or(0)),
+            (
+                "needs_review",
+                stats.by_status.get("needs_review").copied().unwrap_or(0),
+            ),
+            ("stale", stats.by_status.get("stale").copied().unwrap_or(0)),
+            ("new", stats.by_status.get("new").copied().unwrap_or(0)),
+            (
+                "do_not_translate",
+                stats
+                    .by_status
+                    .get("do_not_translate")
+                    .copied()
+                    .unwrap_or(0),
+            ),
+        ] {
+            println!("    {}: {}", k, v);
+        }
+        println!("  Completion: {:.2}%", percent);
+    }
+}
+

langcodec-cli/tests/stats_cli_tests.rs

@@ -0,0 +1,51 @@
+use std::fs;
+use std::process::Command;
+use tempfile::TempDir;
+
+#[test]
+fn test_stats_json_on_android_strings() {
+    let temp_dir = TempDir::new().unwrap();
+    let values_dir = temp_dir.path().join("values");
+    fs::create_dir_all(&values_dir).unwrap();
+    let input_file = values_dir.join("strings.xml");
+
+    let xml = r#"
+        <resources>
+            <string name="a">Hello</string>
+            <string name="b" translatable="false">Ignored</string>
+            <string name="c"></string>
+        </resources>
+    "#;
+    fs::write(&input_file, xml).unwrap();
+
+    let output = Command::new("cargo")
+        .args([
+            "run",
+            "--quiet",
+            "--",
+            "stats",
+            "-i",
+            input_file.to_str().unwrap(),
+            "--json",
+        ])
+        .output()
+        .unwrap();
+
+    assert!(
+        output.status.success(),
+        "CLI failed: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let v: serde_json::Value = serde_json::from_str(&stdout).unwrap();
+    // Expect 1 language
+    assert_eq!(v["summary"]["languages"], 1);
+    let langs = v["languages"].as_array().unwrap();
+    assert_eq!(langs.len(), 1);
+    let by_status = &langs[0]["by_status"];
+    assert_eq!(by_status["translated"], 1);
+    assert_eq!(by_status["do_not_translate"], 1);
+    assert_eq!(by_status["new"], 1);
+}
+