poly-lexis 0.1.0

package/dist/cli/translations.js

@@ -0,0 +1,1364 @@
+#!/usr/bin/env node
+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 });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// 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) + "\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 = 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);
+}
+function validateLanguages(languages) {
+  const invalid = languages.filter((lang) => !isValidLanguage(lang));
+  return {
+    valid: invalid.length === 0,
+    invalid
+  };
+}
+var SUPPORTED_LANGUAGES;
+var init_schema = __esm({
+  "src/translations/core/schema.ts"() {
+    "use strict";
+    init_esm_shims();
+    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)
+    ];
+  }
+});
+
+// src/translations/core/types.ts
+var DEFAULT_CONFIG, DEFAULT_LANGUAGES;
+var init_types = __esm({
+  "src/translations/core/types.ts"() {
+    "use strict";
+    init_esm_shims();
+    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/cli/init.ts
+var init_exports = {};
+__export(init_exports, {
+  detectExistingTranslations: () => detectExistingTranslations,
+  initTranslations: () => initTranslations,
+  loadConfig: () => loadConfig
+});
+import * as fs2 from "fs";
+import * as path3 from "path";
+function detectExistingTranslations(projectRoot) {
+  const possiblePaths = ["public/static/locales", "public/locales", "src/locales", "locales", "i18n", "translations"];
+  for (const possiblePath of possiblePaths) {
+    const fullPath = path3.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 = path3.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 = path3.join(translationsPath, sourceLanguage);
+  const commonPath = path3.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 = path3.join(translationsPath, lang, "common.json");
+    if (!fs2.existsSync(langCommonPath)) {
+      fs2.writeFileSync(langCommonPath, "{}\n", "utf-8");
+      console.log(`Created empty file: ${langCommonPath}`);
+    }
+  }
+  const configPath = path3.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 = path3.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_esm_shims();
+    init_schema();
+    init_types();
+    init_utils();
+  }
+});
+
+// src/translations/cli/generate-types.ts
+var generate_types_exports = {};
+__export(generate_types_exports, {
+  generateTranslationTypes: () => generateTranslationTypes
+});
+import { execSync } from "child_process";
+import * as fs3 from "fs";
+import * as path8 from "path";
+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 = path8.join(projectRoot, config.translationsPath);
+  const sourceLanguage = config.sourceLanguage;
+  const outputFilePath = path8.join(projectRoot, config.typesOutputPath);
+  const dirPath = path8.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 = path8.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("=====");
+}
+var typeTemplate;
+var init_generate_types = __esm({
+  "src/translations/cli/generate-types.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    init_init();
+    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];
+`;
+  }
+});
+
+// src/cli/translations.ts
+init_esm_shims();
+import "dotenv/config";
+import { confirm as confirm2, input as input2, select } from "@inquirer/prompts";
+import * as fs5 from "fs";
+import * as path10 from "path";
+import { parseArgs } from "util";
+
+// src/translations/cli/add-key.ts
+init_esm_shims();
+import * as path4 from "path";
+
+// src/translations/utils/translator.ts
+init_esm_shims();
+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;
+}
+
+// src/translations/cli/add-key.ts
+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("=====");
+}
+
+// src/cli/translations.ts
+init_init();
+
+// src/translations/cli/init-interactive.ts
+init_esm_shims();
+init_schema();
+init_types();
+init_init();
+import * as path5 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 = path5.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
+init_esm_shims();
+import * as fs4 from "fs";
+import * as path9 from "path";
+
+// src/translations/cli/auto-fill.ts
+init_esm_shims();
+import * as path7 from "path";
+init_utils();
+init_init();
+
+// src/translations/cli/validate.ts
+init_esm_shims();
+init_utils();
+init_init();
+import * as path6 from "path";
+function validateTranslations(projectRoot = process.cwd()) {
+  const config = loadConfig(projectRoot);
+  const translationsPath = path6.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
+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;
+  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("=====");
+}
+
+// src/translations/cli/manage.ts
+init_generate_types();
+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 = path9.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 = path9.join(projectRoot, config.translationsPath);
+  const sourceLangPath = path9.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");
+}
+
+// src/cli/translations.ts
+init_utils();
+var { values, positionals } = parseArgs({
+  options: {
+    "auto-fill": {
+      type: "boolean",
+      short: "a",
+      default: false
+    },
+    "api-key": {
+      type: "string"
+    },
+    limit: {
+      type: "string",
+      default: "1000"
+    },
+    language: {
+      type: "string",
+      short: "l"
+    },
+    "skip-types": {
+      type: "boolean",
+      default: false
+    },
+    "dry-run": {
+      type: "boolean",
+      short: "d",
+      default: false
+    },
+    namespace: {
+      type: "string",
+      short: "n"
+    },
+    key: {
+      type: "string",
+      short: "k"
+    },
+    value: {
+      type: "string",
+      short: "v"
+    },
+    help: {
+      type: "boolean",
+      short: "h"
+    }
+  },
+  allowPositionals: true
+});
+if (values.help) {
+  console.log(`
+Usage: translations [command] [options]
+
+Smart translation management - automatically handles initialization, validation,
+auto-filling, and type generation based on your project's current state.
+
+Commands:
+  (none)          Smart mode - validates, fills, and generates types
+  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)
+  -l, --language <lang>   Process only this language
+  --limit <number>        Max translations to process (default: 1000)
+  --skip-types            Skip TypeScript type generation
+  -d, --dry-run           Preview changes without saving
+  -h, --help              Show this help
+
+Options (Add Mode):
+  -n, --namespace <name>  Namespace for the translation
+  -k, --key <key>         Translation key
+  -v, --value <value>     Translation value in source language
+  -a, --auto-fill         Auto-translate to all languages
+
+  (no options)            Interactive mode - prompts for all inputs
+
+Examples:
+  # Smart mode - check and validate translations
+  translations
+
+  # Smart mode - validate and auto-fill missing translations
+  export GOOGLE_TRANSLATE_API_KEY=your_key
+  translations --auto-fill
+
+  # Smart mode - auto-fill only French translations
+  translations --auto-fill --language fr
+
+  # Preview what would be translated (dry-run)
+  translations --auto-fill --dry-run
+
+  # Add a new translation key (interactive mode)
+  translations add
+
+  # Add with flags (non-interactive)
+  translations add --namespace common --key HELLO --value "Hello"
+
+  # Add with auto-translation
+  translations add -n common -k WELCOME -v "Welcome" --auto-fill
+
+What happens in smart mode:
+  1. Checks if translations are initialized (creates .translationsrc.json if needed)
+  2. Validates all translations against source language
+  3. Auto-fills missing translations if --auto-fill is provided
+  4. Generates TypeScript types (unless --skip-types)
+  5. Shows summary and next steps
+`);
+  process.exit(0);
+}
+var command = positionals[0];
+if (command === "add") {
+  if (!values.namespace && !values.key && !values.value) {
+    (async () => {
+      try {
+        console.log("\n\u2728 Add a new translation key\n");
+        const configPath = path10.join(process.cwd(), ".translationsrc.json");
+        const isInitialized = fs5.existsSync(configPath);
+        if (!isInitialized) {
+          console.log("\u26A0\uFE0F  Translation structure not initialized.");
+          const shouldInit = await confirm2({
+            message: "Would you like to initialize it now?",
+            default: true
+          });
+          if (shouldInit) {
+            await initTranslationsInteractive(process.cwd());
+            console.log();
+          } else {
+            console.log("\u274C Cannot add translations without initialization.");
+            process.exit(1);
+          }
+        }
+        const config = loadConfig(process.cwd());
+        const translationsPath = path10.join(process.cwd(), config.translationsPath);
+        const existingNamespaces = getNamespaces(translationsPath, config.sourceLanguage);
+        let namespace;
+        if (existingNamespaces.length > 0) {
+          const namespaceChoice = await select({
+            message: "Select namespace:",
+            choices: [
+              ...existingNamespaces.map((ns) => ({ name: ns, value: ns })),
+              { name: "\u2795 Create new namespace", value: "__new__" }
+            ]
+          });
+          if (namespaceChoice === "__new__") {
+            namespace = await input2({
+              message: "Enter new namespace name:",
+              validate: (value2) => {
+                if (!value2.trim()) return "Namespace is required";
+                if (!/^[a-z0-9-]+$/.test(value2)) {
+                  return "Namespace must contain only lowercase letters, numbers, and hyphens";
+                }
+                return true;
+              }
+            });
+          } else {
+            namespace = namespaceChoice;
+          }
+        } else {
+          namespace = await input2({
+            message: "Enter namespace name (e.g., common, members):",
+            default: "common",
+            validate: (value2) => {
+              if (!value2.trim()) return "Namespace is required";
+              if (!/^[a-z0-9-]+$/.test(value2)) {
+                return "Namespace must contain only lowercase letters, numbers, and hyphens";
+              }
+              return true;
+            }
+          });
+        }
+        const key = await input2({
+          message: "Enter translation key (UPPERCASE_SNAKE_CASE):",
+          validate: (value2) => {
+            if (!value2.trim()) return "Key is required";
+            if (!/^[A-Z0-9_]+$/.test(value2)) {
+              return "Key should use UPPERCASE_SNAKE_CASE (e.g., SAVE_CHANGES)";
+            }
+            return true;
+          },
+          transformer: (value2) => value2.toUpperCase()
+        });
+        const value = await input2({
+          message: `Enter ${config.sourceLanguage.toUpperCase()} translation:`,
+          validate: (value2) => {
+            if (!value2.trim()) return "Translation value is required";
+            return true;
+          }
+        });
+        const autoTranslate = await confirm2({
+          message: `Auto-translate to ${config.languages.length - 1} other languages?`,
+          default: true
+        });
+        let apiKey;
+        if (autoTranslate) {
+          apiKey = values["api-key"] || process.env.GOOGLE_TRANSLATE_API_KEY;
+          if (!apiKey) {
+            console.log("\n\u26A0\uFE0F  GOOGLE_TRANSLATE_API_KEY environment variable not found.");
+            console.log("Skipping auto-translation. Set this variable to enable auto-translation.\n");
+          }
+        }
+        console.log();
+        await addTranslationKey(process.cwd(), {
+          namespace,
+          key: key.toUpperCase(),
+          value,
+          autoTranslate: autoTranslate && !!apiKey,
+          apiKey
+        });
+        console.log('\n\u{1F4A1} Run "translations" to validate and generate types');
+      } catch (error) {
+        if (error.message === "User force closed the prompt") {
+          console.log("\n\u274C Cancelled");
+          process.exit(0);
+        }
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    })();
+  } else {
+    if (!values.namespace || !values.key || !values.value) {
+      console.error("Error: --namespace, --key, and --value are required for add command");
+      console.log("Use --help for usage information");
+      process.exit(1);
+    }
+    const apiKey = values["api-key"] || process.env.GOOGLE_TRANSLATE_API_KEY;
+    if (values["auto-fill"] && !apiKey) {
+      console.error(
+        "Error: --api-key or GOOGLE_TRANSLATE_API_KEY environment variable is required for auto-translation"
+      );
+      process.exit(1);
+    }
+    addTranslationKey(process.cwd(), {
+      namespace: values.namespace,
+      key: values.key,
+      value: values.value,
+      autoTranslate: values["auto-fill"],
+      apiKey
+    }).then(() => {
+      console.log('\n\u{1F4A1} Run "translations" to validate and generate types');
+    }).catch((error) => {
+      console.error("Error:", error instanceof Error ? error.message : error);
+      process.exit(1);
+    });
+  }
+} else if (command) {
+  console.error(`Unknown command: ${command}`);
+  console.log("Use --help for usage information");
+  process.exit(1);
+} 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 limit = Number.parseInt(values.limit || "1000", 10);
+    manageTranslations(process.cwd(), {
+      autoFill: values["auto-fill"],
+      apiKey,
+      limit,
+      language: values.language,
+      skipTypes: values["skip-types"],
+      dryRun: values["dry-run"]
+    }).catch((error) => {
+      console.error("Error:", error instanceof Error ? error.message : error);
+      process.exit(1);
+    });
+  } else {
+    (async () => {
+      try {
+        const configPath = path10.join(process.cwd(), ".translationsrc.json");
+        const isInitialized = fs5.existsSync(configPath);
+        console.log("\n\u{1F30D} Translation Management\n");
+        const action = await select({
+          message: "What would you like to do?",
+          choices: [
+            {
+              name: "\u2728 Add a new translation key",
+              value: "add",
+              description: "Add a translation key to all languages"
+            },
+            {
+              name: "\u{1F50D} Validate translations",
+              value: "validate",
+              description: "Check for missing or empty translations"
+            },
+            {
+              name: "\u{1F916} Auto-fill missing translations",
+              value: "autofill",
+              description: "Automatically translate missing keys with Google Translate"
+            },
+            {
+              name: "\u{1F4DD} Generate TypeScript types",
+              value: "types",
+              description: "Generate types from translation files"
+            },
+            {
+              name: "\u2699\uFE0F  Initialize/reconfigure",
+              value: "init",
+              description: "Set up or change translation configuration"
+            },
+            {
+              name: "\u{1F4CA} Full check (validate + types)",
+              value: "full",
+              description: "Validate translations and generate types"
+            }
+          ]
+        });
+        console.log();
+        if (action === "add") {
+          if (!isInitialized) {
+            console.log("\u26A0\uFE0F  Translation structure not initialized.");
+            const shouldInit = await confirm2({
+              message: "Would you like to initialize it now?",
+              default: true
+            });
+            if (shouldInit) {
+              await initTranslationsInteractive(process.cwd());
+              console.log();
+            } else {
+              console.log("\u274C Cannot add translations without initialization.");
+              process.exit(1);
+            }
+          }
+          const config = loadConfig(process.cwd());
+          const translationsPath = path10.join(process.cwd(), config.translationsPath);
+          const existingNamespaces = getNamespaces(translationsPath, config.sourceLanguage);
+          let namespace;
+          if (existingNamespaces.length > 0) {
+            const namespaceChoice = await select({
+              message: "Select namespace:",
+              choices: [
+                ...existingNamespaces.map((ns) => ({ name: ns, value: ns })),
+                { name: "\u2795 Create new namespace", value: "__new__" }
+              ]
+            });
+            if (namespaceChoice === "__new__") {
+              namespace = await input2({
+                message: "Enter new namespace name:",
+                validate: (value2) => {
+                  if (!value2.trim()) return "Namespace is required";
+                  if (!/^[a-z0-9-]+$/.test(value2)) {
+                    return "Namespace must contain only lowercase letters, numbers, and hyphens";
+                  }
+                  return true;
+                }
+              });
+            } else {
+              namespace = namespaceChoice;
+            }
+          } else {
+            namespace = await input2({
+              message: "Enter namespace name (e.g., common, members):",
+              default: "common",
+              validate: (value2) => {
+                if (!value2.trim()) return "Namespace is required";
+                if (!/^[a-z0-9-]+$/.test(value2)) {
+                  return "Namespace must contain only lowercase letters, numbers, and hyphens";
+                }
+                return true;
+              }
+            });
+          }
+          const key = await input2({
+            message: "Enter translation key (UPPERCASE_SNAKE_CASE):",
+            validate: (value2) => {
+              if (!value2.trim()) return "Key is required";
+              if (!/^[A-Z0-9_]+$/.test(value2)) {
+                return "Key should use UPPERCASE_SNAKE_CASE (e.g., SAVE_CHANGES)";
+              }
+              return true;
+            },
+            transformer: (value2) => value2.toUpperCase()
+          });
+          const value = await input2({
+            message: `Enter ${config.sourceLanguage.toUpperCase()} translation:`,
+            validate: (value2) => {
+              if (!value2.trim()) return "Translation value is required";
+              return true;
+            }
+          });
+          const autoTranslate = await confirm2({
+            message: `Auto-translate to ${config.languages.length - 1} other languages?`,
+            default: true
+          });
+          let apiKey;
+          if (autoTranslate) {
+            apiKey = process.env.GOOGLE_TRANSLATE_API_KEY;
+            if (!apiKey) {
+              console.log("\n\u26A0\uFE0F  GOOGLE_TRANSLATE_API_KEY environment variable not found.");
+              console.log("Skipping auto-translation. Set this variable to enable auto-translation.\n");
+            }
+          }
+          console.log();
+          await addTranslationKey(process.cwd(), {
+            namespace,
+            key: key.toUpperCase(),
+            value,
+            autoTranslate: autoTranslate && !!apiKey,
+            apiKey
+          });
+          console.log('\n\u{1F4A1} Run "translations" again to validate and generate types');
+        } else if (action === "init") {
+          await initTranslationsInteractive(process.cwd());
+        } else if (action === "validate") {
+          await manageTranslations(process.cwd(), {
+            skipTypes: true
+          });
+        } else if (action === "autofill") {
+          const apiKey = process.env.GOOGLE_TRANSLATE_API_KEY;
+          if (!apiKey) {
+            console.log("\u26A0\uFE0F  GOOGLE_TRANSLATE_API_KEY environment variable not found.");
+            console.log("Please set it to enable auto-translation.\n");
+            process.exit(1);
+          }
+          const shouldContinue = await confirm2({
+            message: "This will auto-translate all missing keys. Continue?",
+            default: true
+          });
+          if (shouldContinue) {
+            await manageTranslations(process.cwd(), {
+              autoFill: true,
+              apiKey
+            });
+          }
+        } else if (action === "types") {
+          console.log("\u{1F4DD} Generating TypeScript types...\n");
+          const { generateTranslationTypes: generateTranslationTypes2 } = await Promise.resolve().then(() => (init_generate_types(), generate_types_exports));
+          generateTranslationTypes2(process.cwd());
+          console.log("\n\u2705 Types generated!\n");
+        } else if (action === "full") {
+          await manageTranslations(process.cwd());
+        }
+      } catch (error) {
+        if (error.message === "User force closed the prompt") {
+          console.log("\n\u274C Cancelled");
+          process.exit(0);
+        }
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    })();
+  }
+}
+//# sourceMappingURL=translations.js.map