poly-lexis 0.1.0 → 0.2.0

package/dist/index.js

@@ -14,33 +14,84 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/translations/core/types.ts
-var DEFAULT_CONFIG, DEFAULT_LANGUAGES;
-var init_types = __esm({
-  "src/translations/core/types.ts"() {
+// src/translations/utils/utils.ts
+import * as fs from "fs";
+import * as path from "path";
+function readTranslations(translationsPath, language) {
+  const langPath = path.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 = path.basename(file, ".json");
+    const filePath = path.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 = path.join(translationsPath, language);
+  if (!fs.existsSync(langPath)) {
+    fs.mkdirSync(langPath, { recursive: true });
+  }
+  const filePath = path.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 = path.join(translationsPath, language);
+  if (!fs.existsSync(langPath)) {
+    return [];
+  }
+  return fs.readdirSync(langPath).filter((f) => f.endsWith(".json")).map((f) => path.basename(f, ".json"));
+}
+function hasInterpolation(text) {
+  return /\{\{[^}]+\}\}/g.test(text);
+}
+function extractVariables(text) {
+  const matches = text.match(/\{\{([^}]+)\}\}/g);
+  if (!matches) return [];
+  return matches.map((match) => match.replace(/\{\{|\}\}/g, "").trim());
+}
+function validateVariables(sourceText, translatedText) {
+  const sourceVars = extractVariables(sourceText).sort();
+  const translatedVars = extractVariables(translatedText).sort();
+  if (sourceVars.length !== translatedVars.length) {
+    return false;
+  }
+  return sourceVars.every((v, i) => v === translatedVars[i]);
+}
+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 = path.join(translationsPath, lang);
+    if (!fs.existsSync(langPath)) {
+      fs.mkdirSync(langPath, { recursive: true });
+    }
+  }
+}
+var init_utils = __esm({
+  "src/translations/utils/utils.ts"() {
     "use strict";
-    DEFAULT_CONFIG = {
-      translationsPath: "public/static/locales",
-      languages: ["en"],
-      sourceLanguage: "en",
-      typesOutputPath: "src/types/i18nTypes.ts"
-    };
-    DEFAULT_LANGUAGES = [
-      "en",
-      "fr",
-      "it",
-      "pl",
-      "es",
-      "pt",
-      "de",
-      "de_at",
-      "nl",
-      "sv",
-      "hu",
-      "cs",
-      "ja",
-      "zh_hk"
-    ];
   }
 });
 
