poly-lexis 0.1.0

package/dist/index.js

@@ -0,0 +1,1016 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in 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"() {
+    "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"
+    ];
+  }
+});
+
+// src/translations/core/schema.ts
+function isValidLanguage(lang) {
+  return SUPPORTED_LANGUAGES.includes(lang);
+}
+function validateLanguages(languages) {
+  const invalid = languages.filter((lang) => !isValidLanguage(lang));
+  return {
+    valid: invalid.length === 0,
+    invalid
+  };
+}
+var SUPPORTED_LANGUAGES, TRANSLATION_CONFIG_SCHEMA;
+var init_schema = __esm({
+  "src/translations/core/schema.ts"() {
+    "use strict";
+    SUPPORTED_LANGUAGES = [
+      "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)
+    ];
+    TRANSLATION_CONFIG_SCHEMA = {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      title: "Translation Configuration",
+      description: "Configuration for the translation management system",
+      type: "object",
+      properties: {
+        translationsPath: {
+          type: "string",
+          description: "Path to the translations directory relative to project root",
+          default: "public/static/locales"
+        },
+        languages: {
+          type: "array",
+          description: "List of language codes to support",
+          items: {
+            type: "string",
+            enum: SUPPORTED_LANGUAGES
+          },
+          minItems: 1,
+          uniqueItems: true
+        },
+        sourceLanguage: {
+          type: "string",
+          description: 'Source language for translations (usually "en")',
+          enum: SUPPORTED_LANGUAGES,
+          default: "en"
+        },
+        typesOutputPath: {
+          type: "string",
+          description: "Path to output TypeScript types file",
+          default: "src/types/i18nTypes.ts"
+        }
+      },
+      required: ["translationsPath", "languages", "sourceLanguage"],
+      additionalProperties: false
+    };
+  }
+});
+
+// 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"() {
+    "use strict";
+  }
+});
+
+// src/translations/cli/init.ts
+var init_exports = {};
+__export(init_exports, {
+  detectExistingTranslations: () => detectExistingTranslations,
+  initTranslations: () => initTranslations,
+  loadConfig: () => loadConfig
+});
+import * as fs2 from "fs";
+import * as path2 from "path";
+function detectExistingTranslations(projectRoot) {
+  const possiblePaths = ["public/static/locales", "public/locales", "src/locales", "locales", "i18n", "translations"];
+  for (const possiblePath of possiblePaths) {
+    const fullPath = path2.join(projectRoot, possiblePath);
+    if (fs2.existsSync(fullPath)) {
+      const languages = getAvailableLanguages(fullPath);
+      if (languages.length > 0) {
+        return { path: possiblePath, languages };
+      }
+    }
+  }
+  return { path: null, languages: [] };
+}
+function initTranslations(projectRoot, config = {}) {
+  console.log("=====");
+  console.log("Initializing translation structure");
+  console.log("=====");
+  const existing = detectExistingTranslations(projectRoot);
+  let finalConfig = { ...DEFAULT_CONFIG, ...config };
+  if (existing.path && existing.languages.length > 0) {
+    console.log(`\u2713 Detected existing translations at: ${existing.path}`);
+    console.log(`\u2713 Found languages: ${existing.languages.join(", ")}`);
+    const validation2 = validateLanguages(existing.languages);
+    if (!validation2.valid) {
+      console.log(`\u26A0\uFE0F  Warning: Invalid language codes found: ${validation2.invalid.join(", ")}`);
+      console.log("These languages will be skipped.");
+    }
+    const validLanguages = existing.languages.filter((lang) => !validation2.invalid.includes(lang));
+    finalConfig = {
+      ...finalConfig,
+      translationsPath: existing.path,
+      languages: validLanguages.length > 0 ? validLanguages : finalConfig.languages
+    };
+  }
+  const translationsPath = path2.join(projectRoot, finalConfig.translationsPath);
+  const languages = finalConfig.languages.length > 0 ? finalConfig.languages : [...DEFAULT_LANGUAGES];
+  console.log(`Project root: ${projectRoot}`);
+  console.log(`Translations path: ${translationsPath}`);
+  console.log(`Languages: ${languages.join(", ")}`);
+  console.log("=====");
+  const validation = validateLanguages(languages);
+  if (!validation.valid) {
+    throw new Error(`Invalid language codes: ${validation.invalid.join(", ")}`);
+  }
+  ensureTranslationsStructure(translationsPath, languages);
+  const sourceLanguage = finalConfig.sourceLanguage;
+  const sourcePath = path2.join(translationsPath, sourceLanguage);
+  const commonPath = path2.join(sourcePath, "common.json");
+  if (!fs2.existsSync(commonPath)) {
+    const sampleTranslations = {
+      LOADING: "Loading",
+      SAVE: "Save",
+      CANCEL: "Cancel",
+      SUBMIT: "Submit",
+      ERROR: "Error",
+      SUCCESS: "Success"
+    };
+    fs2.writeFileSync(commonPath, JSON.stringify(sampleTranslations, null, 2) + "\n", "utf-8");
+    console.log(`Created sample file: ${commonPath}`);
+  }
+  for (const lang of languages) {
+    if (lang === sourceLanguage) continue;
+    const langCommonPath = path2.join(translationsPath, lang, "common.json");
+    if (!fs2.existsSync(langCommonPath)) {
+      fs2.writeFileSync(langCommonPath, "{}\n", "utf-8");
+      console.log(`Created empty file: ${langCommonPath}`);
+    }
+  }
+  const configPath = path2.join(projectRoot, ".translationsrc.json");
+  if (!fs2.existsSync(configPath)) {
+    const configContent = {
+      $schema: "./node_modules/@repo/env-scripts/dist/translations/core/translations-config.schema.json",
+      translationsPath: finalConfig.translationsPath,
+      languages,
+      sourceLanguage,
+      typesOutputPath: finalConfig.typesOutputPath
+    };
+    fs2.writeFileSync(configPath, JSON.stringify(configContent, null, 2) + "\n", "utf-8");
+    console.log(`Created config file: ${configPath}`);
+  }
+  console.log("=====");
+  console.log("Translation structure initialized successfully!");
+  console.log("=====");
+}
+function loadConfig(projectRoot) {
+  const configPath = path2.join(projectRoot, ".translationsrc.json");
+  if (!fs2.existsSync(configPath)) {
+    const existing = detectExistingTranslations(projectRoot);
+    if (existing.path && existing.languages.length > 0) {
+      console.log(`\u2139\uFE0F  No config found, but detected translations at ${existing.path}`);
+      return {
+        ...DEFAULT_CONFIG,
+        translationsPath: existing.path,
+        languages: existing.languages
+      };
+    }
+    return DEFAULT_CONFIG;
+  }
+  const configContent = fs2.readFileSync(configPath, "utf-8");
+  const config = JSON.parse(configContent);
+  if (config.languages) {
+    const validation = validateLanguages(config.languages);
+    if (!validation.valid) {
+      console.warn(`\u26A0\uFE0F  Warning: Invalid language codes in config: ${validation.invalid.join(", ")}`);
+      console.warn("Please update .translationsrc.json with valid language codes.");
+    }
+  }
+  return { ...DEFAULT_CONFIG, ...config };
+}
+var init_init = __esm({
+  "src/translations/cli/init.ts"() {
+    "use strict";
+    init_schema();
+    init_types();
+    init_utils();
+  }
+});
+
+// src/translations/index.ts
+init_types();
+init_schema();
+init_utils();
+
+// 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.");
+  }
+  const variableMap = /* @__PURE__ */ new Map();
+  let placeholderIndex = 0;
+  const textWithPlaceholders = text.replace(/\{\{([^}]+)\}\}/g, (match) => {
+    const placeholder = `__PLACEHOLDER_${placeholderIndex}__`;
+    variableMap.set(placeholder, match);
+    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;
+  for (const [placeholder, original] of variableMap) {
+    translatedText = translatedText.replace(new RegExp(placeholder, "g"), original);
+  }
+  return translatedText;
+}
+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));
+    }
+  }
+  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 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/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 { namespace, key, value, autoTranslate = false, apiKey } = options;
+  console.log("=====");
+  console.log("Adding translation key");
+  console.log("=====");
+  console.log(`Namespace: ${namespace}`);
+  console.log(`Key: ${key}`);
+  console.log(`Value (${config.sourceLanguage}): ${value}`);
+  console.log("=====");
+  const sourceLang = config.sourceLanguage;
+  const sourceTranslations = readTranslations(translationsPath, sourceLang);
+  if (!sourceTranslations[namespace]) {
+    sourceTranslations[namespace] = {};
+  }
+  if (sourceTranslations[namespace][key]) {
+    console.log(`\u26A0 Warning: Key "${key}" already exists in ${namespace}. Updating value.`);
+  }
+  sourceTranslations[namespace][key] = value;
+  const sortedSource = sortKeys(sourceTranslations[namespace]);
+  writeTranslation(translationsPath, sourceLang, namespace, sortedSource);
+  console.log(`\u2713 Added to ${sourceLang}/${namespace}.json`);
+  const otherLanguages = config.languages.filter((lang) => lang !== sourceLang);
+  if (autoTranslate && apiKey) {
+    console.log("\nAuto-translating to other languages...");
+    for (const lang of otherLanguages) {
+      try {
+        const targetTranslations = readTranslations(translationsPath, lang);
+        if (!targetTranslations[namespace]) {
+          targetTranslations[namespace] = {};
+        }
+        if (!targetTranslations[namespace][key] || targetTranslations[namespace][key].trim() === "") {
+          const translated = await translateText(value, lang, sourceLang, apiKey);
+          targetTranslations[namespace][key] = translated;
+          const sorted = sortKeys(targetTranslations[namespace]);
+          writeTranslation(translationsPath, lang, namespace, sorted);
+          console.log(`  \u2713 ${lang}: "${translated}"`);
+          await new Promise((resolve) => setTimeout(resolve, 100));
+        } else {
+          console.log(`  - ${lang}: Already exists, skipping`);
+        }
+      } catch (error) {
+        console.error(`  \u2717 ${lang}: Translation failed - ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    }
+  } else {
+    console.log("\nAdding empty values to other languages...");
+    for (const lang of otherLanguages) {
+      const targetTranslations = readTranslations(translationsPath, lang);
+      if (!targetTranslations[namespace]) {
+        targetTranslations[namespace] = {};
+      }
+      if (!targetTranslations[namespace][key]) {
+        targetTranslations[namespace][key] = "";
+        const sorted = sortKeys(targetTranslations[namespace]);
+        writeTranslation(translationsPath, lang, namespace, sorted);
+        console.log(`  \u2713 ${lang}/${namespace}.json`);
+      } else {
+        console.log(`  - ${lang}/${namespace}.json: Already exists`);
+      }
+    }
+    if (!autoTranslate) {
+      console.log("\n\u2139 Use --auto-translate flag to automatically translate to all languages");
+    }
+  }
+  console.log("=====");
+  console.log("Translation key added successfully!");
+  console.log("=====");
+}
+async function addTranslationKeys(projectRoot, entries, autoTranslate = false, apiKey) {
+  console.log(`Adding ${entries.length} translation keys...`);
+  for (const entry of entries) {
+    await addTranslationKey(projectRoot, {
+      namespace: entry.namespace,
+      key: entry.key,
+      value: entry.value,
+      autoTranslate,
+      apiKey
+    });
+  }
+}
+
+// src/translations/cli/validate.ts
+init_utils();
+init_init();
+import * as path5 from "path";
+function validateTranslations(projectRoot = process.cwd()) {
+  const config = loadConfig(projectRoot);
+  const translationsPath = path5.join(projectRoot, config.translationsPath);
+  const sourceLanguage = config.sourceLanguage;
+  const missing = [];
+  const empty = [];
+  const sourceTranslations = readTranslations(translationsPath, sourceLanguage);
+  const sourceNamespaces = getNamespaces(translationsPath, sourceLanguage);
+  const languages = getAvailableLanguages(translationsPath).filter((lang) => lang !== sourceLanguage);
+  console.log("=====");
+  console.log("Validating translations");
+  console.log("=====");
+  console.log(`Source language: ${sourceLanguage}`);
+  console.log(`Target languages: ${languages.join(", ")}`);
+  console.log(`Namespaces: ${sourceNamespaces.join(", ")}`);
+  console.log("=====");
+  for (const language of languages) {
+    const targetTranslations = readTranslations(translationsPath, language);
+    for (const namespace of sourceNamespaces) {
+      const sourceKeys = sourceTranslations[namespace] || {};
+      const targetKeys = targetTranslations[namespace] || {};
+      for (const [key, sourceValue] of Object.entries(sourceKeys)) {
+        const targetValue = targetKeys[key];
+        if (targetValue === void 0) {
+          missing.push({
+            namespace,
+            key,
+            language,
+            sourceValue
+          });
+        } else if (typeof targetValue === "string" && targetValue.trim() === "") {
+          empty.push({
+            namespace,
+            key,
+            language,
+            sourceValue
+          });
+        }
+      }
+    }
+  }
+  const valid = missing.length === 0 && empty.length === 0;
+  if (valid) {
+    console.log("\u2713 All translations are valid!");
+  } else {
+    if (missing.length > 0) {
+      console.log(`
+\u26A0 Found ${missing.length} missing translations:`);
+      for (const item of missing.slice(0, 10)) {
+        console.log(`  ${item.language}/${item.namespace}.json -> ${item.key}`);
+      }
+      if (missing.length > 10) {
+        console.log(`  ... and ${missing.length - 10} more`);
+      }
+    }
+    if (empty.length > 0) {
+      console.log(`
+\u26A0 Found ${empty.length} empty translations:`);
+      for (const item of empty.slice(0, 10)) {
+        console.log(`  ${item.language}/${item.namespace}.json -> ${item.key}`);
+      }
+      if (empty.length > 10) {
+        console.log(`  ... and ${empty.length - 10} more`);
+      }
+    }
+  }
+  console.log("=====");
+  return { valid, missing, empty };
+}
+function getMissingForLanguage(projectRoot, language) {
+  const result = validateTranslations(projectRoot);
+  const items = [
+    ...result.missing.filter((m) => m.language === language).map((m) => ({ ...m, type: "missing" })),
+    ...result.empty.filter((e) => e.language === language).map((e) => ({ ...e, type: "empty" }))
+  ];
+  return items;
+}
+
+// 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 { 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");
+  }
+  const languagesToProcess = options.language ? [options.language] : config.languages.filter((lang) => lang !== config.sourceLanguage);
+  console.log("=====");
+  console.log("Auto-filling translations");
+  console.log("=====");
+  console.log(`Languages: ${languagesToProcess.join(", ")}`);
+  console.log(`Limit: ${limit}`);
+  console.log(`Dry run: ${dryRun}`);
+  console.log("=====");
+  let totalProcessed = 0;
+  let totalTranslated = 0;
+  for (const language of languagesToProcess) {
+    if (totalProcessed >= limit) {
+      console.log(`
+Reached limit of ${limit} translations`);
+      break;
+    }
+    console.log(`
+Processing language: ${language}`);
+    const missing = getMissingForLanguage(projectRoot, language);
+    if (missing.length === 0) {
+      console.log("  No missing or empty translations");
+      continue;
+    }
+    console.log(`  Found ${missing.length} translations to fill`);
+    const remainingLimit = limit - totalProcessed;
+    const itemsToProcess = missing.slice(0, remainingLimit);
+    for (const item of itemsToProcess) {
+      totalProcessed++;
+      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);
+        console.log(`    ${language.toUpperCase()}: "${translated}"`);
+        if (!dryRun) {
+          const translations = readTranslations(translationsPath, language);
+          if (!translations[item.namespace]) {
+            translations[item.namespace] = {};
+          }
+          translations[item.namespace][item.key] = translated;
+          const sorted = sortKeys(translations[item.namespace]);
+          writeTranslation(translationsPath, language, item.namespace, sorted);
+          console.log("    \u2713 Saved");
+        } else {
+          console.log("    \u2713 Dry run - not saved");
+        }
+        totalTranslated++;
+        if (delayMs > 0 && totalProcessed < limit) {
+          await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+      } catch (error) {
+        console.error(`    \u2717 Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    }
+  }
+  console.log("\n=====");
+  console.log(`Total processed: ${totalProcessed}`);
+  console.log(`Total translated: ${totalTranslated}`);
+  if (dryRun) {
+    console.log("\u26A0 Dry run - no changes were saved");
+  }
+  console.log("=====");
+}
+async function fillNamespace(projectRoot, language, namespace, apiKey) {
+  const config = loadConfig(projectRoot);
+  const translationsPath = path6.join(projectRoot, config.translationsPath);
+  console.log(`Filling translations for ${language}/${namespace}.json`);
+  const sourceTranslations = readTranslations(translationsPath, config.sourceLanguage);
+  const targetTranslations = readTranslations(translationsPath, language);
+  const sourceKeys = sourceTranslations[namespace] || {};
+  const targetKeys = targetTranslations[namespace] || {};
+  let count = 0;
+  for (const [key, sourceValue] of Object.entries(sourceKeys)) {
+    const targetValue = targetKeys[key];
+    if (targetValue && targetValue.trim() !== "") {
+      continue;
+    }
+    console.log(`  Translating ${key}...`);
+    const translated = await translateText(sourceValue, language, config.sourceLanguage, apiKey);
+    targetKeys[key] = translated;
+    count++;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  if (count > 0) {
+    const sorted = sortKeys(targetKeys);
+    writeTranslation(translationsPath, language, namespace, sorted);
+    console.log(`\u2713 Filled ${count} translations`);
+  } else {
+    console.log("No translations to fill");
+  }
+}
+
+// src/translations/cli/generate-types.ts
+init_utils();
+init_init();
+import { execSync } from "child_process";
+import * as fs3 from "fs";
+import * as path7 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;
+
+  export type TranslationKey = typeof translationKeys[number];
+  export type TranslationNamespace = typeof namespaceKeys[number];
+`;
+function generateTranslationTypes(projectRoot = process.cwd()) {
+  console.log("=====");
+  console.time("i18n types generated");
+  console.log("Generating i18n types");
+  console.log("=====");
+  const config = loadConfig(projectRoot);
+  const translationsPath = path7.join(projectRoot, config.translationsPath);
+  const sourceLanguage = config.sourceLanguage;
+  const outputFilePath = path7.join(projectRoot, config.typesOutputPath);
+  const dirPath = path7.join(translationsPath, sourceLanguage);
+  if (!fs3.existsSync(dirPath)) {
+    throw new Error(`Source language directory not found: ${dirPath}`);
+  }
+  const namespaces = getNamespaces(translationsPath, sourceLanguage);
+  if (namespaces.length === 0) {
+    throw new Error(`No translation files found in ${dirPath}`);
+  }
+  const translations = readTranslations(translationsPath, sourceLanguage);
+  let allKeys = [];
+  for (const namespace of namespaces) {
+    const keys = Object.keys(translations[namespace] || {});
+    allKeys = allKeys.concat(keys);
+  }
+  const outputDir = path7.dirname(outputFilePath);
+  if (!fs3.existsSync(outputDir)) {
+    fs3.mkdirSync(outputDir, { recursive: true });
+  }
+  const typeString = typeTemplate(allKeys, namespaces);
+  fs3.writeFileSync(outputFilePath, typeString, "utf8");
+  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 });
+  } catch {
+    console.warn("Failed to format with Biome, continuing without formatting...");
+  }
+  console.timeEnd("i18n types generated");
+  console.log("=====");
+}
+
+// src/translations/cli/manage.ts
+import * as fs4 from "fs";
+import * as path8 from "path";
+init_init();
+async function manageTranslations(projectRoot = process.cwd(), options = {}) {
+  const { autoFill = false, apiKey, limit = 1e3, language, skipTypes = false, dryRun = false } = options;
+  console.log("=====");
+  console.log("Translation Management");
+  console.log("=====");
+  const configPath = path8.join(projectRoot, ".translationsrc.json");
+  const isInitialized = fs4.existsSync(configPath);
+  if (!isInitialized) {
+    console.log("\u{1F4C1} No translation configuration found. Initializing...\n");
+    initTranslations(projectRoot);
+    console.log("\n\u2705 Initialization complete!\n");
+  } else {
+    console.log("\u2713 Translation structure initialized\n");
+  }
+  const config = loadConfig(projectRoot);
+  const translationsPath = path8.join(projectRoot, config.translationsPath);
+  const sourceLangPath = path8.join(translationsPath, config.sourceLanguage);
+  if (!fs4.existsSync(sourceLangPath)) {
+    console.log(`\u26A0\uFE0F  Source language directory not found: ${sourceLangPath}`);
+    console.log("Please add translation files to the source language directory.\n");
+    return;
+  }
+  console.log("\u{1F50D} Validating translations...\n");
+  const validationResult = validateTranslations(projectRoot);
+  if (validationResult.valid) {
+    console.log("\n\u2705 All translations are complete!\n");
+  } else {
+    const totalMissing = validationResult.missing.length + validationResult.empty.length;
+    if (autoFill) {
+      if (!apiKey) {
+        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");
+      } else {
+        console.log(`
+\u{1F916} Auto-filling ${totalMissing} missing translations...
+`);
+        await autoFillTranslations(projectRoot, {
+          apiKey,
+          limit,
+          language,
+          dryRun,
+          delayMs: 100
+        });
+        if (!dryRun) {
+          console.log("\n\u{1F50D} Re-validating after auto-fill...\n");
+          const revalidation = validateTranslations(projectRoot);
+          if (revalidation.valid) {
+            console.log("\n\u2705 All translations are now complete!\n");
+          }
+        }
+      }
+    } else {
+      console.log(`
+\u{1F4A1} Tip: Run with --auto-fill to automatically translate missing keys.
+`);
+    }
+  }
+  if (!skipTypes && !dryRun) {
+    console.log("\u{1F4DD} Generating TypeScript types...\n");
+    generateTranslationTypes(projectRoot);
+    console.log("\n\u2705 Types generated!\n");
+  } else if (skipTypes) {
+    console.log("\u23ED\uFE0F  Skipping type generation (--skip-types)\n");
+  } else if (dryRun) {
+    console.log("\u23ED\uFE0F  Skipping type generation (--dry-run)\n");
+  }
+  console.log("=====");
+  console.log("Summary");
+  console.log("=====");
+  console.log(`Configuration: ${configPath}`);
+  console.log(`Translations: ${translationsPath}`);
+  console.log(`Languages: ${config.languages.join(", ")}`);
+  console.log(`Source language: ${config.sourceLanguage}`);
+  if (!validationResult.valid && !autoFill) {
+    console.log(`
+\u26A0\uFE0F  ${validationResult.missing.length} missing translations`);
+    console.log(`\u26A0\uFE0F  ${validationResult.empty.length} empty translations`);
+    console.log("\nNext steps:");
+    console.log("  1. Add missing translations manually, or");
+    console.log("  2. Run with --auto-fill to translate automatically");
+  } else if (validationResult.valid) {
+    console.log("\n\u2705 All systems ready!");
+  }
+  console.log("=====\n");
+}
+export {
+  DEFAULT_CONFIG,
+  DEFAULT_LANGUAGES,
+  SUPPORTED_LANGUAGES,
+  TRANSLATION_CONFIG_SCHEMA,
+  addTranslationKey,
+  addTranslationKeys,
+  autoFillTranslations,
+  detectExistingTranslations,
+  ensureTranslationsStructure,
+  extractVariables,
+  fillNamespace,
+  generateTranslationTypes,
+  getAvailableLanguages,
+  getMissingForLanguage,
+  getNamespaces,
+  hasInterpolation,
+  initTranslations,
+  initTranslationsInteractive,
+  isValidLanguage,
+  loadConfig,
+  manageTranslations,
+  readTranslations,
+  sortKeys,
+  translateBatch,
+  translateText,
+  validateLanguages,
+  validateTranslations,
+  validateVariables,
+  writeTranslation
+};
+//# sourceMappingURL=index.js.map