poly-lexis 0.3.2 → 0.4.0

package/dist/cli/translations.js

@@ -18,72 +18,6 @@ var init_esm_shims = __esm({
   }
 });
 
-// src/translations/utils/utils.ts
-import * as fs from "fs";
-import * as path2 from "path";
-function readTranslations(translationsPath, language) {
-  const langPath = path2.join(translationsPath, language);
-  if (!fs.existsSync(langPath)) {
-    return {};
-  }
-  const files = fs.readdirSync(langPath).filter((f) => f.endsWith(".json"));
-  const translations = {};
-  for (const file of files) {
-    const namespace = path2.basename(file, ".json");
-    const filePath = path2.join(langPath, file);
-    const content = fs.readFileSync(filePath, "utf-8");
-    translations[namespace] = JSON.parse(content);
-  }
-  return translations;
-}
-function writeTranslation(translationsPath, language, namespace, translations) {
-  const langPath = path2.join(translationsPath, language);
-  if (!fs.existsSync(langPath)) {
-    fs.mkdirSync(langPath, { recursive: true });
-  }
-  const filePath = path2.join(langPath, `${namespace}.json`);
-  fs.writeFileSync(filePath, `${JSON.stringify(translations, null, 2)}
-`, "utf-8");
-}
-function getAvailableLanguages(translationsPath) {
-  if (!fs.existsSync(translationsPath)) {
-    return [];
-  }
-  return fs.readdirSync(translationsPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
-}
-function getNamespaces(translationsPath, language) {
-  const langPath = path2.join(translationsPath, language);
-  if (!fs.existsSync(langPath)) {
-    return [];
-  }
-  return fs.readdirSync(langPath).filter((f) => f.endsWith(".json")).map((f) => path2.basename(f, ".json"));
-}
-function sortKeys(obj) {
-  const sorted = {};
-  const keys = Object.keys(obj).sort();
-  for (const key of keys) {
-    sorted[key] = obj[key];
-  }
-  return sorted;
-}
-function ensureTranslationsStructure(translationsPath, languages) {
-  if (!fs.existsSync(translationsPath)) {
-    fs.mkdirSync(translationsPath, { recursive: true });
-  }
-  for (const lang of languages) {
-    const langPath = path2.join(translationsPath, lang);
-    if (!fs.existsSync(langPath)) {
-      fs.mkdirSync(langPath, { recursive: true });
-    }
-  }
-}
-var init_utils = __esm({
-  "src/translations/utils/utils.ts"() {
-    "use strict";
-    init_esm_shims();
-  }
-});
-
 // src/translations/core/schema.ts
 function isValidLanguage(lang) {
   return SUPPORTED_LANGUAGES.includes(lang);
@@ -91,7 +25,7 @@ function isValidLanguage(lang) {
 function validateLanguages(languages) {
   const invalid = languages.filter((lang) => !isValidLanguage(lang));
   return {
-    valid: invalid.length === 0,
+    valid: !invalid.length,
     invalid
   };
 }
@@ -100,6 +34,7 @@ var init_schema = __esm({
   "src/translations/core/schema.ts"() {
     "use strict";
     init_esm_shims();
+    init_language_fallback();
     DEEPL_LANGUAGES = [
       "ar",
       // Arabic
@@ -412,6 +347,297 @@ var init_schema = __esm({
   }
 });
 
+// src/translations/utils/language-fallback.ts
+function resolveLanguageWithFallback(language, provider, enableFallback = true) {
+  const normalizedLanguage = language.toLowerCase();
+  const supportedLanguages = getSupportedLanguagesForProvider(provider);
+  if (isLanguageSupported(normalizedLanguage, supportedLanguages)) {
+    return {
+      resolvedLanguage: normalizedLanguage,
+      usedFallback: false,
+      originalLanguage: language
+    };
+  }
+  if (!enableFallback) {
+    return {
+      resolvedLanguage: normalizedLanguage,
+      usedFallback: false,
+      originalLanguage: language
+    };
+  }
+  const fallbackChain = LANGUAGE_FALLBACK_MAP[normalizedLanguage] || [];
+  for (const fallbackLang of fallbackChain) {
+    if (isLanguageSupported(fallbackLang, supportedLanguages)) {
+      return {
+        resolvedLanguage: fallbackLang,
+        usedFallback: true,
+        originalLanguage: language,
+        fallbackChain: [normalizedLanguage, ...fallbackChain]
+      };
+    }
+  }
+  const baseLang = normalizedLanguage.split("_")[0];
+  if (baseLang !== normalizedLanguage && isLanguageSupported(baseLang, supportedLanguages)) {
+    return {
+      resolvedLanguage: baseLang,
+      usedFallback: true,
+      originalLanguage: language,
+      fallbackChain: [normalizedLanguage, baseLang]
+    };
+  }
+  return {
+    resolvedLanguage: normalizedLanguage,
+    usedFallback: false,
+    originalLanguage: language
+  };
+}
+function getSupportedLanguagesForProvider(provider) {
+  switch (provider) {
+    case "deepl":
+      return DEEPL_LANGUAGES;
+    case "google":
+      return GOOGLE_LANGUAGES;
+    default:
+      return [];
+  }
+}
+function isLanguageSupported(language, supportedLanguages) {
+  return supportedLanguages.includes(language);
+}
+function logLanguageFallback(result, provider) {
+  if (result.usedFallback) {
+    console.warn(
+      `\u26A0\uFE0F  Language fallback: '${result.originalLanguage}' is not supported by ${provider}, using '${result.resolvedLanguage}' instead`
+    );
+    if (result.fallbackChain && result.fallbackChain.length > 2) {
+      console.warn(`   Fallback chain: ${result.fallbackChain.join(" \u2192 ")}`);
+    }
+  }
+}
+var LANGUAGE_FALLBACK_MAP;
+var init_language_fallback = __esm({
+  "src/translations/utils/language-fallback.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_schema();
+    LANGUAGE_FALLBACK_MAP = {
+      // German variants
+      de_at: ["de"],
+      // Austrian German -> German
+      de_ch: ["de"],
+      // Swiss German -> German
+      de_de: ["de"],
+      // Standard German -> German
+      // English variants
+      en_gb: ["en"],
+      // British English -> English
+      en_us: ["en"],
+      // American English -> English
+      en_au: ["en"],
+      // Australian English -> English
+      en_ca: ["en"],
+      // Canadian English -> English
+      en_nz: ["en"],
+      // New Zealand English -> English
+      // Chinese variants (Hong Kong, Taiwan -> Traditional)
+      zh_hk: ["zh_hant", "zh"],
+      // Hong Kong Chinese -> Traditional Chinese -> Chinese
+      zh_tw: ["zh_hant", "zh"],
+      // Taiwan Chinese -> Traditional Chinese -> Chinese
+      zh_mo: ["zh_hant", "zh"],
+      // Macau Chinese -> Traditional Chinese -> Chinese
+      // Chinese variants (Mainland, Singapore -> Simplified)
+      zh_cn: ["zh_hans", "zh"],
+      // Mainland Chinese -> Simplified Chinese -> Chinese
+      zh_sg: ["zh_hans", "zh"],
+      // Singapore Chinese -> Simplified Chinese -> Chinese
+      // Portuguese variants
+      pt_pt: ["pt"],
+      // European Portuguese -> Portuguese
+      pt_ao: ["pt"],
+      // Angolan Portuguese -> Portuguese
+      pt_mz: ["pt"],
+      // Mozambican Portuguese -> Portuguese
+      // Spanish variants (Latin America)
+      es_mx: ["es_419", "es"],
+      // Mexican Spanish -> Latin American Spanish -> Spanish
+      es_ar: ["es_419", "es"],
+      // Argentine Spanish -> Latin American Spanish -> Spanish
+      es_co: ["es_419", "es"],
+      // Colombian Spanish -> Latin American Spanish -> Spanish
+      es_cl: ["es_419", "es"],
+      // Chilean Spanish -> Latin American Spanish -> Spanish
+      es_pe: ["es_419", "es"],
+      // Peruvian Spanish -> Latin American Spanish -> Spanish
+      es_ve: ["es_419", "es"],
+      // Venezuelan Spanish -> Latin American Spanish -> Spanish
+      es_ec: ["es_419", "es"],
+      // Ecuadorian Spanish -> Latin American Spanish -> Spanish
+      es_gt: ["es_419", "es"],
+      // Guatemalan Spanish -> Latin American Spanish -> Spanish
+      es_cu: ["es_419", "es"],
+      // Cuban Spanish -> Latin American Spanish -> Spanish
+      es_do: ["es_419", "es"],
+      // Dominican Spanish -> Latin American Spanish -> Spanish
+      es_hn: ["es_419", "es"],
+      // Honduran Spanish -> Latin American Spanish -> Spanish
+      es_ni: ["es_419", "es"],
+      // Nicaraguan Spanish -> Latin American Spanish -> Spanish
+      es_sv: ["es_419", "es"],
+      // Salvadoran Spanish -> Latin American Spanish -> Spanish
+      es_cr: ["es_419", "es"],
+      // Costa Rican Spanish -> Latin American Spanish -> Spanish
+      es_pa: ["es_419", "es"],
+      // Panamanian Spanish -> Latin American Spanish -> Spanish
+      es_uy: ["es_419", "es"],
+      // Uruguayan Spanish -> Latin American Spanish -> Spanish
+      es_py: ["es_419", "es"],
+      // Paraguayan Spanish -> Latin American Spanish -> Spanish
+      es_bo: ["es_419", "es"],
+      // Bolivian Spanish -> Latin American Spanish -> Spanish
+      // Spanish (European)
+      es_es: ["es"],
+      // European Spanish -> Spanish
+      // French variants
+      fr_ca: ["fr"],
+      // Canadian French -> French
+      fr_ch: ["fr"],
+      // Swiss French -> French
+      fr_be: ["fr"],
+      // Belgian French -> French
+      fr_fr: ["fr"],
+      // Standard French -> French
+      // Norwegian variants
+      no: ["nb"],
+      // Norwegian -> Norwegian Bokmål
+      nn: ["nb"],
+      // Norwegian Nynorsk -> Norwegian Bokmål
+      // Other regional variants
+      it_ch: ["it"],
+      // Swiss Italian -> Italian
+      nl_be: ["nl"],
+      // Belgian Dutch (Flemish) -> Dutch
+      sv_fi: ["sv"],
+      // Finland Swedish -> Swedish
+      ar_ae: ["ar"],
+      // UAE Arabic -> Arabic
+      ar_sa: ["ar"],
+      // Saudi Arabic -> Arabic
+      ar_eg: ["ar"]
+      // Egyptian Arabic -> Arabic
+    };
+  }
+});
+
+// src/translations/utils/utils.ts
+import * as fs from "fs";
+import * as path2 from "path";
+function readTranslations(translationsPath, language) {
+  const langPath = path2.join(translationsPath, language);
+  if (!fs.existsSync(langPath)) {
+    return {};
+  }
+  const files = fs.readdirSync(langPath).filter((f) => f.endsWith(".json"));
+  const translations = {};
+  for (const file of files) {
+    const namespace = path2.basename(file, ".json");
+    const filePath = path2.join(langPath, file);
+    const content = fs.readFileSync(filePath, "utf-8");
+    translations[namespace] = JSON.parse(content);
+  }
+  return translations;
+}
+function writeTranslation(translationsPath, language, namespace, translations) {
+  const langPath = path2.join(translationsPath, language);
+  if (!fs.existsSync(langPath)) {
+    fs.mkdirSync(langPath, { recursive: true });
+  }
+  const filePath = path2.join(langPath, `${namespace}.json`);
+  fs.writeFileSync(filePath, `${JSON.stringify(translations, null, 2)}
+`, "utf-8");
+}
+function getAvailableLanguages(translationsPath) {
+  if (!fs.existsSync(translationsPath)) {
+    return [];
+  }
+  return fs.readdirSync(translationsPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+}
+function getNamespaces(translationsPath, language) {
+  const langPath = path2.join(translationsPath, language);
+  if (!fs.existsSync(langPath)) {
+    return [];
+  }
+  return fs.readdirSync(langPath).filter((f) => f.endsWith(".json")).map((f) => path2.basename(f, ".json"));
+}
+function sortKeys(obj) {
+  const sorted = {};
+  const keys = Object.keys(obj).sort();
+  for (const key of keys) {
+    sorted[key] = obj[key];
+  }
+  return sorted;
+}
+function ensureTranslationsStructure(translationsPath, languages) {
+  if (!fs.existsSync(translationsPath)) {
+    fs.mkdirSync(translationsPath, { recursive: true });
+  }
+  for (const lang of languages) {
+    const langPath = path2.join(translationsPath, lang);
+    if (!fs.existsSync(langPath)) {
+      fs.mkdirSync(langPath, { recursive: true });
+    }
+  }
+}
+function createEmptyTranslationStructure(sourceFile) {
+  const result = {};
+  for (const key of Object.keys(sourceFile)) {
+    result[key] = "";
+  }
+  return result;
+}
+function syncTranslationStructure(translationsPath, languages, sourceLanguage) {
+  const result = {
+    createdFolders: [],
+    createdFiles: [],
+    skippedFiles: []
+  };
+  ensureTranslationsStructure(translationsPath, languages);
+  const sourceNamespaces = getNamespaces(translationsPath, sourceLanguage);
+  if (!sourceNamespaces.length) {
+    return result;
+  }
+  const sourceTranslations = readTranslations(translationsPath, sourceLanguage);
+  const targetLanguages = languages.filter((lang) => lang !== sourceLanguage);
+  for (const language of targetLanguages) {
+    for (const namespace of sourceNamespaces) {
+      const filePath = path2.join(translationsPath, language, `${namespace}.json`);
+      if (fs.existsSync(filePath)) {
+        result.skippedFiles.push({
+          language,
+          namespace,
+          reason: "already exists"
+        });
+        continue;
+      }
+      const sourceFile = sourceTranslations[namespace] || {};
+      const emptyStructure = createEmptyTranslationStructure(sourceFile);
+      writeTranslation(translationsPath, language, namespace, emptyStructure);
+      result.createdFiles.push({
+        language,
+        namespace,
+        path: filePath
+      });
+    }
+  }
+  return result;
+}
+var init_utils = __esm({
+  "src/translations/utils/utils.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // src/translations/core/types.ts
 var DEFAULT_CONFIG, DEFAULT_LANGUAGES;
 var init_types = __esm({
@@ -422,24 +648,11 @@ var init_types = __esm({
       translationsPath: "public/static/locales",
       languages: ["en"],
       sourceLanguage: "en",
-      typesOutputPath: "src/types/i18nTypes.ts"
+      typesOutputPath: "src/types/i18nTypes.ts",
+      provider: "google",
+      useFallbackLanguages: true
     };
-    DEFAULT_LANGUAGES = [
-      "en",
-      "fr",
-      "it",
-      "pl",
-      "es",
-      "pt",
-      "de",
-      "de_at",
-      "nl",
-      "sv",
-      "hu",
-      "cs",
-      "ja",
-      "zh_hk"
-    ];
+    DEFAULT_LANGUAGES = ["en", "fr", "it", "pl", "es", "pt", "de", "nl", "sv", "hu", "cs", "ja"];
   }
 });
 
@@ -513,12 +726,14 @@ function initTranslations(projectRoot, config = {}) {
 `, "utf-8");
     console.log(`Created sample file: ${commonPath}`);
   }
-  for (const lang of languages) {
-    if (lang === sourceLanguage) continue;
-    const langCommonPath = path3.join(translationsPath, lang, "common.json");
-    if (!fs2.existsSync(langCommonPath)) {
-      fs2.writeFileSync(langCommonPath, "{}\n", "utf-8");
-      console.log(`Created empty file: ${langCommonPath}`);
+  console.log("\nSynchronizing translation structure...");
+  const syncResult = syncTranslationStructure(translationsPath, languages, sourceLanguage);
+  if (syncResult.createdFiles.length > 0) {
+    console.log(`Created ${syncResult.createdFiles.length} namespace files in target languages`);
+    const languageGroups = new Set(syncResult.createdFiles.map((f) => f.language));
+    for (const lang of languageGroups) {
+      const langFiles = syncResult.createdFiles.filter((f) => f.language === lang);
+      console.log(`  ${lang}: ${langFiles.map((f) => f.namespace).join(", ")}`);
     }
   }
   const configPath = path3.join(projectRoot, ".translationsrc.json");
@@ -528,7 +743,8 @@ function initTranslations(projectRoot, config = {}) {
       translationsPath: finalConfig.translationsPath,
       languages,
       sourceLanguage,
-      typesOutputPath: finalConfig.typesOutputPath
+      typesOutputPath: finalConfig.typesOutputPath,
+      provider: finalConfig.provider
     };
     fs2.writeFileSync(configPath, `${JSON.stringify(configContent, null, 2)}
 `, "utf-8");
@@ -595,7 +811,7 @@ function generateTranslationTypes(projectRoot = process.cwd()) {
     throw new Error(`Source language directory not found: ${dirPath}`);
   }
   const namespaces = getNamespaces(translationsPath, sourceLanguage);
-  if (namespaces.length === 0) {
+  if (!namespaces.length) {
     throw new Error(`No translation files found in ${dirPath}`);
   }
   const translations = readTranslations(translationsPath, sourceLanguage);
@@ -646,7 +862,7 @@ import "dotenv/config";
 import * as fs6 from "fs";
 import * as path10 from "path";
 import { parseArgs } from "util";
-import { confirm as confirm2, input as input2, select } from "@inquirer/prompts";
+import { confirm as confirm2, input as input2, select as select2 } from "@inquirer/prompts";
 
 // src/translations/cli/add-key.ts
 init_esm_shims();
@@ -657,6 +873,7 @@ init_esm_shims();
 
 // src/translations/utils/google-translate-provider.ts
 init_esm_shims();
+init_language_fallback();
 function preserveVariables(text) {
   const variableMap = /* @__PURE__ */ new Map();
   let placeholderIndex = 0;
@@ -677,14 +894,24 @@ function restoreVariables(text, variableMap) {
 }
 var GoogleTranslateProvider = class {
   async translate(options) {
-    const { text, sourceLang, targetLang, apiKey } = options;
+    const { text, sourceLang, targetLang, apiKey, useFallbackLanguages = true } = options;
     if (!apiKey) {
       throw new Error(
         "Google Translate API key is required. Set GOOGLE_TRANSLATE_API_KEY environment variable or provide apiKey in options."
       );
     }
+    const targetLangResult = resolveLanguageWithFallback(targetLang, "google", useFallbackLanguages);
+    logLanguageFallback(targetLangResult, "google");
+    let resolvedSourceLang;
+    if (sourceLang) {
+      const sourceLangResult = resolveLanguageWithFallback(sourceLang, "google", useFallbackLanguages);
+      logLanguageFallback(sourceLangResult, "google");
+      resolvedSourceLang = sourceLangResult.resolvedLanguage;
+    }
     const { textWithPlaceholders, variableMap } = preserveVariables(text);
     const url = `https://translation.googleapis.com/language/translate/v2?key=${apiKey}`;
+    const sourceForGoogle = resolvedSourceLang?.includes("_") ? resolvedSourceLang.split("_")[0] : resolvedSourceLang;
+    const targetForGoogle = targetLangResult.resolvedLanguage.includes("_") ? targetLangResult.resolvedLanguage.split("_")[0] : targetLangResult.resolvedLanguage;
     const response = await fetch(url, {
       method: "POST",
       headers: {
@@ -692,9 +919,8 @@ var GoogleTranslateProvider = class {
       },
       body: JSON.stringify({
         q: textWithPlaceholders,
-        source: sourceLang,
-        target: targetLang.split("_")[0],
-        // Convert 'pt_BR' to 'pt'
+        source: sourceForGoogle,
+        target: targetForGoogle,
         format: "text"
       })
     });
@@ -730,16 +956,20 @@ var GoogleTranslateProvider = class {
 // src/translations/utils/translator.ts
 var defaultProvider = new GoogleTranslateProvider();
 var customProvider = null;
+function setTranslationProvider(provider) {
+  customProvider = provider;
+}
 function getTranslationProvider() {
   return customProvider || defaultProvider;
 }
-async function translateText(text, targetLang, sourceLang = "en", apiKey) {
+async function translateText(text, targetLang, sourceLang = "en", apiKey, useFallbackLanguages = true) {
   const provider = getTranslationProvider();
   return provider.translate({
     text,
     sourceLang,
     targetLang,
-    apiKey
+    apiKey,
+    useFallbackLanguages
   });
 }
 
@@ -827,7 +1057,7 @@ init_types();
 init_init();
 import * as fs3 from "fs";
 import * as path5 from "path";
-import { checkbox, confirm, input } from "@inquirer/prompts";
+import { checkbox, confirm, input, select } from "@inquirer/prompts";
 async function initTranslationsInteractive(projectRoot = process.cwd()) {
   console.log("\n\u{1F30D} Translation System Setup\n");
   const configPath = path5.join(projectRoot, ".translationsrc.json");
@@ -906,11 +1136,28 @@ async function initTranslationsInteractive(projectRoot = process.cwd()) {
     message: "Where should TypeScript types be generated?",
     default: DEFAULT_CONFIG.typesOutputPath
   });
+  const provider = await select({
+    message: "Which translation provider would you like to use?",
+    choices: [
+      {
+        name: "DeepL (recommended)",
+        value: "deepl",
+        description: "High-quality translations, requires DEEPL_API_KEY"
+      },
+      {
+        name: "Google Translate",
+        value: "google",
+        description: "Google Cloud Translation API, requires GOOGLE_TRANSLATE_API_KEY"
+      }
+    ],
+    default: "deepl"
+  });
   console.log("\n\u{1F4CB} Configuration Summary:");
   console.log(`   Translations: ${translationsPath}`);
   console.log(`   Languages: ${languages.join(", ")}`);
   console.log(`   Source: ${sourceLanguage}`);
   console.log(`   Types: ${typesOutputPath}`);
+  console.log(`   Provider: ${provider}`);
   const confirmInit = await confirm({
     message: "\nProceed with initialization?",
     default: true
@@ -923,7 +1170,8 @@ async function initTranslationsInteractive(projectRoot = process.cwd()) {
     translationsPath,
     languages,
     sourceLanguage,
-    typesOutputPath
+    typesOutputPath,
+    provider
   };
   console.log();
   initTranslations(projectRoot, config);
@@ -981,12 +1229,109 @@ function getLanguageName(code) {
 
 // src/translations/cli/manage.ts
 init_esm_shims();
+init_utils();
 import * as fs5 from "fs";
 import * as path9 from "path";
 
 // src/translations/cli/auto-fill.ts
 init_esm_shims();
 import * as path7 from "path";
+
+// src/translations/utils/deepl-translate-provider.ts
+init_esm_shims();
+init_language_fallback();
+function preserveVariables2(text) {
+  const variableMap = /* @__PURE__ */ new Map();
+  let placeholderIndex = 0;
+  const textWithPlaceholders = text.replace(/\{\{([^}]+)\}\}/g, (match) => {
+    const placeholder = `XXX_${placeholderIndex}_XXX`;
+    variableMap.set(placeholder, match);
+    placeholderIndex++;
+    return placeholder;
+  });
+  return { textWithPlaceholders, variableMap };
+}
+function restoreVariables2(text, variableMap) {
+  let result = text;
+  for (const [placeholder, original] of variableMap) {
+    result = result.replace(new RegExp(placeholder, "g"), original);
+  }
+  return result;
+}
+function normalizeLanguageCode(langCode) {
+  return langCode.replace("_", "-").toUpperCase();
+}
+var DeepLTranslateProvider = class {
+  isFreeApi;
+  constructor(isFreeApi = false) {
+    this.isFreeApi = isFreeApi;
+  }
+  getApiEndpoint() {
+    return this.isFreeApi ? "https://api-free.deepl.com/v2/translate" : "https://api.deepl.com/v2/translate";
+  }
+  async translate(options) {
+    const { text, sourceLang, targetLang, apiKey, useFallbackLanguages = true } = options;
+    if (!apiKey) {
+      throw new Error(
+        "DeepL API key is required. Set DEEPL_API_KEY environment variable or provide apiKey in options."
+      );
+    }
+    const targetLangResult = resolveLanguageWithFallback(targetLang, "deepl", useFallbackLanguages);
+    logLanguageFallback(targetLangResult, "deepl");
+    let resolvedSourceLang;
+    if (sourceLang) {
+      const sourceLangResult = resolveLanguageWithFallback(sourceLang, "deepl", useFallbackLanguages);
+      logLanguageFallback(sourceLangResult, "deepl");
+      resolvedSourceLang = sourceLangResult.resolvedLanguage;
+    }
+    const { textWithPlaceholders, variableMap } = preserveVariables2(text);
+    const body = {
+      text: [textWithPlaceholders],
+      target_lang: normalizeLanguageCode(targetLangResult.resolvedLanguage),
+      ...resolvedSourceLang && { source_lang: normalizeLanguageCode(resolvedSourceLang) }
+    };
+    const response = await fetch(this.getApiEndpoint(), {
+      method: "POST",
+      headers: {
+        Authorization: `DeepL-Auth-Key ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(`DeepL API error: ${errorData.message || response.statusText} (${response.status})`);
+    }
+    const data = await response.json();
+    if (!data.translations || data.translations.length === 0) {
+      throw new Error("DeepL API returned no translations");
+    }
+    const translatedText = data.translations[0].text;
+    return restoreVariables2(translatedText, variableMap);
+  }
+  async translateBatch(texts, sourceLang, targetLang, apiKey, delayMs = 100) {
+    const results = [];
+    for (const text of texts) {
+      const translated = await this.translate({
+        text,
+        sourceLang,
+        targetLang,
+        apiKey
+      });
+      results.push(translated);
+      if (delayMs > 0) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+    }
+    return results;
+  }
+  async validateConfig() {
+    const apiKey = process.env.DEEPL_API_KEY;
+    return !!apiKey;
+  }
+};
+
+// src/translations/cli/auto-fill.ts
 init_utils();
 init_init();
 
@@ -1003,7 +1348,11 @@ function validateTranslations(projectRoot = process.cwd()) {
   const empty = [];
   const sourceTranslations = readTranslations(translationsPath, sourceLanguage);
   const sourceNamespaces = getNamespaces(translationsPath, sourceLanguage);
-  const languages = getAvailableLanguages(translationsPath).filter((lang) => lang !== sourceLanguage);
+  const languages = config.languages.filter((lang) => lang !== sourceLanguage);
+  const syncResult = syncTranslationStructure(translationsPath, config.languages, sourceLanguage);
+  if (syncResult.createdFiles.length > 0) {
+    console.log(`Created ${syncResult.createdFiles.length} missing namespace files during sync`);
+  }
   console.log("=====");
   console.log("Validating translations");
   console.log("=====");
@@ -1036,7 +1385,7 @@ function validateTranslations(projectRoot = process.cwd()) {
       }
     }
   }
-  const valid = missing.length === 0 && empty.length === 0;
+  const valid = !missing.length && !empty.length;
   if (valid) {
     console.log("\u2713 All translations are valid!");
   } else {
@@ -1078,10 +1427,28 @@ async function autoFillTranslations(projectRoot = process.cwd(), options = {}) {
   const config = loadConfig(projectRoot);
   const translationsPath = path7.join(projectRoot, config.translationsPath);
   const { apiKey, limit = 1e3, delayMs = 100, dryRun = false } = options;
+  const currentProvider = getTranslationProvider();
+  const isDefaultGoogleProvider = currentProvider.constructor.name === "GoogleTranslateProvider";
+  if (isDefaultGoogleProvider) {
+    const provider = config.provider || "deepl";
+    if (provider === "deepl") {
+      setTranslationProvider(new DeepLTranslateProvider());
+    } else {
+      setTranslationProvider(new GoogleTranslateProvider());
+    }
+  }
   if (!apiKey) {
-    throw new Error("Google Translate API key is required. Set GOOGLE_TRANSLATE_API_KEY or pass --api-key");
+    const provider = config.provider || "deepl";
+    const envVarName = provider === "google" ? "GOOGLE_TRANSLATE_API_KEY" : "DEEPL_API_KEY";
+    throw new Error(`Translation API key is required. Set ${envVarName} or pass --api-key`);
   }
   const languagesToProcess = options.language ? [options.language] : config.languages.filter((lang) => lang !== config.sourceLanguage);
+  console.log("\u{1F504} Synchronizing translation structure...");
+  const syncResult = syncTranslationStructure(translationsPath, config.languages, config.sourceLanguage);
+  if (syncResult.createdFiles.length > 0) {
+    console.log(`Created ${syncResult.createdFiles.length} namespace files
+`);
+  }
   console.log("=====");
   console.log("Auto-filling translations");
   console.log("=====");
@@ -1100,7 +1467,7 @@ Reached limit of ${limit} translations`);
     console.log(`
 Processing language: ${language}`);
     const missing = getMissingForLanguage(projectRoot, language);
-    if (missing.length === 0) {
+    if (!missing.length) {
       console.log("  No missing or empty translations");
       continue;
     }
@@ -1112,7 +1479,13 @@ Processing language: ${language}`);
       try {
         console.log(`  [${totalProcessed}/${limit}] Translating ${item.namespace}.${item.key}`);
         console.log(`    EN: "${item.sourceValue}"`);
-        const translated = await translateText(item.sourceValue, language, config.sourceLanguage, apiKey);
+        const translated = await translateText(
+          item.sourceValue,
+          language,
+          config.sourceLanguage,
+          apiKey,
+          config.useFallbackLanguages ?? true
+        );
         console.log(`    ${language.toUpperCase()}: "${translated}"`);
         if (!dryRun) {
           const translations = readTranslations(translationsPath, language);
@@ -1169,6 +1542,14 @@ async function manageTranslations(projectRoot = process.cwd(), options = {}) {
     console.log("Please add translation files to the source language directory.\n");
     return false;
   }
+  console.log("\u{1F504} Synchronizing translation structure...\n");
+  const syncResult = syncTranslationStructure(translationsPath, config.languages, config.sourceLanguage);
+  if (syncResult.createdFiles.length > 0) {
+    console.log(`\u2713 Created ${syncResult.createdFiles.length} namespace files
+`);
+  } else {
+    console.log("\u2713 Translation structure is already synchronized\n");
+  }
   console.log("\u{1F50D} Validating translations...\n");
   const validationResult = validateTranslations(projectRoot);
   if (validationResult.valid) {
@@ -1177,8 +1558,11 @@ async function manageTranslations(projectRoot = process.cwd(), options = {}) {
     const totalMissing = validationResult.missing.length + validationResult.empty.length;
     if (autoFill) {
       if (!apiKey) {
+        const provider = config.provider || "deepl";
+        const envVarName = provider === "google" ? "GOOGLE_TRANSLATE_API_KEY" : "DEEPL_API_KEY";
         console.log("\n\u26A0\uFE0F  Auto-fill requested but no API key provided.");
-        console.log("Set GOOGLE_TRANSLATE_API_KEY or pass --api-key to enable auto-fill.\n");
+        console.log(`Set ${envVarName} or pass --api-key to enable auto-fill.
+`);
       } else {
         console.log(`
 \u{1F916} Auto-filling ${totalMissing} missing translations...
@@ -1298,8 +1682,8 @@ Commands:
   add             Add a new translation key
 
 Options (Smart Mode):
-  -a, --auto-fill         Auto-fill missing translations with Google Translate
-  --api-key <key>         Google Translate API key (or set GOOGLE_TRANSLATE_API_KEY)
+  -a, --auto-fill         Auto-fill missing translations with DeepL or Google Translate
+  --api-key <key>         Translation API key (or set DEEPL_API_KEY/GOOGLE_TRANSLATE_API_KEY)
   -l, --language <lang>   Process only this language
   --limit <number>        Max translations to process (default: 1000)
   --skip-types            Skip TypeScript type generation
@@ -1318,7 +1702,11 @@ Examples:
   # Smart mode - check and validate translations
   translations
 
-  # Smart mode - validate and auto-fill missing translations
+  # Smart mode - validate and auto-fill missing translations (DeepL)
+  export DEEPL_API_KEY=your_key
+  translations --auto-fill
+
+  # Smart mode - validate and auto-fill missing translations (Google)
   export GOOGLE_TRANSLATE_API_KEY=your_key
   translations --auto-fill
 
@@ -1373,7 +1761,7 @@ if (command === "add") {
         const existingNamespaces = getNamespaces(translationsPath, config.sourceLanguage);
         let namespace;
         if (existingNamespaces.length > 0) {
-          const namespaceChoice = await select({
+          const namespaceChoice = await select2({
             message: "Select namespace:",
             choices: [
               ...existingNamespaces.map((ns) => ({ name: ns, value: ns })),
@@ -1431,9 +1819,12 @@ if (command === "add") {
         });
         let apiKey;
         if (autoTranslate) {
-          apiKey = values["api-key"] || process.env.GOOGLE_TRANSLATE_API_KEY;
+          const provider = config.provider || "deepl";
+          const envVarName = provider === "google" ? "GOOGLE_TRANSLATE_API_KEY" : "DEEPL_API_KEY";
+          apiKey = values["api-key"] || process.env[envVarName];
           if (!apiKey) {
-            console.log("\n\u26A0\uFE0F  GOOGLE_TRANSLATE_API_KEY environment variable not found.");
+            console.log(`
+\u26A0\uFE0F  ${envVarName} environment variable not found.`);
             console.log("Skipping auto-translation. Set this variable to enable auto-translation.\n");
           }
         }
@@ -1461,11 +1852,12 @@ if (command === "add") {
       console.log("Use --help for usage information");
       process.exit(1);
     }
-    const apiKey = values["api-key"] || process.env.GOOGLE_TRANSLATE_API_KEY;
+    const config = loadConfig(process.cwd());
+    const provider = config.provider || "deepl";
+    const envVarName = provider === "google" ? "GOOGLE_TRANSLATE_API_KEY" : "DEEPL_API_KEY";
+    const apiKey = values["api-key"] || process.env[envVarName];
     if (values["auto-fill"] && !apiKey) {
-      console.error(
-        "Error: --api-key or GOOGLE_TRANSLATE_API_KEY environment variable is required for auto-translation"
-      );
+      console.error(`Error: --api-key or ${envVarName} environment variable is required for auto-translation`);
       process.exit(1);
     }
     addTranslationKey(process.cwd(), {
@@ -1488,7 +1880,11 @@ if (command === "add") {
 } else {
   const hasFlags = values["auto-fill"] || values.language || values["skip-types"] || values["dry-run"];
   if (hasFlags) {
-    const apiKey = values["api-key"] || process.env.GOOGLE_TRANSLATE_API_KEY;
+    const configPath = path10.join(process.cwd(), ".translationsrc.json");
+    const config = fs6.existsSync(configPath) ? loadConfig(process.cwd()) : { provider: "deepl" };
+    const provider = config.provider || "deepl";
+    const envVarName = provider === "google" ? "GOOGLE_TRANSLATE_API_KEY" : "DEEPL_API_KEY";
+    const apiKey = values["api-key"] || process.env[envVarName];
     const limit = Number.parseInt(values.limit || "1000", 10);
     manageTranslations(process.cwd(), {
       autoFill: values["auto-fill"],
@@ -1511,7 +1907,7 @@ if (command === "add") {
         const configPath = path10.join(process.cwd(), ".translationsrc.json");
         const isInitialized = fs6.existsSync(configPath);
         console.log("\n\u{1F30D} Translation Management\n");
-        const action = await select({
+        const action = await select2({
           message: "What would you like to do?",
           choices: [
             {
@@ -1527,7 +1923,7 @@ if (command === "add") {
             {
               name: "\u{1F916} Auto-fill missing translations",
               value: "autofill",
-              description: "Automatically translate missing keys with Google Translate"
+              description: "Automatically translate missing keys with DeepL or Google Translate"
             },
             {
               name: "\u{1F4DD} Generate TypeScript types",
@@ -1567,7 +1963,7 @@ if (command === "add") {
           const existingNamespaces = getNamespaces(translationsPath, config.sourceLanguage);
           let namespace;
           if (existingNamespaces.length > 0) {
-            const namespaceChoice = await select({
+            const namespaceChoice = await select2({
               message: "Select namespace:",
               choices: [
                 ...existingNamespaces.map((ns) => ({ name: ns, value: ns })),
@@ -1625,9 +2021,12 @@ if (command === "add") {
           });
           let apiKey;
           if (autoTranslate) {
-            apiKey = process.env.GOOGLE_TRANSLATE_API_KEY;
+            const provider = config.provider || "deepl";
+            const envVarName = provider === "google" ? "GOOGLE_TRANSLATE_API_KEY" : "DEEPL_API_KEY";
+            apiKey = process.env[envVarName];
             if (!apiKey) {
-              console.log("\n\u26A0\uFE0F  GOOGLE_TRANSLATE_API_KEY environment variable not found.");
+              console.log(`
+\u26A0\uFE0F  ${envVarName} environment variable not found.`);
               console.log("Skipping auto-translation. Set this variable to enable auto-translation.\n");
             }
           }
@@ -1647,9 +2046,12 @@ if (command === "add") {
             skipTypes: true
           });
         } else if (action === "autofill") {
-          const apiKey = process.env.GOOGLE_TRANSLATE_API_KEY;
+          const config = loadConfig(process.cwd());
+          const provider = config.provider || "deepl";
+          const envVarName = provider === "google" ? "GOOGLE_TRANSLATE_API_KEY" : "DEEPL_API_KEY";
+          const apiKey = process.env[envVarName];
           if (!apiKey) {
-            console.log("\u26A0\uFE0F  GOOGLE_TRANSLATE_API_KEY environment variable not found.");
+            console.log(`\u26A0\uFE0F  ${envVarName} environment variable not found.`);
             console.log("Please set it to enable auto-translation.\n");
             process.exit(1);
           }