fix(cli): expand globbed config inputs for annotate and translate

Author: WendellXY

langcodec-cli/src/annotate.rs

@@ -1,6 +1,7 @@
 use crate::{
     ai::{ProviderKind, read_api_key, resolve_model, resolve_provider},
     config::{LoadedConfig, load_config, resolve_config_relative_path},
+    path_glob,
     tui::{
         DashboardEvent, DashboardInit, DashboardItem, DashboardItemStatus, DashboardKind,
         DashboardLogTone, PlainReporter, ResolvedUiMode, RunReporter, SummaryRow, TuiReporter,
@@ -413,19 +414,33 @@ fn resolve_config_inputs(
     cfg: Option<&crate::config::AnnotateConfig>,
     config_dir: Option<&Path>,
 ) -> Result<Vec<String>, String> {
+    fn has_glob_meta(path: &str) -> bool {
+        path.bytes().any(|b| matches!(b, b'*' | b'?' | b'[' | b'{'))
+    }
+
     if let Some(input) = &opts.input {
         return Ok(vec![input.clone()]);
     }
 
     if let Some(input) = cfg.and_then(|item| item.input.as_ref()) {
-        return Ok(vec![resolve_config_relative_path(config_dir, input)]);
+        let resolved = vec![resolve_config_relative_path(config_dir, input)];
+        return if resolved.iter().any(|path| has_glob_meta(path)) {
+            path_glob::expand_input_globs(&resolved)
+        } else {
+            Ok(resolved)
+        };
     }
 
     if let Some(inputs) = cfg.and_then(|item| item.inputs.as_ref()) {
-        return Ok(inputs
+        let resolved = inputs
             .iter()
             .map(|input| resolve_config_relative_path(config_dir, input))
-            .collect());
+            .collect::<Vec<_>>();
+        return if resolved.iter().any(|path| has_glob_meta(path)) {
+            path_glob::expand_input_globs(&resolved)
+        } else {
+            Ok(resolved)
+        };
     }
 
     Ok(Vec::new())
@@ -2158,6 +2173,77 @@ concurrency = 2
         );
     }
 
+    #[test]
+    fn expand_annotate_invocations_expands_globbed_config_inputs() {
+        let temp_dir = TempDir::new().expect("temp dir");
+        let project_dir = temp_dir.path().join("project");
+        let sources_dir = project_dir.join("Sources");
+        let app_dir = project_dir.join("App").join("Resources");
+        let module_dir = project_dir.join("Modules").join("Feature");
+        fs::create_dir_all(&sources_dir).expect("create Sources");
+        fs::create_dir_all(&app_dir).expect("create app dir");
+        fs::create_dir_all(&module_dir).expect("create module dir");
+
+        let first = app_dir.join("Localizable.xcstrings");
+        let second = module_dir.join("Localizable.xcstrings");
+        fs::write(
+            &first,
+            r#"{"sourceLanguage":"en","version":"1.0","strings":{}}"#,
+        )
+        .expect("write first");
+        fs::write(
+            &second,
+            r#"{"sourceLanguage":"en","version":"1.0","strings":{}}"#,
+        )
+        .expect("write second");
+
+        let config_path = project_dir.join("langcodec.toml");
+        fs::write(
+            &config_path,
+            r#"[openai]
+model = "gpt-5.4"
+
+[annotate]
+inputs = ["*/**/Localizable.xcstrings"]
+source_roots = ["Sources"]
+"#,
+        )
+        .expect("write config");
+
+        let loaded = load_config(Some(config_path.to_str().expect("config path")))
+            .expect("load config")
+            .expect("config present");
+
+        let runs = expand_annotate_invocations(
+            &AnnotateOptions {
+                input: None,
+                source_roots: Vec::new(),
+                output: None,
+                source_lang: None,
+                provider: None,
+                model: None,
+                concurrency: None,
+                config: Some(config_path.to_string_lossy().to_string()),
+                dry_run: false,
+                check: false,
+                ui_mode: UiMode::Plain,
+            },
+            Some(&loaded),
+        )
+        .expect("expand annotate invocations");
+
+        let mut inputs = runs.into_iter().map(|run| run.input).collect::<Vec<_>>();
+        inputs.sort();
+
+        let mut expected = vec![
+            first.to_string_lossy().to_string(),
+            second.to_string_lossy().to_string(),
+        ];
+        expected.sort();
+
+        assert_eq!(inputs, expected);
+    }
+
     #[test]
     fn expand_annotate_invocations_rejects_input_and_inputs_together() {
         let temp_dir = TempDir::new().expect("temp dir");

langcodec-cli/src/lib.rs

@@ -5,6 +5,7 @@ pub mod annotate;
 pub mod config;
 pub mod formats;
 pub mod merge;
+pub mod path_glob;
 pub mod tolgee;
 pub mod transformers;
 pub mod translate;

langcodec-cli/src/translate.rs

@@ -2,6 +2,7 @@ use crate::validation::{validate_language_code, validate_output_path};
 use crate::{
     ai::{ProviderKind, build_provider, resolve_model, resolve_provider},
     config::{LoadedConfig, load_config, resolve_config_relative_path},
+    path_glob,
     tolgee::{
         TranslateTolgeeContext, TranslateTolgeeSettings, prefill_translate_from_tolgee,
         push_translate_results_to_tolgee,
@@ -358,20 +359,33 @@ fn resolve_config_sources(
     cfg: Option<&crate::config::TranslateConfig>,
     config_dir: Option<&Path>,
 ) -> Result<Vec<String>, String> {
+    fn has_glob_meta(path: &str) -> bool {
+        path.bytes().any(|b| matches!(b, b'*' | b'?' | b'[' | b'{'))
+    }
+
     if let Some(source) = &opts.source {
         return Ok(vec![source.clone()]);
     }
 
     if let Some(source) = cfg.and_then(|item| item.resolved_source()) {
-        return Ok(vec![resolve_config_relative_path(config_dir, source)]);
+        let resolved = vec![resolve_config_relative_path(config_dir, source)];
+        return if resolved.iter().any(|path| has_glob_meta(path)) {
+            path_glob::expand_input_globs(&resolved)
+        } else {
+            Ok(resolved)
+        };
     }
 
     if let Some(sources) = cfg.and_then(|item| item.resolved_sources()) {
         let resolved = sources
             .iter()
             .map(|source| resolve_config_relative_path(config_dir, source))
             .collect::<Vec<_>>();
-        return Ok(resolved);
+        return if resolved.iter().any(|path| has_glob_meta(path)) {
+            path_glob::expand_input_globs(&resolved)
+        } else {
+            Ok(resolved)
+        };
     }
 
     Ok(Vec::new())
@@ -2316,6 +2330,72 @@ sources = ["one.xcstrings", "two.xcstrings"]
         );
     }
 
+    #[test]
+    fn expands_globbed_sources_from_config() {
+        let temp_dir = TempDir::new().unwrap();
+        let config_dir = temp_dir.path().join("project");
+        let feature_a = config_dir.join("Modules").join("FeatureA");
+        let feature_b = config_dir.join("Modules").join("FeatureB");
+        fs::create_dir_all(&feature_a).unwrap();
+        fs::create_dir_all(&feature_b).unwrap();
+
+        let first = feature_a.join("Localizable.xcstrings");
+        let second = feature_b.join("Localizable.xcstrings");
+        fs::write(
+            &first,
+            r#"{"sourceLanguage":"en","version":"1.0","strings":{}}"#,
+        )
+        .unwrap();
+        fs::write(
+            &second,
+            r#"{"sourceLanguage":"en","version":"1.0","strings":{}}"#,
+        )
+        .unwrap();
+
+        let config = config_dir.join("langcodec.toml");
+        fs::write(
+            &config,
+            r#"[translate.input]
+sources = ["Modules/*/Localizable.xcstrings"]
+"#,
+        )
+        .unwrap();
+
+        let runs = expand_translate_invocations(&TranslateOptions {
+            source: None,
+            target: None,
+            output: None,
+            source_lang: None,
+            target_langs: Vec::new(),
+            status: None,
+            provider: None,
+            model: None,
+            concurrency: None,
+            config: Some(config.to_string_lossy().to_string()),
+            use_tolgee: false,
+            tolgee_config: None,
+            tolgee_namespaces: Vec::new(),
+            dry_run: true,
+            strict: false,
+            ui_mode: UiMode::Plain,
+        })
+        .unwrap();
+
+        let mut sources = runs
+            .into_iter()
+            .map(|run| run.source.expect("source"))
+            .collect::<Vec<_>>();
+        sources.sort();
+
+        let mut expected = vec![
+            first.to_string_lossy().to_string(),
+            second.to_string_lossy().to_string(),
+        ];
+        expected.sort();
+
+        assert_eq!(sources, expected);
+    }
+
     #[test]
     fn rejects_target_with_multiple_sources_from_config() {
         let temp_dir = TempDir::new().unwrap();