@intl-party/cli 1.0.0 → 1.1.1

package/dist/cli.js

@@ -6,8 +6,12 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+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 });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -26,107 +30,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// package.json
-var require_package = __commonJS({
-  "package.json"(exports2, module2) {
-    module2.exports = {
-      name: "@intl-party/cli",
-      version: "1.0.0",
-      description: "Command-line interface for IntlParty - validation, extraction, and management tools",
-      main: "dist/index.js",
-      types: "dist/index.d.ts",
-      bin: {
-        "intl-party": "./dist/cli.js",
-        ip: "./dist/cli.js"
-      },
-      files: [
-        "dist"
-      ],
-      scripts: {
-        build: "tsup src/cli.ts src/index.ts --format cjs",
-        dev: "tsup src/cli.ts src/index.ts --format cjs --dts --watch",
-        test: "vitest",
-        "test:watch": "vitest --watch",
-        lint: "eslint src --ext .ts",
-        typecheck: "tsc --noEmit",
-        clean: "rm -rf dist"
-      },
-      keywords: [
-        "cli",
-        "i18n",
-        "internationalization",
-        "validation",
-        "extraction",
-        "typescript"
-      ],
-      author: "IntlParty Team",
-      license: "MIT",
-      dependencies: {
-        "@intl-party/core": "workspace:*",
-        commander: "^11.1.0",
-        chalk: "^5.3.0",
-        glob: "^10.3.10",
-        "fs-extra": "^11.2.0",
-        ora: "^7.0.1",
-        inquirer: "^9.2.12"
-      },
-      devDependencies: {
-        "@types/fs-extra": "^11.0.4",
-        "@types/inquirer": "^9.0.7",
-        "@types/node": "^20.10.0",
-        eslint: "^8.55.0",
-        jsdom: "^23.0.1",
-        tsup: "^8.0.1",
-        typescript: "^5.3.0",
-        vitest: "^1.0.0"
-      },
-      repository: {
-        type: "git",
-        url: "https://github.com/intl-party/intl-party.git",
-        directory: "packages/cli"
-      }
-    };
-  }
-});
-
-// src/cli.ts
-var import_commander = require("commander");
-var import_chalk7 = __toESM(require("chalk"));
-
-// src/commands/validate.ts
-var import_chalk = __toESM(require("chalk"));
-var import_ora = __toESM(require("ora"));
-var import_fs_extra3 = __toESM(require("fs-extra"));
-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 DEFAULT_CONFIG = {
-  locales: ["en", "es", "fr"],
-  defaultLocale: "en",
-  namespaces: ["common"],
-  translationPaths: {},
-  sourcePatterns: ["src/**/*.{ts,tsx,js,jsx}"],
-  outputDir: "./translations",
-  validation: {
-    strict: false,
-    logMissing: true,
-    throwOnMissing: false,
-    validateFormats: true
-  },
-  extraction: {
-    keyPrefix: "",
-    markExtracted: true,
-    sortKeys: true,
-    includeMetadata: false
-  },
-  sync: {
-    removeUnused: false,
-    addMissing: true,
-    preserveOrder: true
-  }
-};
+var config_exports = {};
+__export(config_exports, {
+  loadConfig: () => loadConfig,
+  saveConfig: () => saveConfig
+});
 async function loadConfig(configPath) {
   const configFiles = [
     configPath,
@@ -145,8 +54,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;
           }
@@ -162,9 +71,9 @@ async function loadConfig(configPath) {
   const packageJsonPath = "package.json";
   if (await import_fs_extra.default.pathExists(packageJsonPath)) {
     try {
-      const packageJson2 = await import_fs_extra.default.readJson(packageJsonPath);
-      if (packageJson2["intl-party"]) {
-        return mergeConfig(DEFAULT_CONFIG, packageJson2["intl-party"]);
+      const packageJson = await import_fs_extra.default.readJson(packageJsonPath);
+      if (packageJson["intl-party"]) {
+        return mergeConfig(DEFAULT_CONFIG, packageJson["intl-party"]);
       }
     } catch {
     }
@@ -188,20 +97,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`
@@ -218,7 +127,7 @@ async function autoDetectConfig() {
   return config;
 }
 function mergeConfig(defaultConfig, userConfig) {
-  return {
+  const merged = {
     ...defaultConfig,
     ...userConfig,
     validation: {
@@ -238,13 +147,67 @@ 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));
 }
+var import_fs_extra, import_node_path, DEFAULT_CONFIG;
+var init_config = __esm({
+  "src/utils/config.ts"() {
+    "use strict";
+    import_fs_extra = __toESM(require("fs-extra"));
+    import_node_path = __toESM(require("path"));
+    DEFAULT_CONFIG = {
+      locales: ["en", "es", "fr"],
+      defaultLocale: "en",
+      namespaces: ["common"],
+      translationPaths: {},
+      sourcePatterns: ["src/**/*.{ts,tsx,js,jsx}"],
+      outputDir: "./translations",
+      validation: {
+        strict: false,
+        logMissing: true,
+        throwOnMissing: false,
+        validateFormats: true
+      },
+      extraction: {
+        keyPrefix: "",
+        markExtracted: true,
+        sortKeys: true,
+        includeMetadata: false
+      },
+      sync: {
+        removeUnused: false,
+        addMissing: true,
+        preserveOrder: true
+      }
+    };
+  }
+});
+
+// src/cli.ts
+var import_commander2 = require("commander");
+var import_chalk8 = __toESM(require("chalk"));
+
+// src/commands/validate.ts
+var import_chalk = __toESM(require("chalk"));
+var import_ora = __toESM(require("ora"));
+var import_fs_extra3 = __toESM(require("fs-extra"));
+var import_core = require("@intl-party/core");
+init_config();
 
 // src/utils/translations.ts
 var import_fs_extra2 = __toESM(require("fs-extra"));
+var import_node_path2 = __toESM(require("path"));
 async function loadTranslations(translationPaths, locales, namespaces) {
   const translations = {};
   for (const locale of locales) {
@@ -268,6 +231,21 @@ async function loadTranslations(translationPaths, locales, namespaces) {
   }
   return translations;
 }
+async function saveTranslations(translations, translationPaths) {
+  for (const [locale, localeTranslations] of Object.entries(translations)) {
+    for (const [namespace, namespaceTranslations] of Object.entries(
+      localeTranslations
+    )) {
+      const translationPath = translationPaths[locale]?.[namespace];
+      if (translationPath) {
+        await import_fs_extra2.default.ensureDir(import_node_path2.default.dirname(translationPath));
+        await import_fs_extra2.default.writeJson(translationPath, namespaceTranslations, {
+          spaces: 2
+        });
+      }
+    }
+  }
+}
 
 // src/commands/validate.ts
 async function validateCommand(options) {
@@ -432,12 +410,23 @@ 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_path2 = __toESM(require("path"));
+var import_node_path3 = __toESM(require("path"));
+init_config();
 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 {
+    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 || ["src/**/*.{ts,tsx,js,jsx}"];
-    const outputDir = options.output || "./translations";
+    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();
@@ -454,7 +443,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");
@@ -472,6 +461,8 @@ function extractKeysFromContent(content) {
     // t('key')
     /useTranslations\(\)\(['"`]([^'"`]+)['"`]\)/g,
     // useTranslations()('key')
+    /useTranslations\(['"`]([^'"`]+)['"`]\)\(['"`]([^'"`]+)['"`]\)/g,
+    // useTranslations('ns')('key')
     /i18nKey=['"`]([^'"`]+)['"`]/g,
     // i18nKey="key"
     /\{\s*t\(['"`]([^'"`]+)['"`]\)\s*\}/g
@@ -480,12 +471,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) {
@@ -501,46 +496,273 @@ 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_path2.default.join(outputDir, "en", `${namespace}.json`);
-    await import_fs_extra4.default.ensureDir(import_path2.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"));
+init_config();
 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_path3 = __toESM(require("path"));
-var import_inquirer = __toESM(require("inquirer"));
+var import_node_path4 = __toESM(require("path"));
+var import_inquirer2 = __toESM(require("inquirer"));
+init_config();
 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",
@@ -555,7 +777,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",
@@ -617,7 +839,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_path3.default.join(
+        config.translationPaths[locale][namespace] = import_node_path4.default.join(
           answers.translationsDir,
           locale,
           `${namespace}.json`
@@ -627,10 +849,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_path3.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_path3.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 });
         }
@@ -774,10 +996,11 @@ 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"));
+init_config();
 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");
@@ -899,46 +1122,927 @@ 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");
+init_config();
+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);
+  }
+}
+
+// src/commands/nextjs.ts
+var import_commander = require("commander");
+var import_node_fs = require("fs");
+var import_node_path6 = require("path");
+var import_chalk7 = __toESM(require("chalk"));
+async function initializeNextjsProject(force = false) {
+  console.log(import_chalk7.default.cyan("\u{1F680} Initializing IntlParty for Next.js..."));
+  if ((0, import_node_fs.existsSync)("intl-party.config.ts") || (0, import_node_fs.existsSync)("intl-party.config.js")) {
+    if (!force) {
+      console.log(import_chalk7.default.yellow("\u26A0\uFE0F  IntlParty already initialized!"));
+      return true;
+    }
+    console.log(import_chalk7.default.yellow("\u26A0\uFE0F  Force flag set, overwriting existing files..."));
+  }
+  const hasSrcDir = (0, import_node_fs.existsSync)("src");
+  const baseDir = hasSrcDir ? "src" : ".";
+  const appDir = (0, import_node_path6.join)(baseDir, "app");
+  const configContent = `// IntlParty configuration for Next.js
+export default {
+  locales: ["en", "es", "fr"],
+  defaultLocale: "en",
+  messages: "./messages",
+  // localePrefix defaults to "never" for clean URLs
+  // cookieName defaults to "INTL_LOCALE"
+};`;
+  (0, import_node_fs.writeFileSync)("intl-party.config.ts", configContent);
+  console.log(import_chalk7.default.green("\u2705 Created intl-party.config.ts"));
+  const messagesDir = "messages";
+  if (!(0, import_node_fs.existsSync)(messagesDir)) {
+    (0, import_node_fs.mkdirSync)(messagesDir, { recursive: true });
+  }
+  const locales = ["en", "es", "fr"];
+  const sampleMessagesBase = {
+    welcome: "Welcome to IntlParty!",
+    description: "A modern i18n solution for Next.js",
+    navigation: {
+      home: "Home",
+      about: "About",
+      contact: "Contact"
+    }
+  };
+  locales.forEach((locale) => {
+    const localeDir = (0, import_node_path6.join)(messagesDir, locale);
+    if (!(0, import_node_fs.existsSync)(localeDir)) {
+      (0, import_node_fs.mkdirSync)(localeDir, { recursive: true });
+    }
+    const messages = {
+      ...sampleMessagesBase,
+      navigation: { ...sampleMessagesBase.navigation }
+    };
+    if (locale === "es") {
+      messages.welcome = "\xA1Bienvenido a IntlParty!";
+      messages.description = "Una soluci\xF3n i18n moderna para Next.js";
+      messages.navigation.home = "Inicio";
+      messages.navigation.about = "Acerca de";
+      messages.navigation.contact = "Contacto";
+    } else if (locale === "fr") {
+      messages.welcome = "Bienvenue chez IntlParty !";
+      messages.description = "Une solution i18n moderne pour Next.js";
+      messages.navigation.home = "Accueil";
+      messages.navigation.about = "\xC0 propos";
+      messages.navigation.contact = "Contact";
+    }
+    (0, import_node_fs.writeFileSync)(
+      (0, import_node_path6.join)(localeDir, "common.json"),
+      JSON.stringify(messages, null, 2)
+    );
+  });
+  console.log(import_chalk7.default.green("\u2705 Created sample message files in ./messages"));
+  const middlewarePath = hasSrcDir ? "src/middleware.ts" : "middleware.ts";
+  const middlewareContent = `import { createSetup } from "@intl-party/nextjs";
+import config from "${hasSrcDir ? "../" : "./"}intl-party.config";
+
+const { middleware, middlewareConfig } = createSetup(config);
+
+export { middleware };
+export const config = middlewareConfig;`;
+  (0, import_node_fs.writeFileSync)(middlewarePath, middlewareContent);
+  console.log(import_chalk7.default.green(`\u2705 Created ${middlewarePath}`));
+  if ((0, import_node_fs.existsSync)("next.config.js")) {
+    const nextConfigIntlPath = "next.config.intl-party.js";
+    const nextConfigContent = `const { createNextConfigWithIntl } = require("@intl-party/nextjs");
+
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  reactStrictMode: true,
+};
+
+module.exports = createNextConfigWithIntl(
+  {
+    i18nConfig: require("./intl-party.config").default,
+    autoGenerate: true,
+    watchMode: true,
+  },
+  nextConfig
+);`;
+    (0, import_node_fs.writeFileSync)(nextConfigIntlPath, nextConfigContent);
+    console.log(
+      import_chalk7.default.green(
+        `\u2705 Created ${nextConfigIntlPath} (merge with your next.config.js)`
+      )
+    );
+  }
+  if (!(0, import_node_fs.existsSync)(appDir)) {
+    (0, import_node_fs.mkdirSync)(appDir, { recursive: true });
+  }
+  const layoutContent = `import { createSetup } from "@intl-party/nextjs";
+import config from "${hasSrcDir ? "../../" : "../"}intl-party.config";
+
+const { getLocale, getMessages, Provider } = createSetup(config);
+
+export default async function RootLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  const locale = await getLocale();
+  const messages = await getMessages(locale);
+
+  return (
+    <html lang={locale}>
+      <body>
+        <Provider locale={locale} initialMessages={messages}>
+          {children}
+        </Provider>
+      </body>
+    </html>
+  );
+}`;
+  (0, import_node_fs.writeFileSync)((0, import_node_path6.join)(appDir, "layout.intl-party.tsx"), layoutContent);
+  const pageContent = `import { useTranslations } from "@intl-party/nextjs";
+
+export default function HomePage() {
+  const t = useTranslations("common");
+
+  return (
+    <div style={{ padding: "2rem", fontFamily: "system-ui, sans-serif" }}>
+      <h1>{t("welcome")}</h1>
+      <p>{t("description")}</p>
+      
+      <nav style={{ display: "flex", gap: "1rem", marginTop: "1rem" }}>
+        <a href="/">{t("navigation.home")}</a>
+        <a href="/about">{t("navigation.about")}</a>
+        <a href="/contact">{t("navigation.contact")}</a>
+      </nav>
+    </div>
+  );
+}`;
+  (0, import_node_fs.writeFileSync)((0, import_node_path6.join)(appDir, "page.intl-party.tsx"), pageContent);
+  console.log(import_chalk7.default.green(`\u2705 Created example files in ${appDir}`));
+  if ((0, import_node_fs.existsSync)(".gitignore")) {
+    const gitignore = (0, import_node_fs.readFileSync)(".gitignore", "utf-8");
+    if (!gitignore.includes(".intl-party")) {
+      console.log(import_chalk7.default.blue("\n\u{1F4A1} Tip: Add .intl-party/ to your .gitignore"));
+    }
+  }
+  console.log(import_chalk7.default.blue("\n\u{1F4A1} Tip: Make sure to install the dependency:"));
+  console.log(import_chalk7.default.white("   npm install @intl-party/nextjs"));
+  console.log(import_chalk7.default.green("\n\u{1F389} IntlParty initialized successfully!"));
+  console.log("\n\u{1F4DD} Next steps:");
+  console.log("1. Review the generated configuration files");
+  console.log(
+    `2. Move/merge ${appDir}/layout.intl-party.tsx into your RootLayout`
+  );
+  console.log("3. Add translations to your message files in ./messages");
+  console.log("4. Run your development server");
+  console.log(`
+\u{1F4DA} For more information, visit: https://intl-party.ai/docs`);
+  return true;
 }
+var nextjsCommand = new import_commander.Command("nextjs").description("Next.js specific commands for IntlParty").option("--init", "Initialize IntlParty in a Next.js project").option("--force", "Force overwrite existing files").action(async (options) => {
+  if (options.init) {
+    await initializeNextjsProject(options.force);
+  } else {
+    console.log("Please specify an action. Use --init to initialize.");
+  }
+});
+
+// package.json
+var package_default = {
+  name: "@intl-party/cli",
+  version: "1.1.1",
+  description: "Command-line interface for IntlParty - validation, extraction, and management tools",
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  bin: {
+    "intl-party": "./dist/cli.js",
+    ip: "./dist/cli.js"
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "tsup src/cli.ts src/index.ts --format cjs",
+    dev: "tsup src/cli.ts src/index.ts --format cjs --dts --watch",
+    test: "vitest --run",
+    "test:watch": "vitest",
+    lint: "eslint src --ext .ts",
+    typecheck: "tsc --noEmit",
+    clean: "rm -rf dist"
+  },
+  keywords: [
+    "cli",
+    "i18n",
+    "internationalization",
+    "validation",
+    "extraction",
+    "typescript"
+  ],
+  author: "RodrigoEspinosa",
+  license: "MIT",
+  homepage: "https://github.com/RodrigoEspinosa/intl-party#readme",
+  bugs: {
+    url: "https://github.com/RodrigoEspinosa/intl-party/issues"
+  },
+  dependencies: {
+    "@intl-party/core": "workspace:*",
+    commander: "^11.1.0",
+    chalk: "^5.3.0",
+    chokidar: "^3.5.3",
+    glob: "^10.3.10",
+    "fs-extra": "^11.2.0",
+    ora: "^7.0.1",
+    inquirer: "^9.2.12"
+  },
+  devDependencies: {
+    "@types/fs-extra": "^11.0.4",
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.10.0",
+    eslint: "^8.55.0",
+    jsdom: "^23.0.1",
+    tsup: "^8.0.1",
+    typescript: "^5.3.0",
+    vitest: "^1.0.0"
+  },
+  repository: {
+    type: "git",
+    url: "https://github.com/RodrigoEspinosa/intl-party.git",
+    directory: "packages/cli"
+  },
+  engines: {
+    node: ">=18.0.0"
+  }
+};
 
 // src/cli.ts
-var packageJson = require_package();
-import_commander.program.name("intl-party").description("CLI for IntlParty internationalization library").version(packageJson.version);
-import_commander.program.option("-c, --config <path>", "path to config file", "intl-party.config.js").option("-v, --verbose", "verbose output").option("--no-color", "disable colored output");
-import_commander.program.command("validate").description("validate translation files for completeness and consistency").option("-l, --locales <locales...>", "specific locales to validate").option("-n, --namespaces <namespaces...>", "specific namespaces to validate").option("--strict", "enable strict validation mode").option("--format <format>", "output format (text|json|junit)", "text").option("--output <file>", "output file path").action(validateCommand);
-import_commander.program.command("extract").description("extract translation keys from source code").option("-s, --source <patterns...>", "source file patterns", [
+import_commander2.program.name("intl-party").description("CLI for IntlParty internationalization library").version(package_default.version);
+import_commander2.program.option("-c, --config <path>", "path to config file", "intl-party.config.js").option("-v, --verbose", "verbose output").option("--no-color", "disable colored output");
+import_commander2.program.command("validate").description("validate translation files for completeness and consistency").option("-l, --locales <locales...>", "specific locales to validate").option("-n, --namespaces <namespaces...>", "specific namespaces to validate").option("--strict", "enable strict validation mode").option("--format <format>", "output format (text|json|junit)", "text").option("--output <file>", "output file path").action(validateCommand);
+import_commander2.program.command("extract").description("extract translation keys from source code").option("-s, --source <patterns...>", "source file patterns", [
   "src/**/*.{ts,tsx,js,jsx}"
 ]).option(
   "-o, --output <dir>",
   "output directory for extracted keys",
-  "./translations"
+  "./messages"
 ).option("--dry-run", "show what would be extracted without writing files").option("--update", "update existing translation files with new keys").option("--remove-unused", "remove unused translation keys").action(extractCommand);
-import_commander.program.command("sync").description("synchronize translations across locales").option("-b, --base <locale>", "base locale to sync from", "en").option("-t, --target <locales...>", "target locales to sync to").option("--missing-only", "only add missing keys, don't remove extras").option("--interactive", "interactive mode for conflict resolution").action(syncCommand);
-import_commander.program.command("init").description("initialize intl-party configuration and structure").option("--force", "overwrite existing configuration").option(
+import_commander2.program.command("sync").description("synchronize translations across locales").option("-b, --base <locale>", "base locale to sync from", "en").option("-t, --target <locales...>", "target locales to sync to").option("--missing-only", "only add missing keys, don't remove extras").option("--interactive", "interactive mode for conflict resolution").action(syncCommand);
+import_commander2.program.command("init").description("initialize intl-party configuration and structure").option("--force", "overwrite existing configuration").option(
   "--template <template>",
   "template to use (nextjs|react|vanilla)",
   "react"
 ).action(initCommand);
-import_commander.program.command("check").description("check for issues in translations and configuration").option("--missing", "check for missing translations").option("--unused", "check for unused translation keys").option("--duplicates", "check for duplicate keys").option("--format-errors", "check for format errors in translations").option("--fix", "automatically fix issues where possible").action(checkCommand);
-import_commander.program.command("generate").description("generate TypeScript definitions and other files").option("-t, --types", "generate TypeScript type definitions").option("-s, --schemas", "generate JSON schemas").option("-d, --docs", "generate documentation").option("--watch", "watch for changes and regenerate").action(generateCommand);
-import_commander.program.command("completion").description("generate shell completion scripts").option("--shell <shell>", "shell type (bash|zsh|fish)", "bash").action((options) => {
+import_commander2.program.command("check").description("check for issues in translations and configuration").option("--missing", "check for missing translations").option("--unused", "check for unused translation keys").option("--duplicates", "check for duplicate keys").option("--format-errors", "check for format errors in translations").option("--fix", "automatically fix issues where possible").action(checkCommand);
+import_commander2.program.command("check-config").description("validate your intl-party configuration").option("-c, --config <path>", "path to config file").action(async (options) => {
+  const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const spinner = (await import("ora")).default("Validating configuration...").start();
+  try {
+    const config = await loadConfig2(options.config);
+    spinner.succeed("Configuration is valid!");
+    if (options.verbose) {
+      console.log(JSON.stringify(config, null, 2));
+    }
+  } catch (error) {
+    spinner.fail("Configuration is invalid");
+    console.error(
+      import_chalk8.default.red("Error:"),
+      error instanceof Error ? error.message : error
+    );
+    process.exit(1);
+  }
+});
+import_commander2.program.command("generate").description("generate TypeScript definitions and other files").option("-t, --types", "generate TypeScript type definitions").option("-s, --schemas", "generate JSON schemas").option("-d, --docs", "generate documentation").option("-c, --client", "generate client package files").option(
+  "-o, --output <dir>",
+  "output directory for generated files",
+  "./node_modules/.intl-party"
+).option("--watch", "watch for changes and regenerate").option("--verbose", "verbose output").action(generateCommand);
+import_commander2.program.addCommand(nextjsCommand);
+import_commander2.program.command("completion").description("generate shell completion scripts").option("--shell <shell>", "shell type (bash|zsh|fish)", "bash").action((_options) => {
   console.log("Shell completion not implemented yet");
 });
-import_commander.program.exitOverride((err) => {
+import_commander2.program.exitOverride((err) => {
   if (err.code === "commander.help") {
     process.exit(0);
   }
   if (err.code === "commander.version") {
     process.exit(0);
   }
-  console.error(import_chalk7.default.red("Error:"), err.message);
+  console.error(import_chalk8.default.red("Error:"), err.message);
   process.exit(1);
 });
-import_commander.program.parse();
+import_commander2.program.parse();
 if (!process.argv.slice(2).length) {
-  import_commander.program.outputHelp();
+  import_commander2.program.outputHelp();
 }