@intl-party/cli 1.0.0 → 1.1.1

package/dist/index.js

@@ -51,7 +51,7 @@ var import_core = require("@intl-party/core");
 
 // src/utils/config.ts
 var import_fs_extra = __toESM(require("fs-extra"));
-var import_path = __toESM(require("path"));
+var import_node_path = __toESM(require("path"));
 var DEFAULT_CONFIG = {
   locales: ["en", "es", "fr"],
   defaultLocale: "en",
@@ -95,8 +95,8 @@ async function loadConfig(configPath) {
           const content = await import_fs_extra.default.readFile(configFile, "utf-8");
           config = JSON.parse(content);
         } else {
-          delete require.cache[import_path.default.resolve(configFile)];
-          config = require(import_path.default.resolve(configFile));
+          delete require.cache[import_node_path.default.resolve(configFile)];
+          config = require(import_node_path.default.resolve(configFile));
           if (config.default) {
             config = config.default;
           }
@@ -138,20 +138,20 @@ async function autoDetectConfig() {
       try {
         const entries = await import_fs_extra.default.readdir(basePath);
         const locales = entries.filter(
-          (entry) => import_fs_extra.default.statSync(import_path.default.join(basePath, entry)).isDirectory()
+          (entry) => import_fs_extra.default.statSync(import_node_path.default.join(basePath, entry)).isDirectory()
         );
         if (locales.length > 0) {
           config.locales = locales;
           config.translationPaths = {};
-          const firstLocaleDir = import_path.default.join(basePath, locales[0]);
+          const firstLocaleDir = import_node_path.default.join(basePath, locales[0]);
           const namespaceFiles = await import_fs_extra.default.readdir(firstLocaleDir);
-          const namespaces = namespaceFiles.filter((file) => file.endsWith(".json")).map((file) => import_path.default.basename(file, ".json"));
+          const namespaces = namespaceFiles.filter((file) => file.endsWith(".json")).map((file) => import_node_path.default.basename(file, ".json"));
           if (namespaces.length > 0) {
             config.namespaces = namespaces;
             for (const locale of locales) {
               config.translationPaths[locale] = {};
               for (const namespace of namespaces) {
-                config.translationPaths[locale][namespace] = import_path.default.join(
+                config.translationPaths[locale][namespace] = import_node_path.default.join(
                   basePath,
                   locale,
                   `${namespace}.json`
@@ -168,7 +168,7 @@ async function autoDetectConfig() {
   return config;
 }
 function mergeConfig(defaultConfig, userConfig) {
-  return {
+  const merged = {
     ...defaultConfig,
     ...userConfig,
     validation: {
@@ -188,6 +188,15 @@ function mergeConfig(defaultConfig, userConfig) {
       ...userConfig.translationPaths
     }
   };
+  if (userConfig.messages && !userConfig.outputDir) {
+    merged.outputDir = userConfig.messages;
+  }
+  if (userConfig.sourceDir && !userConfig.sourcePatterns) {
+    merged.sourcePatterns = [
+      import_node_path.default.join(userConfig.sourceDir, "**/*.{ts,tsx,js,jsx}")
+    ];
+  }
+  return merged;
 }
 async function saveConfig(config, configPath = "intl-party.config.json") {
   await import_fs_extra.default.writeFile(configPath, JSON.stringify(config, null, 2));
@@ -195,7 +204,7 @@ async function saveConfig(config, configPath = "intl-party.config.json") {
 
 // src/utils/translations.ts
 var import_fs_extra2 = __toESM(require("fs-extra"));
-var import_path2 = __toESM(require("path"));
+var import_node_path2 = __toESM(require("path"));
 async function loadTranslations(translationPaths, locales, namespaces) {
   const translations = {};
   for (const locale of locales) {
@@ -226,7 +235,7 @@ async function saveTranslations(translations, translationPaths) {
     )) {
       const translationPath = translationPaths[locale]?.[namespace];
       if (translationPath) {
-        await import_fs_extra2.default.ensureDir(import_path2.default.dirname(translationPath));
+        await import_fs_extra2.default.ensureDir(import_node_path2.default.dirname(translationPath));
         await import_fs_extra2.default.writeJson(translationPath, namespaceTranslations, {
           spaces: 2
         });
@@ -398,12 +407,22 @@ var import_chalk2 = __toESM(require("chalk"));
 var import_ora2 = __toESM(require("ora"));
 var import_glob = require("glob");
 var import_fs_extra4 = __toESM(require("fs-extra"));
-var import_path3 = __toESM(require("path"));
+var import_node_path3 = __toESM(require("path"));
 async function extractCommand(options) {
-  const spinner = (0, import_ora2.default)("Extracting translation keys...").start();
+  const spinner = (0, import_ora2.default)("Loading configuration...").start();
+  let config;
   try {
-    const sourcePatterns = options.source || ["src/**/*.{ts,tsx,js,jsx}"];
-    const outputDir = options.output || "./translations";
+    config = await loadConfig(options.config);
+    spinner.succeed("Configuration loaded");
+  } catch (error) {
+    spinner.fail("Failed to load configuration");
+    console.error(import_chalk2.default.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+  spinner.start("Extracting translation keys...");
+  try {
+    const sourcePatterns = options.source || config.sourcePatterns || ["src/**/*.{ts,tsx,js,jsx}"];
+    const outputDir = options.output || config.outputDir || "./messages";
     const files = await (0, import_glob.glob)(sourcePatterns);
     spinner.succeed(`Found ${files.length} source files`);
     const extractedKeys = /* @__PURE__ */ new Set();
@@ -420,7 +439,7 @@ async function extractCommand(options) {
       });
       return;
     }
-    await writeExtractedKeys(Array.from(extractedKeys), outputDir, options);
+    await writeExtractedKeys(Array.from(extractedKeys), outputDir, config, options);
     console.log(import_chalk2.default.green(`\u2713 Translation keys extracted to ${outputDir}`));
   } catch (error) {
     spinner.fail("Extraction failed");
@@ -438,6 +457,8 @@ function extractKeysFromContent(content) {
     // t('key')
     /useTranslations\(\)\(['"`]([^'"`]+)['"`]\)/g,
     // useTranslations()('key')
+    /useTranslations\(['"`]([^'"`]+)['"`]\)\(['"`]([^'"`]+)['"`]\)/g,
+    // useTranslations('ns')('key')
     /i18nKey=['"`]([^'"`]+)['"`]/g,
     // i18nKey="key"
     /\{\s*t\(['"`]([^'"`]+)['"`]\)\s*\}/g
@@ -446,12 +467,16 @@ function extractKeysFromContent(content) {
   for (const pattern of patterns) {
     let match;
     while ((match = pattern.exec(content)) !== null) {
-      keys.push(match[1]);
+      if (match[2]) {
+        keys.push(`${match[1]}.${match[2]}`);
+      } else {
+        keys.push(match[1]);
+      }
     }
   }
   return keys;
 }
-async function writeExtractedKeys(keys, outputDir, options) {
+async function writeExtractedKeys(keys, outputDir, config, options) {
   await import_fs_extra4.default.ensureDir(outputDir);
   const namespaces = { common: [] };
   for (const key of keys) {
@@ -467,46 +492,271 @@ async function writeExtractedKeys(keys, outputDir, options) {
       namespaces.common.push(key);
     }
   }
-  for (const [namespace, namespaceKeys] of Object.entries(namespaces)) {
-    if (namespaceKeys.length === 0) continue;
-    const filePath = import_path3.default.join(outputDir, "en", `${namespace}.json`);
-    await import_fs_extra4.default.ensureDir(import_path3.default.dirname(filePath));
-    let translations = {};
-    if (options.update && await import_fs_extra4.default.pathExists(filePath)) {
-      try {
-        translations = await import_fs_extra4.default.readJson(filePath);
-      } catch {
+  const locales = config.locales || ["en"];
+  for (const locale of locales) {
+    for (const [namespace, namespaceKeys] of Object.entries(namespaces)) {
+      if (namespaceKeys.length === 0) continue;
+      const filePath = import_node_path3.default.join(outputDir, locale, `${namespace}.json`);
+      await import_fs_extra4.default.ensureDir(import_node_path3.default.dirname(filePath));
+      let translations = {};
+      if ((options.update || locale !== config.defaultLocale) && await import_fs_extra4.default.pathExists(filePath)) {
+        try {
+          translations = await import_fs_extra4.default.readJson(filePath);
+        } catch {
+        }
       }
-    }
-    for (const key of namespaceKeys) {
-      if (!translations[key]) {
-        translations[key] = key;
+      for (const key of namespaceKeys) {
+        if (!translations[key]) {
+          translations[key] = locale === config.defaultLocale ? key : "";
+        }
       }
+      if (config.extraction?.sortKeys !== false) {
+        const sortedTranslations = {};
+        Object.keys(translations).sort().forEach((k) => {
+          sortedTranslations[k] = translations[k];
+        });
+        translations = sortedTranslations;
+      }
+      await import_fs_extra4.default.writeJson(filePath, translations, { spaces: 2 });
     }
-    await import_fs_extra4.default.writeJson(filePath, translations, { spaces: 2 });
   }
 }
 
 // src/commands/sync.ts
 var import_chalk3 = __toESM(require("chalk"));
+var import_ora3 = __toESM(require("ora"));
+var import_inquirer = __toESM(require("inquirer"));
 async function syncCommand(options) {
-  console.log(import_chalk3.default.blue("Sync command not yet implemented"));
-  console.log("Options:", options);
+  const spinner = (0, import_ora3.default)("Loading configuration...").start();
+  try {
+    const config = await loadConfig(options.config);
+    spinner.text = "Loading translations...";
+    const translations = await loadTranslations(
+      config.translationPaths,
+      config.locales,
+      config.namespaces
+    );
+    spinner.succeed("Configuration loaded");
+    const baseLocale = options.base || config.defaultLocale;
+    const targetLocales = options.target || config.locales.filter((l) => l !== baseLocale);
+    if (!config.locales.includes(baseLocale)) {
+      throw new Error(`Base locale '${baseLocale}' not found in configuration`);
+    }
+    const analysis = analyzeTranslations(
+      translations,
+      baseLocale,
+      targetLocales,
+      config.namespaces
+    );
+    if (options.verbose) {
+      displayAnalysis(analysis);
+    }
+    if (options.interactive && (analysis.missingKeys.length > 0 || analysis.unusedKeys.length > 0)) {
+      const shouldProceed = await confirmSync(analysis);
+      if (!shouldProceed) {
+        console.log(import_chalk3.default.yellow("Sync cancelled by user"));
+        return;
+      }
+    }
+    const updatedTranslations = await performSync(
+      translations,
+      analysis,
+      baseLocale,
+      targetLocales,
+      config.namespaces,
+      options
+    );
+    spinner.start("Saving translations...");
+    await saveTranslations(updatedTranslations, config.translationPaths);
+    spinner.succeed("Translations synchronized successfully");
+    displaySummary(analysis, updatedTranslations);
+  } catch (error) {
+    spinner.fail("Sync failed");
+    console.error(
+      import_chalk3.default.red("Error:"),
+      error instanceof Error ? error.message : error
+    );
+    process.exit(1);
+  }
+}
+function analyzeTranslations(translations, baseLocale, targetLocales, namespaces) {
+  const missingKeys = [];
+  const unusedKeys = [];
+  const baseKeys = /* @__PURE__ */ new Set();
+  for (const namespace of namespaces) {
+    const baseTranslations = translations[baseLocale]?.[namespace] || {};
+    collectKeys(baseTranslations, "", baseKeys);
+  }
+  for (const locale of targetLocales) {
+    for (const namespace of namespaces) {
+      const targetTranslations = translations[locale]?.[namespace] || {};
+      const targetKeys = /* @__PURE__ */ new Set();
+      collectKeys(targetTranslations, "", targetKeys);
+      for (const key of baseKeys) {
+        if (!targetKeys.has(key)) {
+          missingKeys.push({ locale, namespace, key });
+        }
+      }
+    }
+  }
+  for (const locale of targetLocales) {
+    for (const namespace of namespaces) {
+      const targetTranslations = translations[locale]?.[namespace] || {};
+      const targetKeys = /* @__PURE__ */ new Set();
+      collectKeys(targetTranslations, "", targetKeys);
+      for (const key of targetKeys) {
+        if (!baseKeys.has(key)) {
+          unusedKeys.push({ locale, namespace, key });
+        }
+      }
+    }
+  }
+  return {
+    missingKeys,
+    unusedKeys,
+    totalKeys: baseKeys.size,
+    missingCount: missingKeys.length,
+    unusedCount: unusedKeys.length
+  };
+}
+function collectKeys(obj, prefix, keys) {
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      collectKeys(value, fullKey, keys);
+    } else {
+      keys.add(fullKey);
+    }
+  }
+}
+function displayAnalysis(analysis) {
+  console.log(import_chalk3.default.bold("\n\u{1F4CA} Translation Analysis:"));
+  console.log(`Total keys in base locale: ${import_chalk3.default.blue(analysis.totalKeys)}`);
+  console.log(`Missing keys: ${import_chalk3.default.yellow(analysis.missingCount)}`);
+  console.log(`Unused keys: ${import_chalk3.default.red(analysis.unusedCount)}`);
+  if (analysis.missingKeys.length > 0) {
+    console.log(import_chalk3.default.yellow("\n\u26A0\uFE0F  Missing Keys:"));
+    const grouped = groupKeysByLocale(analysis.missingKeys);
+    for (const [locale, keys] of Object.entries(grouped)) {
+      console.log(import_chalk3.default.gray(`  ${locale}: ${keys.length} keys`));
+      if (keys.length <= 10) {
+        keys.forEach(
+          (key) => console.log(import_chalk3.default.gray(`    - ${key.namespace}.${key.key}`))
+        );
+      }
+    }
+  }
+  if (analysis.unusedKeys.length > 0) {
+    console.log(import_chalk3.default.red("\n\u{1F5D1}\uFE0F  Unused Keys:"));
+    const grouped = groupKeysByLocale(analysis.unusedKeys);
+    for (const [locale, keys] of Object.entries(grouped)) {
+      console.log(import_chalk3.default.gray(`  ${locale}: ${keys.length} keys`));
+      if (keys.length <= 10) {
+        keys.forEach(
+          (key) => console.log(import_chalk3.default.gray(`    - ${key.namespace}.${key.key}`))
+        );
+      }
+    }
+  }
+}
+function groupKeysByLocale(keys) {
+  return keys.reduce(
+    (acc, key) => {
+      if (!acc[key.locale]) acc[key.locale] = [];
+      acc[key.locale].push(key);
+      return acc;
+    },
+    {}
+  );
+}
+async function confirmSync(analysis) {
+  const questions = [];
+  if (analysis.missingCount > 0) {
+    questions.push({
+      type: "confirm",
+      name: "addMissing",
+      message: `Add ${analysis.missingCount} missing translation keys?`,
+      default: true
+    });
+  }
+  if (analysis.unusedCount > 0) {
+    questions.push({
+      type: "confirm",
+      name: "removeUnused",
+      message: `Remove ${analysis.unusedCount} unused translation keys?`,
+      default: false
+    });
+  }
+  const answers = await import_inquirer.default.prompt(questions);
+  return answers.addMissing || answers.removeUnused;
+}
+async function performSync(translations, analysis, baseLocale, targetLocales, namespaces, options) {
+  const updatedTranslations = JSON.parse(JSON.stringify(translations));
+  if (analysis.missingKeys.length > 0 && (options.missingOnly || !options.missingOnly)) {
+    for (const missing of analysis.missingKeys) {
+      const baseValue = getNestedValue(
+        updatedTranslations[baseLocale]?.[missing.namespace] || {},
+        missing.key
+      );
+      setNestedValue(
+        updatedTranslations[missing.locale][missing.namespace],
+        missing.key,
+        baseValue
+      );
+    }
+  }
+  if (analysis.unusedKeys.length > 0 && !options.missingOnly) {
+    for (const unused of analysis.unusedKeys) {
+      removeNestedValue(
+        updatedTranslations[unused.locale][unused.namespace],
+        unused.key
+      );
+    }
+  }
+  return updatedTranslations;
+}
+function getNestedValue(obj, path6) {
+  return path6.split(".").reduce((current, key) => current?.[key], obj);
+}
+function setNestedValue(obj, path6, value) {
+  const keys = path6.split(".");
+  const lastKey = keys.pop();
+  const target = keys.reduce((current, key) => {
+    if (!current[key]) current[key] = {};
+    return current[key];
+  }, obj);
+  target[lastKey] = value;
+}
+function removeNestedValue(obj, path6) {
+  const keys = path6.split(".");
+  const lastKey = keys.pop();
+  const target = keys.reduce((current, key) => current?.[key], obj);
+  if (target) {
+    delete target[lastKey];
+  }
+}
+function displaySummary(analysis, translations) {
+  console.log(import_chalk3.default.bold.green("\n\u2705 Sync Complete!"));
+  console.log(`Added ${import_chalk3.default.green(analysis.missingCount)} missing keys`);
+  console.log(`Removed ${import_chalk3.default.red(analysis.unusedCount)} unused keys`);
+  console.log(
+    `Total translations: ${Object.keys(translations).length} locales`
+  );
 }
 
 // src/commands/init.ts
 var import_chalk4 = __toESM(require("chalk"));
-var import_ora3 = __toESM(require("ora"));
+var import_ora4 = __toESM(require("ora"));
 var import_fs_extra5 = __toESM(require("fs-extra"));
-var import_path4 = __toESM(require("path"));
-var import_inquirer = __toESM(require("inquirer"));
+var import_node_path4 = __toESM(require("path"));
+var import_inquirer2 = __toESM(require("inquirer"));
 async function initCommand(options) {
-  const spinner = (0, import_ora3.default)("Initializing IntlParty configuration...").start();
+  const spinner = (0, import_ora4.default)("Initializing IntlParty configuration...").start();
   try {
     const configPath = "intl-party.config.json";
     if (await import_fs_extra5.default.pathExists(configPath) && !options.force) {
       spinner.stop();
-      const { overwrite } = await import_inquirer.default.prompt([
+      const { overwrite } = await import_inquirer2.default.prompt([
         {
           type: "confirm",
           name: "overwrite",
@@ -521,7 +771,7 @@ async function initCommand(options) {
     }
     spinner.start("Setting up configuration...");
     spinner.stop();
-    const answers = await import_inquirer.default.prompt([
+    const answers = await import_inquirer2.default.prompt([
       {
         type: "input",
         name: "defaultLocale",
@@ -583,7 +833,7 @@ async function initCommand(options) {
     for (const locale of answers.locales) {
       config.translationPaths[locale] = {};
       for (const namespace of answers.namespaces) {
-        config.translationPaths[locale][namespace] = import_path4.default.join(
+        config.translationPaths[locale][namespace] = import_node_path4.default.join(
           answers.translationsDir,
           locale,
           `${namespace}.json`
@@ -593,10 +843,10 @@ async function initCommand(options) {
     spinner.start("Creating directory structure...");
     await import_fs_extra5.default.ensureDir(answers.translationsDir);
     for (const locale of answers.locales) {
-      const localeDir = import_path4.default.join(answers.translationsDir, locale);
+      const localeDir = import_node_path4.default.join(answers.translationsDir, locale);
       await import_fs_extra5.default.ensureDir(localeDir);
       for (const namespace of answers.namespaces) {
-        const filePath = import_path4.default.join(localeDir, `${namespace}.json`);
+        const filePath = import_node_path4.default.join(localeDir, `${namespace}.json`);
         if (!await import_fs_extra5.default.pathExists(filePath)) {
           await import_fs_extra5.default.writeJson(filePath, {}, { spaces: 2 });
         }
@@ -740,10 +990,10 @@ console.log(i18n.t('welcome'));
 
 // src/commands/check.ts
 var import_chalk5 = __toESM(require("chalk"));
-var import_ora4 = __toESM(require("ora"));
+var import_ora5 = __toESM(require("ora"));
 var import_core2 = require("@intl-party/core");
 async function checkCommand(options) {
-  const spinner = (0, import_ora4.default)("Loading configuration...").start();
+  const spinner = (0, import_ora5.default)("Loading configuration...").start();
   try {
     const config = await loadConfig(options.config);
     spinner.succeed("Configuration loaded");
@@ -865,10 +1115,623 @@ async function checkCommand(options) {
 }
 
 // src/commands/generate.ts
+var import_fs_extra6 = __toESM(require("fs-extra"));
+var import_node_path5 = __toESM(require("path"));
+var import_crypto = __toESM(require("crypto"));
 var import_chalk6 = __toESM(require("chalk"));
+var import_ora6 = __toESM(require("ora"));
+var import_chokidar = require("chokidar");
+async function getMessageData(configPath, options) {
+  let config;
+  let locales;
+  let namespaces;
+  let translationPaths;
+  if (configPath && await import_fs_extra6.default.pathExists(configPath)) {
+    config = await loadConfig(configPath);
+    locales = config.locales;
+    namespaces = config.namespaces;
+    translationPaths = config.translationPaths;
+  } else {
+    if (options?.verbose) {
+      console.log(
+        import_chalk6.default.gray("No config file found, auto-detecting from filesystem...")
+      );
+    }
+    const autoDetected = await autoDetectMessages(options);
+    locales = autoDetected.locales;
+    namespaces = autoDetected.namespaces;
+    translationPaths = autoDetected.translationPaths;
+  }
+  if (config) {
+    const nextjsConfig = config.shared;
+    if (nextjsConfig && nextjsConfig.messagesPath && nextjsConfig.locales && nextjsConfig.namespaces) {
+      translationPaths = {};
+      for (const locale of nextjsConfig.locales) {
+        translationPaths[locale] = {};
+        for (const namespace of nextjsConfig.namespaces) {
+          translationPaths[locale][namespace] = import_node_path5.default.join(
+            process.cwd(),
+            nextjsConfig.messagesPath,
+            locale,
+            `${namespace}.json`
+          );
+        }
+      }
+      locales = nextjsConfig.locales;
+      namespaces = nextjsConfig.namespaces;
+      if (options?.verbose) {
+        console.log(
+          import_chalk6.default.gray(
+            `Using Next.js config: ${locales.length} locales, ${namespaces.length} namespaces`
+          )
+        );
+        console.log(import_chalk6.default.gray(`Messages path: ${nextjsConfig.messagesPath}`));
+      }
+    } else if (config.messagesPath && config.locales && config.namespaces) {
+      const standardConfig = config;
+      translationPaths = {};
+      for (const locale of standardConfig.locales) {
+        translationPaths[locale] = {};
+        for (const namespace of standardConfig.namespaces) {
+          translationPaths[locale][namespace] = import_node_path5.default.join(
+            process.cwd(),
+            standardConfig.messagesPath,
+            locale,
+            `${namespace}.json`
+          );
+        }
+      }
+      locales = standardConfig.locales;
+      namespaces = standardConfig.namespaces;
+      if (options?.verbose) {
+        console.log(
+          import_chalk6.default.gray(
+            `Using standard config: ${locales.length} locales, ${namespaces.length} namespaces`
+          )
+        );
+        console.log(
+          import_chalk6.default.gray(`Messages path: ${standardConfig.messagesPath}`)
+        );
+      }
+    }
+  }
+  const messages = await loadTranslations(
+    translationPaths,
+    locales,
+    namespaces
+  );
+  const translationKeys = /* @__PURE__ */ new Set();
+  const namespaceKeys = /* @__PURE__ */ new Set();
+  for (const locale of locales) {
+    for (const namespace of namespaces) {
+      const extractKeys = (obj, prefix = "") => {
+        for (const [key, value] of Object.entries(obj)) {
+          const fullKey = prefix ? `${prefix}.${key}` : key;
+          const namespaceKey = prefix ? key : fullKey;
+          translationKeys.add(fullKey);
+          if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+            extractKeys(value, fullKey);
+          } else {
+            const dotNotationKey = fullKey.replace(`${namespace}.`, "");
+            namespaceKeys.add(dotNotationKey);
+          }
+        }
+      };
+      if (messages[locale]?.[namespace]) {
+        extractKeys(messages[locale][namespace], namespace);
+      }
+    }
+  }
+  return {
+    locales,
+    namespaces,
+    messages,
+    translationKeys: Array.from(translationKeys).sort(),
+    namespaceKeys: Array.from(namespaceKeys).sort()
+  };
+}
+function generateTypescriptTypes(data) {
+  const { locales, namespaces, translationKeys, namespaceKeys } = data;
+  const keyUnion = translationKeys.map((key) => `"${key}"`).join(" | ");
+  const namespaceKeyUnion = namespaceKeys.map((key) => `"${key}"`).join(" | ");
+  const namespaceTypes = namespaces.map((ns) => {
+    const messageStructure = data.messages[locales[0]]?.[ns];
+    if (!messageStructure) return `  "${ns}": {};`;
+    const generateNestedInterface = (obj, indent = 2) => {
+      const spaces = "  ".repeat(indent);
+      const entries = Object.entries(obj);
+      if (entries.length === 0) return "{}";
+      const interfaceLines = entries.map(([key, value]) => {
+        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+          return `${spaces}"${key}": ${generateNestedInterface(value, indent + 1)};`;
+        } else {
+          return `${spaces}"${key}": string;`;
+        }
+      });
+      return `{
+${interfaceLines.join("\n")}
+${"  ".repeat(indent - 1)}}`;
+    };
+    return `  "${ns}": ${generateNestedInterface(messageStructure)};`;
+  }).join("\n");
+  const localeTypes = locales.map((locale) => {
+    return `  "${locale}": {
+${namespaceTypes}
+  };`;
+  }).join("\n");
+  return `// Generated by @intl-party/cli - do not edit
+// This file contains type-safe definitions for your translations
+
+export type TranslationKey = ${keyUnion};
+
+export type NamespaceTranslationKey = ${namespaceKeyUnion};
+
+export type TranslationNamespace = ${namespaces.map((ns) => `"${ns}"`).join(" | ")};
+
+export type Locale = ${locales.map((locale) => `"${locale}"`).join(" | ")};
+
+export interface Translations {
+${localeTypes}
+}
+
+export interface NamespaceTranslations {
+${namespaceTypes}
+}
+
+// Helper type for getting translation value type
+export type TranslationValue<T extends TranslationKey> = string;
+
+// Helper type for getting namespace translations
+export type GetNamespaceTranslations<N extends TranslationNamespace> = 
+  Translations[Locale][N];
+
+// Type-safe translation function signature
+export interface TranslationFunction {
+  <T extends TranslationKey>(key: T, options?: Record<string, any>): TranslationValue<T>;
+  <T extends TranslationNamespace>(namespace: T): GetNamespaceTranslations<T>;
+}
+
+// Default messages object (for runtime usage)
+export const defaultMessages: Translations = ${JSON.stringify(data.messages, null, 2)} as const;
+`;
+}
+function generateClientMessages(data) {
+  return `// Generated by @intl-party/cli - do not edit
+// This file contains runtime message data for the client package
+
+import type { Translations } from './translations.generated';
+
+export const messages: Translations = ${JSON.stringify(data.messages, null, 2)} as const;
+
+// Re-export for convenience
+export { messages as defaultMessages } from './translations.generated';
+`;
+}
+function generateJavaScriptMessages(data) {
+  return `// Generated by @intl-party/cli - do not edit
+// This file contains runtime message data for easy imports
+
+export const defaultMessages = ${JSON.stringify(data.messages, null, 2)};
+
+// Export individual locale messages for convenience
+${data.locales.map((locale) => `export const ${locale}Messages = defaultMessages.${locale};`).join("\n")}
+`;
+}
+function generateClientIndex() {
+  return `// Generated by @intl-party/cli - do not edit
+// This file is the main entry point for the client package
+
+export * from './translations.generated';
+export * from './messages.generated';
+`;
+}
+function generateJsonSchemas(data) {
+  const schemas = {};
+  for (const locale of data.locales) {
+    for (const namespace of data.namespaces) {
+      const messages = data.messages[locale]?.[namespace] || {};
+      const schema = createJsonSchema(messages);
+      const schemaName = `${locale}_${namespace}`;
+      schemas[schemaName] = {
+        $schema: "http://json-schema.org/draft-07/schema#",
+        $id: `#/schemas/${schemaName}`,
+        title: `Translation schema for ${locale}/${namespace}`,
+        description: `JSON schema for translation keys in ${namespace} namespace for ${locale} locale`,
+        type: "object",
+        properties: schema.properties,
+        required: schema.required,
+        additionalProperties: false
+      };
+    }
+  }
+  const combinedSchema = {
+    $schema: "http://json-schema.org/draft-07/schema#",
+    $id: "#/schemas/translations",
+    title: "IntlParty Translation Schema",
+    description: "JSON schema for all IntlParty translations",
+    type: "object",
+    properties: {},
+    definitions: {}
+  };
+  for (const locale of data.locales) {
+    combinedSchema.properties[locale] = {
+      type: "object",
+      description: `Translations for ${locale} locale`,
+      properties: {}
+    };
+    for (const namespace of data.namespaces) {
+      const schemaName = `${locale}_${namespace}`;
+      combinedSchema.properties[locale].properties[namespace] = {
+        $ref: `#/definitions/${schemaName}`
+      };
+      combinedSchema.definitions[schemaName] = schemas[schemaName];
+    }
+  }
+  return JSON.stringify(
+    {
+      schemas,
+      combined: combinedSchema,
+      metadata: {
+        generated: (/* @__PURE__ */ new Date()).toISOString(),
+        locales: data.locales,
+        namespaces: data.namespaces,
+        version: "1.0.0"
+      }
+    },
+    null,
+    2
+  );
+}
+function createJsonSchema(obj, prefix = "") {
+  const properties = {};
+  const required = [];
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      const nestedSchema = createJsonSchema(value, fullKey);
+      properties[key] = {
+        type: "object",
+        properties: nestedSchema.properties,
+        required: nestedSchema.required,
+        description: `Translation key: ${fullKey}`
+      };
+    } else {
+      properties[key] = {
+        type: "string",
+        description: `Translation key: ${fullKey}`,
+        examples: [value]
+      };
+      required.push(key);
+    }
+  }
+  return { properties, required };
+}
+function generateDocumentation(data) {
+  const lines = [];
+  lines.push("# Translation Documentation");
+  lines.push("");
+  lines.push(`Generated on: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push(`Locales: ${data.locales.join(", ")}`);
+  lines.push(`Namespaces: ${data.namespaces.join(", ")}`);
+  lines.push("");
+  lines.push("## Table of Contents");
+  for (const locale of data.locales) {
+    lines.push(`- [${locale.toUpperCase()}](#${locale.toLowerCase()})`);
+  }
+  lines.push("");
+  for (const locale of data.locales) {
+    lines.push(`## ${locale.toUpperCase()}`);
+    lines.push("");
+    for (const namespace of data.namespaces) {
+      const messages = data.messages[locale]?.[namespace] || {};
+      if (Object.keys(messages).length === 0) {
+        continue;
+      }
+      lines.push(`### ${namespace} namespace`);
+      lines.push("");
+      generateNamespaceDocumentation(messages, lines, "");
+    }
+    lines.push("");
+  }
+  lines.push("## Summary");
+  lines.push("");
+  const totalKeys = Object.values(data.messages).flatMap((locale) => Object.values(locale)).reduce((total, namespace) => {
+    return total + countKeys(namespace);
+  }, 0);
+  lines.push(`- **Total locales**: ${data.locales.length}`);
+  lines.push(`- **Total namespaces**: ${data.namespaces.length}`);
+  lines.push(`- **Total translation keys**: ${totalKeys}`);
+  lines.push("");
+  lines.push("### Keys by Locale");
+  lines.push("");
+  for (const locale of data.locales) {
+    const localeKeys = Object.values(data.messages[locale] || {}).reduce(
+      (total, namespace) => total + countKeys(namespace),
+      0
+    );
+    lines.push(`- **${locale}**: ${localeKeys} keys`);
+  }
+  return lines.join("\n");
+}
+function generateNamespaceDocumentation(obj, lines, prefix) {
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      lines.push(`#### ${fullKey}`);
+      lines.push("");
+      lines.push("Nested translation object containing:");
+      lines.push("");
+      const nestedKeys = Object.keys(value);
+      for (const nestedKey of nestedKeys) {
+        lines.push(`- \`${fullKey}.${nestedKey}\``);
+      }
+      lines.push("");
+      generateNamespaceDocumentation(value, lines, fullKey);
+    } else {
+      lines.push(`#### ${fullKey}`);
+      lines.push("");
+      lines.push(`**Translation**: \`"${value}"\``);
+      lines.push("");
+      const interpolationMatches = String(value).match(/\{\{([^}]+)\}\}/g);
+      if (interpolationMatches) {
+        lines.push("**Interpolation variables**:");
+        lines.push("");
+        const variables = interpolationMatches.map(
+          (match) => match.replace(/[{}]/g, "")
+        );
+        const uniqueVariables = [...new Set(variables)];
+        for (const variable of uniqueVariables) {
+          lines.push(`- \`${variable}\``);
+        }
+        lines.push("");
+      }
+    }
+  }
+}
+function countKeys(obj) {
+  let count = 0;
+  for (const value of Object.values(obj)) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      count += countKeys(value);
+    } else {
+      count += 1;
+    }
+  }
+  return count;
+}
+async function autoDetectMessages(options) {
+  const cwd = process.cwd();
+  const possibleMessageDirs = [
+    import_node_path5.default.join(cwd, "messages"),
+    import_node_path5.default.join(cwd, "locales"),
+    import_node_path5.default.join(cwd, "translations"),
+    import_node_path5.default.join(cwd, "i18n")
+  ];
+  let messagesDir = null;
+  for (const dir of possibleMessageDirs) {
+    if (await import_fs_extra6.default.pathExists(dir)) {
+      messagesDir = dir;
+      break;
+    }
+  }
+  if (!messagesDir) {
+    throw new Error(
+      "No messages directory found. Expected one of: messages/, locales/, translations/, i18n/"
+    );
+  }
+  if (options?.verbose) {
+    console.log(import_chalk6.default.gray(`Found messages directory: ${messagesDir}`));
+  }
+  const localeDirs = await import_fs_extra6.default.readdir(messagesDir);
+  const detectedLocales = localeDirs.filter(async (dir) => {
+    const localePath = import_node_path5.default.join(messagesDir, dir);
+    const stat = await import_fs_extra6.default.stat(localePath);
+    return stat.isDirectory();
+  });
+  const validLocales = [];
+  for (const dir of localeDirs) {
+    const localePath = import_node_path5.default.join(messagesDir, dir);
+    const stat = await import_fs_extra6.default.stat(localePath);
+    if (stat.isDirectory()) {
+      validLocales.push(dir);
+    }
+  }
+  if (validLocales.length === 0) {
+    throw new Error(`No locale directories found in ${messagesDir}`);
+  }
+  const firstLocale = validLocales[0];
+  const firstLocalePath = import_node_path5.default.join(messagesDir, firstLocale);
+  const namespaceFiles = await import_fs_extra6.default.readdir(firstLocalePath);
+  const detectedNamespaces = namespaceFiles.filter((file) => file.endsWith(".json")).map((file) => import_node_path5.default.basename(file, ".json"));
+  if (detectedNamespaces.length === 0) {
+    throw new Error(`No JSON files found in ${firstLocalePath}`);
+  }
+  const translationPaths = {};
+  for (const locale of validLocales) {
+    translationPaths[locale] = {};
+    for (const namespace of detectedNamespaces) {
+      translationPaths[locale][namespace] = import_node_path5.default.join(
+        messagesDir,
+        locale,
+        `${namespace}.json`
+      );
+    }
+  }
+  if (options?.verbose) {
+    console.log(
+      import_chalk6.default.gray(
+        `Auto-detected ${validLocales.length} locales: ${validLocales.join(", ")}`
+      )
+    );
+    console.log(
+      import_chalk6.default.gray(
+        `Auto-detected ${detectedNamespaces.length} namespaces: ${detectedNamespaces.join(", ")}`
+      )
+    );
+  }
+  return {
+    locales: validLocales,
+    namespaces: detectedNamespaces,
+    translationPaths
+  };
+}
+function generateCacheHash(data) {
+  const content = JSON.stringify({
+    locales: data.locales.sort(),
+    namespaces: data.namespaces.sort(),
+    messages: data.messages
+  });
+  return import_crypto.default.createHash("md5").update(content).digest("hex");
+}
+async function writeGeneratedFiles(data, outputDir, options) {
+  await import_fs_extra6.default.ensureDir(outputDir);
+  const cacheHash = generateCacheHash(data);
+  const cacheFilePath = import_node_path5.default.join(outputDir, ".intl-party-cache");
+  let shouldRegenerate = true;
+  if (await import_fs_extra6.default.pathExists(cacheFilePath)) {
+    const existingHash = await import_fs_extra6.default.readFile(cacheFilePath, "utf-8");
+    if (existingHash === cacheHash) {
+      shouldRegenerate = false;
+    }
+  }
+  if (!shouldRegenerate && !options.watch && !options.client) {
+    if (options.verbose) {
+      console.log(import_chalk6.default.gray("No changes detected, skipping generation"));
+    }
+    return;
+  }
+  if (options.types !== false) {
+    const typesContent = generateTypescriptTypes(data);
+    const typesFilePath = import_node_path5.default.join(outputDir, "translations.generated.ts");
+    await import_fs_extra6.default.writeFile(typesFilePath, typesContent);
+    const jsContent = generateJavaScriptMessages(data);
+    const jsFilePath = import_node_path5.default.join(outputDir, "messages.generated.js");
+    await import_fs_extra6.default.writeFile(jsFilePath, jsContent);
+    if (options.verbose) {
+      console.log(import_chalk6.default.green(`\u2713 Generated types: ${typesFilePath}`));
+    }
+  }
+  if (options.schemas) {
+    const schemasContent = generateJsonSchemas(data);
+    const schemasFilePath = import_node_path5.default.join(outputDir, "schemas.json");
+    await import_fs_extra6.default.writeFile(schemasFilePath, schemasContent);
+    if (options.verbose) {
+      console.log(import_chalk6.default.green(`\u2713 Generated schemas: ${schemasFilePath}`));
+    }
+  }
+  if (options.docs) {
+    const docsContent = generateDocumentation(data);
+    const docsFilePath = import_node_path5.default.join(outputDir, "translations.md");
+    await import_fs_extra6.default.writeFile(docsFilePath, docsContent);
+    if (options.verbose) {
+      console.log(import_chalk6.default.green(`\u2713 Generated documentation: ${docsFilePath}`));
+    }
+  }
+  await import_fs_extra6.default.writeFile(cacheFilePath, cacheHash);
+}
+async function generateClientPackage(data, options) {
+  console.log(import_chalk6.default.blue("\u{1F527} Generating client package files..."));
+  if (options.verbose) {
+    console.log(import_chalk6.default.gray(`Data: ${JSON.stringify(data, null, 2)}`));
+  }
+  let rootDir = process.cwd();
+  while (rootDir !== import_node_path5.default.dirname(rootDir)) {
+    const packageJsonPath = import_node_path5.default.join(rootDir, "package.json");
+    if (await import_fs_extra6.default.pathExists(packageJsonPath)) {
+      const packageJson = await import_fs_extra6.default.readJson(packageJsonPath);
+      if (packageJson.name === "@intl-party/monorepo") {
+        break;
+      }
+    }
+    rootDir = import_node_path5.default.dirname(rootDir);
+  }
+  const clientDir = import_node_path5.default.join(rootDir, "packages/client/generated");
+  await import_fs_extra6.default.ensureDir(clientDir);
+  const typesContent = generateTypescriptTypes(data);
+  const typesFilePath = import_node_path5.default.join(clientDir, "translations.generated.ts");
+  if (options.verbose) {
+    console.log(import_chalk6.default.gray(`Writing types to: ${typesFilePath}`));
+  }
+  await import_fs_extra6.default.writeFile(typesFilePath, typesContent);
+  const messagesContent = generateClientMessages(data);
+  const messagesFilePath = import_node_path5.default.join(clientDir, "messages.generated.ts");
+  if (options.verbose) {
+    console.log(import_chalk6.default.gray(`Writing messages to: ${messagesFilePath}`));
+  }
+  await import_fs_extra6.default.writeFile(messagesFilePath, messagesContent);
+  const indexContent = generateClientIndex();
+  const indexPath = import_node_path5.default.join(clientDir, "index.generated.ts");
+  if (options.verbose) {
+    console.log(import_chalk6.default.gray(`Writing index to: ${indexPath}`));
+  }
+  await import_fs_extra6.default.writeFile(indexPath, indexContent);
+  if (options.verbose) {
+    console.log(
+      import_chalk6.default.green(`\u2713 Generated client package files in ${clientDir}`)
+    );
+  }
+}
+async function setupWatcher(configPath, outputDir, options) {
+  const config = await loadConfig(configPath);
+  const { translationPaths } = config;
+  const watchPaths = [];
+  for (const localePaths of Object.values(translationPaths)) {
+    watchPaths.push(...Object.values(localePaths));
+  }
+  console.log(
+    import_chalk6.default.blue(`\u{1F440} Watching for changes in ${watchPaths.length} files...`)
+  );
+  const watcher = (0, import_chokidar.watch)(watchPaths, {
+    ignoreInitial: true,
+    persistent: true
+  });
+  watcher.on("change", async (filePath) => {
+    console.log(import_chalk6.default.yellow(`\u{1F4DD} File changed: ${filePath}`));
+    try {
+      const data = await getMessageData(configPath);
+      await writeGeneratedFiles(data, outputDir, options);
+      console.log(import_chalk6.default.green("\u2713 Regenerated translations"));
+    } catch (error) {
+      console.error(import_chalk6.default.red("\u2717 Failed to regenerate:"), error);
+    }
+  });
+  process.on("SIGINT", () => {
+    watcher.close();
+    console.log(import_chalk6.default.gray("\n\u{1F44B} Stopped watching"));
+    process.exit(0);
+  });
+}
 async function generateCommand(options) {
-  console.log(import_chalk6.default.blue("Generate command not yet implemented"));
-  console.log("Options:", options);
+  const spinner = (0, import_ora6.default)("Loading translation data...").start();
+  if (options.verbose) {
+    console.log(
+      import_chalk6.default.gray(`Debug options: ${JSON.stringify(options, null, 2)}`)
+    );
+  }
+  try {
+    const data = await getMessageData(options.config, options);
+    spinner.succeed(
+      `Loaded ${data.locales.length} locales, ${data.namespaces.length} namespaces, ${data.translationKeys.length} keys`
+    );
+    const outputDir = options.output || "./node_modules/.intl-party";
+    spinner.start("Generating files...");
+    await writeGeneratedFiles(data, outputDir, options);
+    spinner.succeed("Files generated successfully");
+    console.log(import_chalk6.default.green(`\u2713 Generated translation files in ${outputDir}`));
+    if (options.client) {
+      await generateClientPackage(data, options);
+    }
+    if (options.watch) {
+      await setupWatcher(options.config, outputDir, options);
+    }
+  } catch (error) {
+    spinner.fail("Generation failed");
+    console.error(
+      import_chalk6.default.red("Error:"),
+      error instanceof Error ? error.message : error
+    );
+    process.exit(1);
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {