@intl-party/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,885 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  checkCommand: () => checkCommand,
+  extractCommand: () => extractCommand,
+  generateCommand: () => generateCommand,
+  initCommand: () => initCommand,
+  loadConfig: () => loadConfig,
+  loadTranslations: () => loadTranslations,
+  saveConfig: () => saveConfig,
+  saveTranslations: () => saveTranslations,
+  syncCommand: () => syncCommand,
+  validateCommand: () => validateCommand
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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
+  }
+};
+async function loadConfig(configPath) {
+  const configFiles = [
+    configPath,
+    "intl-party.config.js",
+    "intl-party.config.ts",
+    "intl-party.config.json",
+    ".intl-party.config.js",
+    ".intl-party.config.ts",
+    ".intl-party.config.json"
+  ].filter(Boolean);
+  for (const configFile of configFiles) {
+    if (configFile && await import_fs_extra.default.pathExists(configFile)) {
+      try {
+        let config;
+        if (configFile.endsWith(".json")) {
+          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));
+          if (config.default) {
+            config = config.default;
+          }
+        }
+        return mergeConfig(DEFAULT_CONFIG, config);
+      } catch (error) {
+        throw new Error(
+          `Failed to load config from ${configFile}: ${error instanceof Error ? error.message : error}`
+        );
+      }
+    }
+  }
+  const packageJsonPath = "package.json";
+  if (await import_fs_extra.default.pathExists(packageJsonPath)) {
+    try {
+      const packageJson = await import_fs_extra.default.readJson(packageJsonPath);
+      if (packageJson["intl-party"]) {
+        return mergeConfig(DEFAULT_CONFIG, packageJson["intl-party"]);
+      }
+    } catch {
+    }
+  }
+  const autoDetected = await autoDetectConfig();
+  return mergeConfig(DEFAULT_CONFIG, autoDetected);
+}
+async function autoDetectConfig() {
+  const config = {};
+  const commonPaths = [
+    "translations",
+    "locales",
+    "i18n",
+    "public/locales",
+    "src/locales",
+    "src/translations",
+    "assets/locales"
+  ];
+  for (const basePath of commonPaths) {
+    if (await import_fs_extra.default.pathExists(basePath)) {
+      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()
+        );
+        if (locales.length > 0) {
+          config.locales = locales;
+          config.translationPaths = {};
+          const firstLocaleDir = import_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"));
+          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(
+                  basePath,
+                  locale,
+                  `${namespace}.json`
+                );
+              }
+            }
+          }
+          break;
+        }
+      } catch {
+      }
+    }
+  }
+  return config;
+}
+function mergeConfig(defaultConfig, userConfig) {
+  return {
+    ...defaultConfig,
+    ...userConfig,
+    validation: {
+      ...defaultConfig.validation,
+      ...userConfig.validation
+    },
+    extraction: {
+      ...defaultConfig.extraction,
+      ...userConfig.extraction
+    },
+    sync: {
+      ...defaultConfig.sync,
+      ...userConfig.sync
+    },
+    translationPaths: {
+      ...defaultConfig.translationPaths,
+      ...userConfig.translationPaths
+    }
+  };
+}
+async function saveConfig(config, configPath = "intl-party.config.json") {
+  await import_fs_extra.default.writeFile(configPath, JSON.stringify(config, null, 2));
+}
+
+// src/utils/translations.ts
+var import_fs_extra2 = __toESM(require("fs-extra"));
+var import_path2 = __toESM(require("path"));
+async function loadTranslations(translationPaths, locales, namespaces) {
+  const translations = {};
+  for (const locale of locales) {
+    translations[locale] = {};
+    for (const namespace of namespaces) {
+      const translationPath = translationPaths[locale]?.[namespace];
+      if (translationPath && await import_fs_extra2.default.pathExists(translationPath)) {
+        try {
+          const content = await import_fs_extra2.default.readJson(translationPath);
+          translations[locale][namespace] = content;
+        } catch (error) {
+          console.warn(
+            `Failed to load ${locale}/${namespace} from ${translationPath}`
+          );
+          translations[locale][namespace] = {};
+        }
+      } else {
+        translations[locale][namespace] = {};
+      }
+    }
+  }
+  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_path2.default.dirname(translationPath));
+        await import_fs_extra2.default.writeJson(translationPath, namespaceTranslations, {
+          spaces: 2
+        });
+      }
+    }
+  }
+}
+
+// src/commands/validate.ts
+async function validateCommand(options) {
+  const spinner = (0, import_ora.default)("Loading configuration...").start();
+  try {
+    const config = await loadConfig(options.config);
+    spinner.succeed("Configuration loaded");
+    const targetLocales = options.locales || config.locales;
+    const targetNamespaces = options.namespaces || config.namespaces;
+    spinner.start("Loading translations...");
+    const translations = await loadTranslations(
+      config.translationPaths,
+      targetLocales,
+      targetNamespaces
+    );
+    spinner.succeed("Translations loaded");
+    spinner.start("Validating translations...");
+    const validationConfig = {
+      strict: options.strict || config.validation?.strict || false,
+      logMissing: options.verbose || false,
+      throwOnMissing: false,
+      validateFormats: true
+    };
+    const result = (0, import_core.validateTranslations)(
+      translations,
+      targetLocales,
+      targetNamespaces,
+      validationConfig
+    );
+    spinner.stop();
+    await outputResults(result, options);
+    if (!result.valid) {
+      process.exit(1);
+    }
+  } catch (error) {
+    spinner.fail("Validation failed");
+    console.error(
+      import_chalk.default.red("Error:"),
+      error instanceof Error ? error.message : error
+    );
+    process.exit(1);
+  }
+}
+async function outputResults(result, options) {
+  if (options.format === "json") {
+    const output = JSON.stringify(result, null, 2);
+    if (options.output) {
+      await import_fs_extra3.default.writeFile(options.output, output);
+      console.log(import_chalk.default.green("\u2713"), `Results written to ${options.output}`);
+    } else {
+      console.log(output);
+    }
+    return;
+  }
+  if (options.format === "junit") {
+    const junitXml = generateJUnitXML(result);
+    if (options.output) {
+      await import_fs_extra3.default.writeFile(options.output, junitXml);
+      console.log(
+        import_chalk.default.green("\u2713"),
+        `JUnit report written to ${options.output}`
+      );
+    } else {
+      console.log(junitXml);
+    }
+    return;
+  }
+  if (result.valid) {
+    console.log(import_chalk.default.green("\u2713 All translations are valid!"));
+    if (result.warnings.length > 0) {
+      console.log(import_chalk.default.yellow(`
+\u26A0 ${result.warnings.length} warning(s):`));
+      result.warnings.forEach((warning, index) => {
+        console.log(
+          `  ${index + 1}. ${import_chalk.default.yellow(warning.type)}: ${warning.message}`
+        );
+        if (options.verbose) {
+          console.log(
+            `     Locale: ${warning.locale}, Namespace: ${warning.namespace}, Key: ${warning.key}`
+          );
+        }
+      });
+    }
+  } else {
+    console.log(
+      import_chalk.default.red(`\u2717 Validation failed with ${result.errors.length} error(s):`)
+    );
+    result.errors.forEach((error, index) => {
+      console.log(`  ${index + 1}. ${import_chalk.default.red(error.type)}: ${error.message}`);
+      if (options.verbose) {
+        console.log(
+          `     Locale: ${error.locale}, Namespace: ${error.namespace}, Key: ${error.key}`
+        );
+      }
+    });
+    if (result.warnings.length > 0) {
+      console.log(import_chalk.default.yellow(`
+\u26A0 ${result.warnings.length} warning(s):`));
+      result.warnings.forEach((warning, index) => {
+        console.log(
+          `  ${index + 1}. ${import_chalk.default.yellow(warning.type)}: ${warning.message}`
+        );
+        if (options.verbose) {
+          console.log(
+            `     Locale: ${warning.locale}, Namespace: ${warning.namespace}, Key: ${warning.key}`
+          );
+        }
+      });
+    }
+  }
+  const totalIssues = result.errors.length + result.warnings.length;
+  if (totalIssues > 0) {
+    console.log(
+      `
+Summary: ${result.errors.length} errors, ${result.warnings.length} warnings`
+    );
+  }
+}
+function generateJUnitXML(result) {
+  const totalTests = 1;
+  const failures = result.valid ? 0 : 1;
+  const errors = result.errors.length;
+  let xml = `<?xml version="1.0" encoding="UTF-8"?>
+`;
+  xml += `<testsuites name="intl-party-validation" tests="${totalTests}" failures="${failures}" errors="${errors}">
+`;
+  xml += `  <testsuite name="translation-validation" tests="${totalTests}" failures="${failures}" errors="${errors}">
+`;
+  if (result.valid) {
+    xml += `    <testcase name="validation" classname="translations" />
+`;
+  } else {
+    xml += `    <testcase name="validation" classname="translations">
+`;
+    xml += `      <failure message="Translation validation failed">
+`;
+    xml += `        <![CDATA[
+`;
+    result.errors.forEach((error) => {
+      xml += `${error.type}: ${error.message}
+`;
+      xml += `  Locale: ${error.locale}, Namespace: ${error.namespace}, Key: ${error.key}
+
+`;
+    });
+    xml += `        ]]>
+`;
+    xml += `      </failure>
+`;
+    xml += `    </testcase>
+`;
+  }
+  xml += `  </testsuite>
+`;
+  xml += `</testsuites>
+`;
+  return xml;
+}
+
+// src/commands/extract.ts
+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"));
+async function extractCommand(options) {
+  const spinner = (0, import_ora2.default)("Extracting translation keys...").start();
+  try {
+    const sourcePatterns = options.source || ["src/**/*.{ts,tsx,js,jsx}"];
+    const outputDir = options.output || "./translations";
+    const files = await (0, import_glob.glob)(sourcePatterns);
+    spinner.succeed(`Found ${files.length} source files`);
+    const extractedKeys = /* @__PURE__ */ new Set();
+    for (const file of files) {
+      const content = await import_fs_extra4.default.readFile(file, "utf-8");
+      const keys = extractKeysFromContent(content);
+      keys.forEach((key) => extractedKeys.add(key));
+    }
+    spinner.succeed(`Extracted ${extractedKeys.size} unique translation keys`);
+    if (options.dryRun) {
+      console.log("\nExtracted keys:");
+      Array.from(extractedKeys).sort().forEach((key) => {
+        console.log(`  ${import_chalk2.default.cyan(key)}`);
+      });
+      return;
+    }
+    await writeExtractedKeys(Array.from(extractedKeys), outputDir, options);
+    console.log(import_chalk2.default.green(`\u2713 Translation keys extracted to ${outputDir}`));
+  } catch (error) {
+    spinner.fail("Extraction failed");
+    console.error(
+      import_chalk2.default.red("Error:"),
+      error instanceof Error ? error.message : error
+    );
+    process.exit(1);
+  }
+}
+function extractKeysFromContent(content) {
+  const keys = [];
+  const patterns = [
+    /t\(['"`]([^'"`]+)['"`]\)/g,
+    // t('key')
+    /useTranslations\(\)\(['"`]([^'"`]+)['"`]\)/g,
+    // useTranslations()('key')
+    /i18nKey=['"`]([^'"`]+)['"`]/g,
+    // i18nKey="key"
+    /\{\s*t\(['"`]([^'"`]+)['"`]\)\s*\}/g
+    // { t('key') }
+  ];
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      keys.push(match[1]);
+    }
+  }
+  return keys;
+}
+async function writeExtractedKeys(keys, outputDir, options) {
+  await import_fs_extra4.default.ensureDir(outputDir);
+  const namespaces = { common: [] };
+  for (const key of keys) {
+    const parts = key.split(".");
+    if (parts.length > 1) {
+      const namespace = parts[0];
+      const keyWithoutNamespace = parts.slice(1).join(".");
+      if (!namespaces[namespace]) {
+        namespaces[namespace] = [];
+      }
+      namespaces[namespace].push(keyWithoutNamespace);
+    } else {
+      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 {
+      }
+    }
+    for (const key of namespaceKeys) {
+      if (!translations[key]) {
+        translations[key] = key;
+      }
+    }
+    await import_fs_extra4.default.writeJson(filePath, translations, { spaces: 2 });
+  }
+}
+
+// src/commands/sync.ts
+var import_chalk3 = __toESM(require("chalk"));
+async function syncCommand(options) {
+  console.log(import_chalk3.default.blue("Sync command not yet implemented"));
+  console.log("Options:", options);
+}
+
+// src/commands/init.ts
+var import_chalk4 = __toESM(require("chalk"));
+var import_ora3 = __toESM(require("ora"));
+var import_fs_extra5 = __toESM(require("fs-extra"));
+var import_path4 = __toESM(require("path"));
+var import_inquirer = __toESM(require("inquirer"));
+async function initCommand(options) {
+  const spinner = (0, import_ora3.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([
+        {
+          type: "confirm",
+          name: "overwrite",
+          message: "Configuration file already exists. Overwrite?",
+          default: false
+        }
+      ]);
+      if (!overwrite) {
+        console.log(import_chalk4.default.yellow("Initialization cancelled."));
+        return;
+      }
+    }
+    spinner.start("Setting up configuration...");
+    spinner.stop();
+    const answers = await import_inquirer.default.prompt([
+      {
+        type: "input",
+        name: "defaultLocale",
+        message: "Default locale:",
+        default: "en"
+      },
+      {
+        type: "input",
+        name: "locales",
+        message: "Supported locales (comma-separated):",
+        default: "en,es,fr",
+        filter: (input) => input.split(",").map((l) => l.trim())
+      },
+      {
+        type: "input",
+        name: "namespaces",
+        message: "Translation namespaces (comma-separated):",
+        default: "common",
+        filter: (input) => input.split(",").map((n) => n.trim())
+      },
+      {
+        type: "input",
+        name: "translationsDir",
+        message: "Translations directory:",
+        default: "./translations"
+      },
+      {
+        type: "input",
+        name: "sourceDir",
+        message: "Source directory:",
+        default: "./src"
+      }
+    ]);
+    const config = {
+      locales: answers.locales,
+      defaultLocale: answers.defaultLocale,
+      namespaces: answers.namespaces,
+      translationPaths: {},
+      sourcePatterns: [`${answers.sourceDir}/**/*.{ts,tsx,js,jsx}`],
+      outputDir: answers.translationsDir,
+      validation: {
+        strict: false,
+        logMissing: true,
+        throwOnMissing: false,
+        validateFormats: true
+      },
+      extraction: {
+        keyPrefix: "",
+        markExtracted: true,
+        sortKeys: true,
+        includeMetadata: false
+      },
+      sync: {
+        removeUnused: false,
+        addMissing: true,
+        preserveOrder: true
+      }
+    };
+    for (const locale of answers.locales) {
+      config.translationPaths[locale] = {};
+      for (const namespace of answers.namespaces) {
+        config.translationPaths[locale][namespace] = import_path4.default.join(
+          answers.translationsDir,
+          locale,
+          `${namespace}.json`
+        );
+      }
+    }
+    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);
+      await import_fs_extra5.default.ensureDir(localeDir);
+      for (const namespace of answers.namespaces) {
+        const filePath = import_path4.default.join(localeDir, `${namespace}.json`);
+        if (!await import_fs_extra5.default.pathExists(filePath)) {
+          await import_fs_extra5.default.writeJson(filePath, {}, { spaces: 2 });
+        }
+      }
+    }
+    await saveConfig(config, configPath);
+    if (options.template) {
+      await createTemplateFiles(options.template, answers);
+    }
+    spinner.succeed("IntlParty configuration initialized successfully!");
+    console.log(import_chalk4.default.green("\n\u2713 Configuration created:"), configPath);
+    console.log(
+      import_chalk4.default.green("\u2713 Translation directories created:"),
+      answers.translationsDir
+    );
+    if (options.template) {
+      console.log(import_chalk4.default.green("\u2713 Template files created"));
+    }
+    console.log(import_chalk4.default.blue("\nNext steps:"));
+    console.log("1. Add translations to your JSON files");
+    console.log(
+      "2. Run",
+      import_chalk4.default.cyan("intl-party extract"),
+      "to extract keys from your code"
+    );
+    console.log(
+      "3. Run",
+      import_chalk4.default.cyan("intl-party validate"),
+      "to check your translations"
+    );
+  } catch (error) {
+    spinner.fail("Initialization failed");
+    console.error(
+      import_chalk4.default.red("Error:"),
+      error instanceof Error ? error.message : error
+    );
+    process.exit(1);
+  }
+}
+async function createTemplateFiles(template, config) {
+  switch (template) {
+    case "nextjs":
+      await createNextJSTemplate(config);
+      break;
+    case "react":
+      await createReactTemplate(config);
+      break;
+    case "vanilla":
+      await createVanillaTemplate(config);
+      break;
+    default:
+      console.log(import_chalk4.default.yellow(`Unknown template: ${template}`));
+  }
+}
+async function createNextJSTemplate(config) {
+  const middlewareContent = `import { createI18nMiddleware } from '@intl-party/nextjs/middleware';
+
+export default createI18nMiddleware({
+  locales: ${JSON.stringify(config.locales)},
+  defaultLocale: '${config.defaultLocale}',
+  localePrefix: 'as-needed'
+});
+
+export const config = {
+  matcher: [
+    '/((?!api|_next|_vercel|favicon.ico).*)'
+  ]
+};
+`;
+  const layoutContent = `import { AppI18nProvider } from '@intl-party/nextjs/app';
+
+export default function RootLayout({
+  children,
+  params: { locale }
+}: {
+  children: React.ReactNode;
+  params: { locale: string };
+}) {
+  return (
+    <html lang={locale}>
+      <body>
+        <AppI18nProvider locale={locale} config={{
+          locales: ${JSON.stringify(config.locales)},
+          defaultLocale: '${config.defaultLocale}',
+          namespaces: ${JSON.stringify(config.namespaces)}
+        }}>
+          {children}
+        </AppI18nProvider>
+      </body>
+    </html>
+  );
+}
+`;
+  await import_fs_extra5.default.writeFile("middleware.ts", middlewareContent);
+  await import_fs_extra5.default.ensureDir("app/[locale]");
+  await import_fs_extra5.default.writeFile("app/[locale]/layout.tsx", layoutContent);
+}
+async function createReactTemplate(config) {
+  const appContent = `import { I18nProvider } from '@intl-party/react';
+import { createI18n } from '@intl-party/core';
+
+const i18n = createI18n({
+  locales: ${JSON.stringify(config.locales)},
+  defaultLocale: '${config.defaultLocale}',
+  namespaces: ${JSON.stringify(config.namespaces)}
+});
+
+function App() {
+  return (
+    <I18nProvider i18n={i18n}>
+      <div className="App">
+        <h1>IntlParty React App</h1>
+        {/* Your app content */}
+      </div>
+    </I18nProvider>
+  );
+}
+
+export default App;
+`;
+  await import_fs_extra5.default.writeFile("src/App.tsx", appContent);
+}
+async function createVanillaTemplate(config) {
+  const indexContent = `import { createI18n } from '@intl-party/core';
+
+const i18n = createI18n({
+  locales: ${JSON.stringify(config.locales)},
+  defaultLocale: '${config.defaultLocale}',
+  namespaces: ${JSON.stringify(config.namespaces)}
+});
+
+// Load translations
+// Add your translation loading logic here
+
+// Use translations
+console.log(i18n.t('welcome'));
+`;
+  await import_fs_extra5.default.ensureDir("src");
+  await import_fs_extra5.default.writeFile("src/index.ts", indexContent);
+}
+
+// src/commands/check.ts
+var import_chalk5 = __toESM(require("chalk"));
+var import_ora4 = __toESM(require("ora"));
+var import_core2 = require("@intl-party/core");
+async function checkCommand(options) {
+  const spinner = (0, import_ora4.default)("Loading configuration...").start();
+  try {
+    const config = await loadConfig(options.config);
+    spinner.succeed("Configuration loaded");
+    spinner.start("Loading translations...");
+    const translations = await loadTranslations(
+      config.translationPaths,
+      config.locales,
+      config.namespaces
+    );
+    spinner.succeed("Translations loaded");
+    const issues = [];
+    if (options.missing !== false) {
+      spinner.start("Checking for missing translations...");
+      const validationResult = (0, import_core2.validateTranslations)(
+        translations,
+        config.locales,
+        config.namespaces,
+        { strict: true }
+      );
+      validationResult.errors.forEach((error) => {
+        if (error.type === "missing_key" || error.type === "missing_namespace") {
+          issues.push({
+            type: "missing",
+            severity: "error",
+            message: error.message,
+            locale: error.locale,
+            namespace: error.namespace,
+            key: error.key
+          });
+        }
+      });
+      spinner.succeed(
+        `Missing translations check completed (${issues.length} issues found)`
+      );
+    }
+    if (options.formatErrors !== false) {
+      spinner.start("Checking for format errors...");
+      const validationResult = (0, import_core2.validateTranslations)(
+        translations,
+        config.locales,
+        config.namespaces,
+        { validateFormats: true }
+      );
+      validationResult.errors.forEach((error) => {
+        if (error.type === "invalid_format") {
+          issues.push({
+            type: "format",
+            severity: "error",
+            message: error.message,
+            locale: error.locale,
+            namespace: error.namespace,
+            key: error.key
+          });
+        }
+      });
+      spinner.succeed("Format errors check completed");
+    }
+    if (options.unused) {
+      spinner.start("Checking for unused keys...");
+      spinner.succeed("Unused keys check completed");
+    }
+    if (options.duplicates) {
+      spinner.start("Checking for duplicate keys...");
+      spinner.succeed("Duplicate keys check completed");
+    }
+    if (issues.length === 0) {
+      console.log(import_chalk5.default.green("\u2713 No issues found!"));
+      return;
+    }
+    console.log(import_chalk5.default.red(`
+\u2717 Found ${issues.length} issue(s):
+`));
+    const groupedIssues = issues.reduce(
+      (acc, issue) => {
+        if (!acc[issue.type]) {
+          acc[issue.type] = [];
+        }
+        acc[issue.type].push(issue);
+        return acc;
+      },
+      {}
+    );
+    for (const [type, typeIssues] of Object.entries(groupedIssues)) {
+      console.log(
+        import_chalk5.default.bold(`${type.toUpperCase()} ISSUES (${typeIssues.length}):`)
+      );
+      typeIssues.forEach((issue, index) => {
+        const icon = issue.severity === "error" ? import_chalk5.default.red("\u2717") : import_chalk5.default.yellow("\u26A0");
+        const location = issue.locale && issue.namespace ? import_chalk5.default.gray(
+          `[${issue.locale}/${issue.namespace}${issue.key ? `/${issue.key}` : ""}]`
+        ) : "";
+        console.log(`  ${index + 1}. ${icon} ${issue.message} ${location}`);
+      });
+      console.log();
+    }
+    if (options.fix) {
+      spinner.start("Attempting to fix issues...");
+      let fixedCount = 0;
+      if (fixedCount > 0) {
+        spinner.succeed(`Fixed ${fixedCount} issue(s)`);
+      } else {
+        spinner.info("No issues could be automatically fixed");
+      }
+    }
+    const errorCount = issues.filter(
+      (issue) => issue.severity === "error"
+    ).length;
+    if (errorCount > 0) {
+      process.exit(1);
+    }
+  } catch (error) {
+    spinner.fail("Check failed");
+    console.error(
+      import_chalk5.default.red("Error:"),
+      error instanceof Error ? error.message : error
+    );
+    process.exit(1);
+  }
+}
+
+// src/commands/generate.ts
+var import_chalk6 = __toESM(require("chalk"));
+async function generateCommand(options) {
+  console.log(import_chalk6.default.blue("Generate command not yet implemented"));
+  console.log("Options:", options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkCommand,
+  extractCommand,
+  generateCommand,
+  initCommand,
+  loadConfig,
+  loadTranslations,
+  saveConfig,
+  saveTranslations,
+  syncCommand,
+  validateCommand
+});