@@ -60,54 +111,274 @@ var init_schema = __esm({
   "src/translations/core/schema.ts"() {
     "use strict";
     SUPPORTED_LANGUAGES = [
+      "af",
+      // Afrikaans
+      "sq",
+      // Albanian
+      "am",
+      // Amharic
+      "ar",
+      // Arabic
+      "hy",
+      // Armenian
+      "as",
+      // Assamese
+      "ay",
+      // Aymara
+      "az",
+      // Azerbaijani
+      "bm",
+      // Bambara
+      "eu",
+      // Basque
+      "be",
+      // Belarusian
+      "bn",
+      // Bengali
+      "bho",
+      // Bhojpuri
+      "bs",
+      // Bosnian
+      "bg",
+      // Bulgarian
+      "ca",
+      // Catalan
+      "ceb",
+      // Cebuano
+      "ny",
+      // Chichewa
+      "zh",
+      // Chinese (Simplified) - Google uses 'zh' or 'zh-CN'
+      "zh_cn",
+      // Chinese (Simplified) - alternative format
+      "zh_tw",
+      // Chinese (Traditional)
+      "co",
+      // Corsican
+      "hr",
+      // Croatian
+      "cs",
+      // Czech
+      "da",
+      // Danish
+      "dv",
+      // Dhivehi
+      "doi",
+      // Dogri
+      "nl",
+      // Dutch
       "en",
       // English
+      "eo",
+      // Esperanto
+      "et",
+      // Estonian
+      "ee",
+      // Ewe
+      "tl",
+      // Filipino (Tagalog)
+      "fi",
+      // Finnish
       "fr",
       // French
-      "it",
-      // Italian
-      "pl",
-      // Polish
-      "es",
-      // Spanish
-      "pt",
-      // Portuguese
+      "gl",
+      // Galician
+      "ka",
+      // Georgian
       "de",
       // German
-      "de_at",
-      // German (Austria)
-      "nl",
-      // Dutch
-      "sv",
-      // Swedish
+      "el",
+      // Greek
+      "gn",
+      // Guarani
+      "gu",
+      // Gujarati
+      "ht",
+      // Haitian Creole
+      "ha",
+      // Hausa
+      "haw",
+      // Hawaiian
+      "iw",
+      // Hebrew (legacy code, 'he' is preferred)
+      "he",
+      // Hebrew
+      "hi",
+      // Hindi
+      "hmn",
+      // Hmong
       "hu",
       // Hungarian
-      "cs",
-      // Czech
+      "is",
+      // Icelandic
+      "ig",
+      // Igbo
+      "ilo",
+      // Ilocano
+      "id",
+      // Indonesian
+      "ga",
+      // Irish
+      "it",
+      // Italian
       "ja",
       // Japanese
-      "zh_hk",
-      // Chinese (Hong Kong)
-      "zh_cn",
-      // Chinese (Simplified)
+      "jw",
+      // Javanese
+      "kn",
+      // Kannada
+      "kk",
+      // Kazakh
+      "km",
+      // Khmer
+      "rw",
+      // Kinyarwanda
+      "gom",
+      // Konkani
       "ko",
       // Korean
+      "kri",
+      // Krio
+      "ku",
+      // Kurdish (Kurmanji)
+      "ckb",
+      // Kurdish (Sorani)
+      "ky",
+      // Kyrgyz
+      "lo",
+      // Lao
+      "la",
+      // Latin
+      "lv",
+      // Latvian
+      "ln",
+      // Lingala
+      "lt",
+      // Lithuanian
+      "lg",
+      // Luganda
+      "lb",
+      // Luxembourgish
+      "mk",
+      // Macedonian
+      "mai",
+      // Maithili
+      "mg",
+      // Malagasy
+      "ms",
+      // Malay
+      "ml",
+      // Malayalam
+      "mt",
+      // Maltese
+      "mi",
+      // Maori
+      "mr",
+      // Marathi
+      "mni",
+      // Meiteilon (Manipuri)
+      "lus",
+      // Mizo
+      "mn",
+      // Mongolian
+      "my",
+      // Myanmar (Burmese)
+      "ne",
+      // Nepali
+      "no",
+      // Norwegian
+      "or",
+      // Odia
+      "om",
+      // Oromo
+      "ps",
+      // Pashto
+      "fa",
+      // Persian
+      "pl",
+      // Polish
+      "pt",
+      // Portuguese
+      "pt_br",
+      // Portuguese (Brazil)
+      "pa",
+      // Punjabi
+      "qu",
+      // Quechua
+      "ro",
+      // Romanian
       "ru",
       // Russian
-      "ar",
-      // Arabic
-      "he",
-      // Hebrew
+      "sm",
+      // Samoan
+      "sa",
+      // Sanskrit
+      "gd",
+      // Scottish Gaelic
+      "sr",
+      // Serbian
+      "st",
+      // Sesotho
+      "sn",
+      // Shona
+      "sd",
+      // Sindhi
+      "si",
+      // Sinhala
+      "sk",
+      // Slovak
+      "sl",
+      // Slovenian
+      "so",
+      // Somali
+      "es",
+      // Spanish
+      "su",
+      // Sundanese
+      "sw",
+      // Swahili
+      "sv",
+      // Swedish
+      "tg",
+      // Tajik
+      "ta",
+      // Tamil
+      "tt",
+      // Tatar
+      "te",
+      // Telugu
+      "th",
+      // Thai
+      "ti",
+      // Tigrinya
+      "ts",
+      // Tsonga
       "tr",
       // Turkish
-      "da",
-      // Danish
-      "fi",
-      // Finnish
-      "no",
-      // Norwegian
-      "pt_br"
-      // Portuguese (Brazil)
+      "tk",
+      // Turkmen
+      "ak",
+      // Twi
+      "uk",
+      // Ukrainian
+      "ur",
+      // Urdu
+      "ug",
+      // Uyghur
+      "uz",
+      // Uzbek
+      "vi",
+      // Vietnamese
+      "cy",
+      // Welsh
+      "xh",
+      // Xhosa
+      "yi",
+      // Yiddish
+      "yo",
+      // Yoruba
+      "zu"
+      // Zulu
     ];
     TRANSLATION_CONFIG_SCHEMA = {
       $schema: "http://json-schema.org/draft-07/schema#",
@@ -148,83 +419,33 @@ var init_schema = __esm({
   }
 });
 
-// src/translations/utils/utils.ts
-import * as fs from "fs";
-import * as path from "path";
-function readTranslations(translationsPath, language) {
-  const langPath = path.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 = path.basename(file, ".json");
-    const filePath = path.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 = path.join(translationsPath, language);
-  if (!fs.existsSync(langPath)) {
-    fs.mkdirSync(langPath, { recursive: true });
-  }
-  const filePath = path.join(langPath, `${namespace}.json`);
-  fs.writeFileSync(filePath, JSON.stringify(translations, null, 2) + "\n", "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 = path.join(translationsPath, language);
-  if (!fs.existsSync(langPath)) {
-    return [];
-  }
-  return fs.readdirSync(langPath).filter((f) => f.endsWith(".json")).map((f) => path.basename(f, ".json"));
-}
-function hasInterpolation(text) {
-  return /\{\{[^}]+\}\}/g.test(text);
-}
-function extractVariables(text) {
-  const matches = text.match(/\{\{([^}]+)\}\}/g);
-  if (!matches) return [];
-  return matches.map((match) => match.replace(/\{\{|\}\}/g, "").trim());
-}
-function validateVariables(sourceText, translatedText) {
-  const sourceVars = extractVariables(sourceText).sort();
-  const translatedVars = extractVariables(translatedText).sort();
-  if (sourceVars.length !== translatedVars.length) {
-    return false;
-  }
-  return sourceVars.every((v, i) => v === translatedVars[i]);
-}
-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 = path.join(translationsPath, lang);
-    if (!fs.existsSync(langPath)) {
-      fs.mkdirSync(langPath, { recursive: true });
-    }
-  }
-}
-var init_utils = __esm({
-  "src/translations/utils/utils.ts"() {
+// src/translations/core/types.ts
+var DEFAULT_CONFIG, DEFAULT_LANGUAGES;
+var init_types = __esm({
+  "src/translations/core/types.ts"() {
     "use strict";
+    DEFAULT_CONFIG = {
+      translationsPath: "public/static/locales",
+      languages: ["en"],
+      sourceLanguage: "en",
+      typesOutputPath: "src/types/i18nTypes.ts"
+    };
+    DEFAULT_LANGUAGES = [
+      "en",
+      "fr",
+      "it",
+      "pl",
+      "es",
+      "pt",
+      "de",
+      "de_at",
+      "nl",
+      "sv",
+      "hu",
+      "cs",
+      "ja",
+      "zh_hk"
+    ];
   }
 });
 
@@ -294,7 +515,8 @@ function initTranslations(projectRoot, config = {}) {
       ERROR: "Error",
       SUCCESS: "Success"
     };
-    fs2.writeFileSync(commonPath, JSON.stringify(sampleTranslations, null, 2) + "\n", "utf-8");
+    fs2.writeFileSync(commonPath, `${JSON.stringify(sampleTranslations, null, 2)}
+`, "utf-8");
     console.log(`Created sample file: ${commonPath}`);
   }
   for (const lang of languages) {
@@ -314,7 +536,8 @@ function initTranslations(projectRoot, config = {}) {
       sourceLanguage,
       typesOutputPath: finalConfig.typesOutputPath
     };
-    fs2.writeFileSync(configPath, JSON.stringify(configContent, null, 2) + "\n", "utf-8");
+    fs2.writeFileSync(configPath, `${JSON.stringify(configContent, null, 2)}
+`, "utf-8");
     console.log(`Created config file: ${configPath}`);
   }
   console.log("=====");
@@ -355,16 +578,11 @@ var init_init = __esm({
   }
 });
 
-// src/translations/index.ts
-init_types();
-init_schema();
-init_utils();
+// src/translations/cli/add-key.ts
+import * as path3 from "path";
 
-// src/translations/utils/translator.ts
-async function translateText(text, targetLang, sourceLang = "en", apiKey) {
-  if (!apiKey) {
-    throw new Error("Google Translate API key is required. Set GOOGLE_TRANSLATE_API_KEY environment variable.");
-  }
+// src/translations/utils/google-translate-provider.ts
+function preserveVariables(text) {
   const variableMap = /* @__PURE__ */ new Map();
   let placeholderIndex = 0;
   const textWithPlaceholders = text.replace(/\{\{([^}]+)\}\}/g, (match) => {
@@ -373,209 +591,99 @@ async function translateText(text, targetLang, sourceLang = "en", apiKey) {
     placeholderIndex++;
     return placeholder;
   });
-  const url = `https://translation.googleapis.com/language/translate/v2?key=${apiKey}`;
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({
-      q: textWithPlaceholders,
-      source: sourceLang,
-      target: targetLang.split("_")[0],
-      // Convert 'pt_BR' to 'pt'
-      format: "text"
-    })
-  });
-  const data = await response.json();
-  if (data.error) {
-    throw new Error(`Google Translate API error: ${data.error.message}`);
-  }
-  let translatedText = data.data.translations[0].translatedText;
+  return { textWithPlaceholders, variableMap };
+}
+function restoreVariables(text, variableMap) {
+  let result = text;
   for (const [placeholder, original] of variableMap) {
-    translatedText = translatedText.replace(new RegExp(placeholder, "g"), original);
+    result = result.replace(new RegExp(placeholder, "g"), original);
   }
-  return translatedText;
+  return result;
 }
-async function translateBatch(texts, targetLang, sourceLang = "en", apiKey, delayMs = 100) {
-  const results = [];
-  for (const text of texts) {
-    const translated = await translateText(text, targetLang, sourceLang, apiKey);
-    results.push(translated);
-    if (delayMs > 0) {
-      await new Promise((resolve) => setTimeout(resolve, delayMs));
+var GoogleTranslateProvider = class {
+  async translate(options) {
+    const { text, sourceLang, targetLang, apiKey } = 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 { textWithPlaceholders, variableMap } = preserveVariables(text);
+    const url = `https://translation.googleapis.com/language/translate/v2?key=${apiKey}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        q: textWithPlaceholders,
+        source: sourceLang,
+        target: targetLang.split("_")[0],
+        // Convert 'pt_BR' to 'pt'
+        format: "text"
+      })
+    });
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(`Google Translate API error: ${data.error.message}`);
+    }
+    const translatedText = data.data.translations[0].translatedText;
+    return restoreVariables(translatedText, variableMap);
   }
-  return results;
-}
-
-// src/translations/index.ts
-init_init();
-
-// src/translations/cli/init-interactive.ts
-init_schema();
-init_types();
-init_init();
-import * as path3 from "path";
-import { checkbox, confirm, input } from "@inquirer/prompts";
-async function initTranslationsInteractive(projectRoot = process.cwd()) {
-  console.log("\n\u{1F30D} Translation System Setup\n");
-  const configPath = path3.join(projectRoot, ".translationsrc.json");
-  const alreadyExists = __require("fs").existsSync(configPath);
-  if (alreadyExists) {
-    console.log("\u26A0\uFE0F  Configuration file already exists at .translationsrc.json\n");
-    const shouldOverwrite = await confirm({
-      message: "Would you like to reconfigure?",
-      default: false
-    });
-    if (!shouldOverwrite) {
-      console.log("\u2713 Keeping existing configuration");
-      return;
-    }
-  }
-  const { detectExistingTranslations: detectExistingTranslations2 } = await Promise.resolve().then(() => (init_init(), init_exports));
-  const existing = detectExistingTranslations2(projectRoot);
-  let translationsPath;
-  let languages;
-  if (existing.path) {
-    console.log(`\u2713 Found existing translations at: ${existing.path}`);
-    const useExisting = await confirm({
-      message: "Use this location?",
-      default: true
-    });
-    if (useExisting) {
-      translationsPath = existing.path;
-    } else {
-      translationsPath = await input({
-        message: "Enter translations directory path:",
-        default: DEFAULT_CONFIG.translationsPath,
-        validate: (value) => {
-          if (!value.trim()) return "Path is required";
-          return true;
-        }
-      });
-    }
-  } else {
-    translationsPath = await input({
-      message: "Where should translations be stored?",
-      default: DEFAULT_CONFIG.translationsPath,
-      validate: (value) => {
-        if (!value.trim()) return "Path is required";
-        return true;
-      }
-    });
-  }
-  if (existing.languages.length > 0) {
-    console.log(`\u2713 Found existing languages: ${existing.languages.join(", ")}`);
-    const useExistingLangs = await confirm({
-      message: "Use these languages?",
-      default: true
-    });
-    if (useExistingLangs) {
-      languages = existing.languages;
-    } else {
-      languages = await selectLanguages();
-    }
-  } else {
-    languages = await selectLanguages();
-  }
-  const sourceLanguage = await input({
-    message: "What is your source language?",
-    default: "en",
-    validate: (value) => {
-      if (!SUPPORTED_LANGUAGES.includes(value)) {
-        return `Invalid language code. Must be one of: ${SUPPORTED_LANGUAGES.join(", ")}`;
-      }
-      if (!languages.includes(value)) {
-        return "Source language must be in the list of supported languages";
-      }
-      return true;
-    }
-  });
-  const typesOutputPath = await input({
-    message: "Where should TypeScript types be generated?",
-    default: DEFAULT_CONFIG.typesOutputPath
-  });
-  console.log("\n\u{1F4CB} Configuration Summary:");
-  console.log(`   Translations: ${translationsPath}`);
-  console.log(`   Languages: ${languages.join(", ")}`);
-  console.log(`   Source: ${sourceLanguage}`);
-  console.log(`   Types: ${typesOutputPath}`);
-  const confirmInit = await confirm({
-    message: "\nProceed with initialization?",
-    default: true
-  });
-  if (!confirmInit) {
-    console.log("\u274C Cancelled");
-    return;
-  }
-  const config = {
-    translationsPath,
-    languages,
-    sourceLanguage,
-    typesOutputPath
-  };
-  console.log();
-  initTranslations(projectRoot, config);
-  console.log("\n\u{1F4DD} Configuration saved to: .translationsrc.json");
-  console.log("\n\u{1F4A1} Next steps:");
-  console.log('   1. Run "translations add" to add your first translation key');
-  console.log('   2. Run "translations" to validate and generate types');
-  console.log("   3. Check the .translationsrc.json file for your configuration\n");
+  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.GOOGLE_TRANSLATE_API_KEY;
+    return !!apiKey;
+  }
+};
+
+// src/translations/utils/translator.ts
+var defaultProvider = new GoogleTranslateProvider();
+var customProvider = null;
+function setTranslationProvider(provider) {
+  customProvider = provider;
 }
-async function selectLanguages() {
-  const languageChoices = SUPPORTED_LANGUAGES.map((lang) => ({
-    name: `${lang} - ${getLanguageName(lang)}`,
-    value: lang,
-    checked: lang === "en"
-    // English selected by default
-  }));
-  const selected = await checkbox({
-    message: "Select languages to support (space to select, enter to confirm):",
-    choices: languageChoices,
-    required: true,
-    pageSize: 15,
-    loop: false
+function getTranslationProvider() {
+  return customProvider || defaultProvider;
+}
+function resetTranslationProvider() {
+  customProvider = null;
+}
+async function translateText(text, targetLang, sourceLang = "en", apiKey) {
+  const provider = getTranslationProvider();
+  return provider.translate({
+    text,
+    sourceLang,
+    targetLang,
+    apiKey
   });
-  return selected;
 }
-function getLanguageName(code) {
-  const names = {
-    en: "English",
-    fr: "French",
-    it: "Italian",
-    pl: "Polish",
-    es: "Spanish",
-    pt: "Portuguese",
-    de: "German",
-    de_at: "German (Austria)",
-    nl: "Dutch",
-    sv: "Swedish",
-    hu: "Hungarian",
-    cs: "Czech",
-    ja: "Japanese",
-    zh_hk: "Chinese (Hong Kong)",
-    zh_cn: "Chinese (Simplified)",
-    ko: "Korean",
-    ru: "Russian",
-    ar: "Arabic",
-    he: "Hebrew",
-    tr: "Turkish",
-    da: "Danish",
-    fi: "Finnish",
-    no: "Norwegian",
-    pt_br: "Portuguese (Brazil)"
-  };
-  return names[code] || code;
+async function translateBatch(texts, targetLang, sourceLang = "en", apiKey, delayMs = 100) {
+  const provider = getTranslationProvider();
+  return provider.translateBatch(texts, sourceLang, targetLang, apiKey, delayMs);
 }
 
 // src/translations/cli/add-key.ts
-import * as path4 from "path";
 init_utils();
 init_init();
 async function addTranslationKey(projectRoot, options) {
   const config = loadConfig(projectRoot);
-  const translationsPath = path4.join(projectRoot, config.translationsPath);
+  const translationsPath = path3.join(projectRoot, config.translationsPath);
   const { namespace, key, value, autoTranslate = false, apiKey } = options;
   console.log("=====");
   console.log("Adding translation key");
@@ -656,13 +764,18 @@ async function addTranslationKeys(projectRoot, entries, autoTranslate = false, a
   }
 }
 
+// src/translations/cli/auto-fill.ts
+import * as path5 from "path";
+init_utils();
+init_init();
+
 // src/translations/cli/validate.ts
 init_utils();
 init_init();
-import * as path5 from "path";
+import * as path4 from "path";
 function validateTranslations(projectRoot = process.cwd()) {
   const config = loadConfig(projectRoot);
-  const translationsPath = path5.join(projectRoot, config.translationsPath);
+  const translationsPath = path4.join(projectRoot, config.translationsPath);
   const sourceLanguage = config.sourceLanguage;
   const missing = [];
   const empty = [];
@@ -739,12 +852,9 @@ function getMissingForLanguage(projectRoot, language) {
 }
 
 // src/translations/cli/auto-fill.ts
-import * as path6 from "path";
-init_utils();
-init_init();
 async function autoFillTranslations(projectRoot = process.cwd(), options = {}) {
   const config = loadConfig(projectRoot);
-  const translationsPath = path6.join(projectRoot, config.translationsPath);
+  const translationsPath = path5.join(projectRoot, config.translationsPath);
   const { apiKey, limit = 1e3, delayMs = 100, dryRun = false } = options;
   if (!apiKey) {
     throw new Error("Google Translate API key is required. Set GOOGLE_TRANSLATE_API_KEY or pass --api-key");
@@ -813,7 +923,7 @@ Processing language: ${language}`);
 }
 async function fillNamespace(projectRoot, language, namespace, apiKey) {
   const config = loadConfig(projectRoot);
-  const translationsPath = path6.join(projectRoot, config.translationsPath);
+  const translationsPath = path5.join(projectRoot, config.translationsPath);
   console.log(`Filling translations for ${language}/${namespace}.json`);
   const sourceTranslations = readTranslations(translationsPath, config.sourceLanguage);
   const targetTranslations = readTranslations(translationsPath, language);
@@ -845,7 +955,7 @@ init_utils();
 init_init();
 import { execSync } from "child_process";
 import * as fs3 from "fs";
-import * as path7 from "path";
+import * as path6 from "path";
 var typeTemplate = (translationKeys, namespaceKeys) => `
   export const translationKeys = [${translationKeys.map((key) => `"${key}"`).join(", ")}] as const;
   export const namespaceKeys = [${namespaceKeys.map((key) => `"${key}"`).join(", ")}] as const;
@@ -859,10 +969,10 @@ function generateTranslationTypes(projectRoot = process.cwd()) {
   console.log("Generating i18n types");
   console.log("=====");
   const config = loadConfig(projectRoot);
-  const translationsPath = path7.join(projectRoot, config.translationsPath);
+  const translationsPath = path6.join(projectRoot, config.translationsPath);
   const sourceLanguage = config.sourceLanguage;
-  const outputFilePath = path7.join(projectRoot, config.typesOutputPath);
-  const dirPath = path7.join(translationsPath, sourceLanguage);
+  const outputFilePath = path6.join(projectRoot, config.typesOutputPath);
+  const dirPath = path6.join(translationsPath, sourceLanguage);
   if (!fs3.existsSync(dirPath)) {
     throw new Error(`Source language directory not found: ${dirPath}`);
   }
@@ -876,7 +986,7 @@ function generateTranslationTypes(projectRoot = process.cwd()) {
     const keys = Object.keys(translations[namespace] || {});
     allKeys = allKeys.concat(keys);
   }
-  const outputDir = path7.dirname(outputFilePath);
+  const outputDir = path6.dirname(outputFilePath);
   if (!fs3.existsSync(outputDir)) {
     fs3.mkdirSync(outputDir, { recursive: true });
   }
@@ -885,7 +995,10 @@ function generateTranslationTypes(projectRoot = process.cwd()) {
   console.log(`Generated types with ${allKeys.length} keys and ${namespaces.length} namespaces`);
   console.log(`Output: ${outputFilePath}`);
   try {
-    execSync(`pnpm biome format --write ${outputFilePath}`, { stdio: "inherit", cwd: projectRoot });
+    execSync(`pnpm biome format --write ${outputFilePath}`, {
+      stdio: "inherit",
+      cwd: projectRoot
+    });
   } catch {
     console.warn("Failed to format with Biome, continuing without formatting...");
   }
@@ -893,6 +1006,166 @@ function generateTranslationTypes(projectRoot = process.cwd()) {
   console.log("=====");
 }
 
+// src/translations/index.ts
+init_init();
+
+// src/translations/cli/init-interactive.ts
+init_schema();
+init_types();
+init_init();
+import * as path7 from "path";
+import { checkbox, confirm, input } from "@inquirer/prompts";
+async function initTranslationsInteractive(projectRoot = process.cwd()) {
+  console.log("\n\u{1F30D} Translation System Setup\n");
+  const configPath = path7.join(projectRoot, ".translationsrc.json");
+  const alreadyExists = __require("fs").existsSync(configPath);
+  if (alreadyExists) {
+    console.log("\u26A0\uFE0F  Configuration file already exists at .translationsrc.json\n");
+    const shouldOverwrite = await confirm({
+      message: "Would you like to reconfigure?",
+      default: false
+    });
+    if (!shouldOverwrite) {
+      console.log("\u2713 Keeping existing configuration");
+      return;
+    }
+  }
+  const { detectExistingTranslations: detectExistingTranslations2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+  const existing = detectExistingTranslations2(projectRoot);
+  let translationsPath;
+  let languages;
+  if (existing.path) {
+    console.log(`\u2713 Found existing translations at: ${existing.path}`);
+    const useExisting = await confirm({
+      message: "Use this location?",
+      default: true
+    });
+    if (useExisting) {
+      translationsPath = existing.path;
+    } else {
+      translationsPath = await input({
+        message: "Enter translations directory path:",
+        default: DEFAULT_CONFIG.translationsPath,
+        validate: (value) => {
+          if (!value.trim()) return "Path is required";
+          return true;
+        }
+      });
+    }
+  } else {
+    translationsPath = await input({
+      message: "Where should translations be stored?",
+      default: DEFAULT_CONFIG.translationsPath,
+      validate: (value) => {
+        if (!value.trim()) return "Path is required";
+        return true;
+      }
+    });
+  }
+  if (existing.languages.length > 0) {
+    console.log(`\u2713 Found existing languages: ${existing.languages.join(", ")}`);
+    const useExistingLangs = await confirm({
+      message: "Use these languages?",
+      default: true
+    });
+    if (useExistingLangs) {
+      languages = existing.languages;
+    } else {
+      languages = await selectLanguages();
+    }
+  } else {
+    languages = await selectLanguages();
+  }
+  const sourceLanguage = await input({
+    message: "What is your source language?",
+    default: "en",
+    validate: (value) => {
+      if (!SUPPORTED_LANGUAGES.includes(value)) {
+        return `Invalid language code. Must be one of: ${SUPPORTED_LANGUAGES.join(", ")}`;
+      }
+      if (!languages.includes(value)) {
+        return "Source language must be in the list of supported languages";
+      }
+      return true;
+    }
+  });
+  const typesOutputPath = await input({
+    message: "Where should TypeScript types be generated?",
+    default: DEFAULT_CONFIG.typesOutputPath
+  });
+  console.log("\n\u{1F4CB} Configuration Summary:");
+  console.log(`   Translations: ${translationsPath}`);
+  console.log(`   Languages: ${languages.join(", ")}`);
+  console.log(`   Source: ${sourceLanguage}`);
+  console.log(`   Types: ${typesOutputPath}`);
+  const confirmInit = await confirm({
+    message: "\nProceed with initialization?",
+    default: true
+  });
+  if (!confirmInit) {
+    console.log("\u274C Cancelled");
+    return;
+  }
+  const config = {
+    translationsPath,
+    languages,
+    sourceLanguage,
+    typesOutputPath
+  };
+  console.log();
+  initTranslations(projectRoot, config);
+  console.log("\n\u{1F4DD} Configuration saved to: .translationsrc.json");
+  console.log("\n\u{1F4A1} Next steps:");
+  console.log('   1. Run "translations add" to add your first translation key');
+  console.log('   2. Run "translations" to validate and generate types');
+  console.log("   3. Check the .translationsrc.json file for your configuration\n");
+}
+async function selectLanguages() {
+  const languageChoices = SUPPORTED_LANGUAGES.map((lang) => ({
+    name: `${lang} - ${getLanguageName(lang)}`,
+    value: lang,
+    checked: lang === "en"
+    // English selected by default
+  }));
+  const selected = await checkbox({
+    message: "Select languages to support (space to select, enter to confirm):",
+    choices: languageChoices,
+    required: true,
+    pageSize: 15,
+    loop: false
+  });
+  return selected;
+}
+function getLanguageName(code) {
+  const names = {
+    en: "English",
+    fr: "French",
+    it: "Italian",
+    pl: "Polish",
+    es: "Spanish",
+    pt: "Portuguese",
+    de: "German",
+    de_at: "German (Austria)",
+    nl: "Dutch",
+    sv: "Swedish",
+    hu: "Hungarian",
+    cs: "Czech",
+    ja: "Japanese",
+    zh_hk: "Chinese (Hong Kong)",
+    zh_cn: "Chinese (Simplified)",
+    ko: "Korean",
+    ru: "Russian",
+    ar: "Arabic",
+    he: "Hebrew",
+    tr: "Turkish",
+    da: "Danish",
+    fi: "Finnish",
+    no: "Norwegian",
+    pt_br: "Portuguese (Brazil)"
+  };
+  return names[code] || code;
+}
+
 // src/translations/cli/manage.ts
 import * as fs4 from "fs";
 import * as path8 from "path";
@@ -982,9 +1255,15 @@ async function manageTranslations(projectRoot = process.cwd(), options = {}) {
   }
   console.log("=====\n");
 }
+
+// src/translations/index.ts
+init_schema();
+init_types();
+init_utils();
 export {
   DEFAULT_CONFIG,
   DEFAULT_LANGUAGES,
+  GoogleTranslateProvider,
   SUPPORTED_LANGUAGES,
   TRANSLATION_CONFIG_SCHEMA,
   addTranslationKey,
@@ -998,6 +1277,7 @@ export {
   getAvailableLanguages,
   getMissingForLanguage,
   getNamespaces,
+  getTranslationProvider,
   hasInterpolation,
   initTranslations,
   initTranslationsInteractive,
@@ -1005,6 +1285,8 @@ export {
   loadConfig,
   manageTranslations,
   readTranslations,
+  resetTranslationProvider,
+  setTranslationProvider,
   sortKeys,
   translateBatch,
   translateText,