i18n-ai-cli 1.0.0

package/dist/cli.js

@@ -0,0 +1,1013 @@
+#!/usr/bin/env node
+
+// src/bin/cli.ts
+import { Command } from "commander";
+import chalk8 from "chalk";
+
+// src/config/config-loader.ts
+import fs from "fs-extra";
+import path from "path";
+import { z } from "zod";
+var CONFIG_FILE_NAME = "i18n-cli.config.json";
+var ConfigSchema = z.object({
+  localesPath: z.string().min(1),
+  defaultLocale: z.string().min(2),
+  supportedLocales: z.array(z.string().min(2)),
+  keyStyle: z.enum(["flat", "nested"]).default("nested"),
+  usagePatterns: z.array(z.string()).default([]),
+  autoSort: z.boolean().default(true)
+});
+function resolveConfigPath() {
+  const cwd = process.cwd();
+  return path.join(cwd, CONFIG_FILE_NAME);
+}
+async function loadConfig() {
+  const configPath = resolveConfigPath();
+  if (!await fs.pathExists(configPath)) {
+    throw new Error(
+      `Configuration file "${CONFIG_FILE_NAME}" not found in project root.
+Run "i18n-cli init" to create one.`
+    );
+  }
+  let rawConfig;
+  try {
+    rawConfig = await fs.readJson(configPath);
+  } catch (err) {
+    throw new Error(
+      `Failed to parse ${CONFIG_FILE_NAME}. Ensure it contains valid JSON.`
+    );
+  }
+  const parsed = ConfigSchema.safeParse(rawConfig);
+  if (!parsed.success) {
+    const errors = parsed.error.issues.map((e) => `\u2022 ${e.path.join(".")}: ${e.message}`).join("\n");
+    throw new Error(
+      `Invalid configuration in ${CONFIG_FILE_NAME}:
+${errors}`
+    );
+  }
+  const config = parsed.data;
+  validateConfigLogic(config);
+  const compiledUsagePatterns = compileUsagePatterns(
+    config.usagePatterns
+  );
+  return {
+    ...config,
+    compiledUsagePatterns
+  };
+}
+function validateConfigLogic(config) {
+  if (!config.supportedLocales.includes(config.defaultLocale)) {
+    throw new Error(
+      `defaultLocale "${config.defaultLocale}" must be included in supportedLocales.`
+    );
+  }
+  const duplicates = findDuplicates(config.supportedLocales);
+  if (duplicates.length > 0) {
+    throw new Error(
+      `Duplicate locales found in supportedLocales: ${duplicates.join(", ")}`
+    );
+  }
+}
+function compileUsagePatterns(patterns) {
+  if (patterns.length === 0) {
+    return [];
+  }
+  return patterns.map((pattern, index) => {
+    let regex;
+    try {
+      regex = new RegExp(pattern, "g");
+    } catch (err) {
+      throw new Error(
+        `Invalid regex in usagePatterns[${index}]: ${String(err)}`
+      );
+    }
+    const groupCount = countCapturingGroups(pattern);
+    if (groupCount === 0) {
+      throw new Error(
+        `usagePatterns[${index}] must include a capturing group (use a named group like "(?<key>...)" or a standard "(...)").`
+      );
+    }
+    return regex;
+  });
+}
+function countCapturingGroups(pattern) {
+  let count = 0;
+  let inCharClass = false;
+  for (let i = 0; i < pattern.length; i++) {
+    const char = pattern[i];
+    if (char === "\\") {
+      i += 1;
+      continue;
+    }
+    if (char === "[") {
+      inCharClass = true;
+      continue;
+    }
+    if (char === "]" && inCharClass) {
+      inCharClass = false;
+      continue;
+    }
+    if (inCharClass) {
+      continue;
+    }
+    if (char !== "(") {
+      continue;
+    }
+    const next = pattern[i + 1];
+    if (next !== "?") {
+      count += 1;
+      continue;
+    }
+    const next2 = pattern[i + 2];
+    if (next2 !== "<") {
+      continue;
+    }
+    const next3 = pattern[i + 3];
+    if (next3 === "=" || next3 === "!") {
+      continue;
+    }
+    count += 1;
+  }
+  return count;
+}
+function findDuplicates(arr) {
+  const seen = /* @__PURE__ */ new Set();
+  const duplicates = [];
+  for (const item of arr) {
+    if (seen.has(item)) {
+      duplicates.push(item);
+    }
+    seen.add(item);
+  }
+  return duplicates;
+}
+
+// src/core/file-manager.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+var FileManager = class {
+  localesPath;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.localesPath = path2.resolve(process.cwd(), config.localesPath);
+  }
+  getLocaleFilePath(locale) {
+    return path2.join(this.localesPath, `${locale}.json`);
+  }
+  async ensureLocalesDirectory() {
+    await fs2.ensureDir(this.localesPath);
+  }
+  async localeExists(locale) {
+    const filePath = this.getLocaleFilePath(locale);
+    return fs2.pathExists(filePath);
+  }
+  async listLocales() {
+    return this.config.supportedLocales;
+  }
+  async readLocale(locale) {
+    const filePath = this.getLocaleFilePath(locale);
+    if (!await fs2.pathExists(filePath)) {
+      throw new Error(`Locale file "${locale}.json" does not exist.`);
+    }
+    try {
+      return await fs2.readJson(filePath);
+    } catch {
+      throw new Error(`Invalid JSON in "${locale}.json".`);
+    }
+  }
+  async writeLocale(locale, data, options) {
+    const filePath = this.getLocaleFilePath(locale);
+    const finalData = this.config.autoSort ? this.sortKeysRecursively(data) : data;
+    if (options?.dryRun) {
+      return;
+    }
+    await fs2.writeJson(filePath, finalData, { spaces: 2 });
+  }
+  async deleteLocale(locale, options) {
+    const filePath = this.getLocaleFilePath(locale);
+    if (!await fs2.pathExists(filePath)) {
+      throw new Error(`Locale "${locale}" does not exist.`);
+    }
+    if (options?.dryRun) {
+      return;
+    }
+    await fs2.remove(filePath);
+  }
+  async createLocale(locale, initialData, options) {
+    await this.ensureLocalesDirectory();
+    const filePath = this.getLocaleFilePath(locale);
+    if (await fs2.pathExists(filePath)) {
+      throw new Error(`Locale "${locale}" already exists.`);
+    }
+    if (options?.dryRun) {
+      return;
+    }
+    await fs2.writeJson(filePath, initialData, { spaces: 2 });
+  }
+  sortKeysRecursively(obj) {
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this.sortKeysRecursively(item));
+    }
+    if (obj !== null && typeof obj === "object") {
+      return Object.keys(obj).sort().reduce((acc, key) => {
+        acc[key] = this.sortKeysRecursively(obj[key]);
+        return acc;
+      }, /* @__PURE__ */ Object.create(null));
+    }
+    return obj;
+  }
+};
+
+// src/context/build-context.ts
+async function buildContext(options) {
+  const config = await loadConfig();
+  const fileManager = new FileManager(config);
+  return {
+    config,
+    fileManager,
+    options
+  };
+}
+
+// src/commands/init.ts
+import chalk from "chalk";
+import fs3 from "fs-extra";
+import inquirer2 from "inquirer";
+import path3 from "path";
+
+// src/core/confirmation.ts
+import inquirer from "inquirer";
+async function confirmAction(message, options = {}) {
+  const { skip = false, defaultValue = false, ci = false } = options;
+  if (skip) {
+    return true;
+  }
+  if (ci) {
+    throw new Error(
+      "Confirmation required in CI mode. Re-run with --yes to proceed."
+    );
+  }
+  if (!process.stdout.isTTY) {
+    return defaultValue;
+  }
+  const { confirmed } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "confirmed",
+      message,
+      default: defaultValue
+    }
+  ]);
+  return confirmed;
+}
+
+// src/commands/init.ts
+var DEFAULT_USAGE_PATTERNS = [
+  `t\\(['"](.*?)['"]\\)`,
+  `translate\\(['"](.*?)['"]\\)`,
+  `i18n\\.t\\(['"](.*?)['"]\\)`
+];
+async function initCommand(options) {
+  const { yes, dryRun, ci, force } = options;
+  const configPath = path3.join(process.cwd(), CONFIG_FILE_NAME);
+  const configExists = await fs3.pathExists(configPath);
+  if (configExists && !force) {
+    throw new Error(
+      `Configuration file "${CONFIG_FILE_NAME}" already exists. Use --force to overwrite.`
+    );
+  }
+  const canPrompt = process.stdout.isTTY && !yes && !ci;
+  let config;
+  if (canPrompt) {
+    const answers = await inquirer2.prompt([
+      {
+        type: "input",
+        name: "localesPath",
+        message: "Locales directory",
+        default: "./locales",
+        validate: (input) => input.trim().length > 0 || "Please provide a locales path."
+      },
+      {
+        type: "input",
+        name: "defaultLocale",
+        message: "Default locale",
+        default: "en",
+        validate: (input) => input.trim().length >= 2 || "Default locale must be at least 2 characters."
+      },
+      {
+        type: "input",
+        name: "supportedLocales",
+        message: "Supported locales (comma-separated)",
+        default: (answers2) => answers2.defaultLocale
+      },
+      {
+        type: "list",
+        name: "keyStyle",
+        message: "Key style",
+        choices: ["nested", "flat"],
+        default: "nested"
+      },
+      {
+        type: "confirm",
+        name: "autoSort",
+        message: "Auto-sort keys?",
+        default: true
+      },
+      {
+        type: "confirm",
+        name: "useDefaultUsagePatterns",
+        message: "Use default usagePatterns?",
+        default: true
+      }
+    ]);
+    let usagePatterns = DEFAULT_USAGE_PATTERNS;
+    if (!answers.useDefaultUsagePatterns) {
+      usagePatterns = [];
+      let addMore = true;
+      while (addMore) {
+        const { pattern } = await inquirer2.prompt([
+          {
+            type: "input",
+            name: "pattern",
+            message: "Add usage pattern (regex)",
+            validate: (input) => input.trim().length > 0 || "Pattern cannot be empty."
+          }
+        ]);
+        usagePatterns.push(pattern.trim());
+        const { again } = await inquirer2.prompt([
+          {
+            type: "confirm",
+            name: "again",
+            message: "Add another pattern?",
+            default: false
+          }
+        ]);
+        addMore = again;
+      }
+    }
+    const supportedLocales = parseLocales(
+      answers.supportedLocales
+    );
+    config = {
+      localesPath: answers.localesPath.trim(),
+      defaultLocale: answers.defaultLocale.trim(),
+      supportedLocales,
+      keyStyle: answers.keyStyle,
+      usagePatterns,
+      autoSort: answers.autoSort
+    };
+  } else {
+    config = {
+      localesPath: "./locales",
+      defaultLocale: "en",
+      supportedLocales: ["en"],
+      keyStyle: "nested",
+      usagePatterns: DEFAULT_USAGE_PATTERNS,
+      autoSort: true
+    };
+  }
+  config.supportedLocales = normalizeLocales(
+    config.supportedLocales,
+    config.defaultLocale
+  );
+  compileUsagePatterns(config.usagePatterns);
+  if (ci && !yes) {
+    const action = configExists ? "overwritten" : "created";
+    throw new Error(
+      `CI mode: configuration file would be ${action}. Re-run with --yes to apply.`
+    );
+  }
+  if (configExists && !yes) {
+    const confirmed = await confirmAction(
+      `This will overwrite "${CONFIG_FILE_NAME}". Continue?`,
+      { skip: false, ci: ci ?? false }
+    );
+    if (!confirmed) {
+      console.log(chalk.red("\nOperation cancelled."));
+      return;
+    }
+  }
+  if (dryRun) {
+    console.log(chalk.yellow("\n[DRY RUN] Configuration not written."));
+    return;
+  }
+  await fs3.writeJson(configPath, config, { spaces: 2 });
+  await maybeInitLocales(config, { dryRun: false });
+  console.log(
+    chalk.green(`
+\u2714 Created ${CONFIG_FILE_NAME} successfully.`)
+  );
+}
+function parseLocales(input) {
+  return input.split(",").map((locale) => locale.trim()).filter(Boolean);
+}
+function normalizeLocales(locales, defaultLocale) {
+  const unique = /* @__PURE__ */ new Set();
+  for (const locale of locales) {
+    if (locale.length > 0) {
+      unique.add(locale);
+    }
+  }
+  if (!unique.has(defaultLocale)) {
+    unique.add(defaultLocale);
+  }
+  return Array.from(unique);
+}
+async function maybeInitLocales(config, options) {
+  const localesPath = path3.resolve(
+    process.cwd(),
+    config.localesPath
+  );
+  if (options.dryRun) {
+    return;
+  }
+  await fs3.ensureDir(localesPath);
+  const defaultLocaleFile = path3.join(
+    localesPath,
+    `${config.defaultLocale}.json`
+  );
+  if (await fs3.pathExists(defaultLocaleFile)) {
+    return;
+  }
+  await fs3.writeJson(defaultLocaleFile, {}, { spaces: 2 });
+}
+
+// src/commands/add-lang.ts
+import chalk2 from "chalk";
+import ISO6391 from "iso-639-1";
+function isValidLocale(code) {
+  const parts = code.split("-");
+  if (parts.length === 1) {
+    return ISO6391.validate(parts[0]);
+  }
+  if (parts.length === 2) {
+    return ISO6391.validate(parts[0]);
+  }
+  return false;
+}
+async function addLang(lang, options, context) {
+  const { config, fileManager } = context;
+  const { yes, dryRun, ci } = context.options;
+  const locale = lang.trim();
+  if (!isValidLocale(locale)) {
+    throw new Error(`Invalid language code: ${locale}`);
+  }
+  if (config.supportedLocales.includes(locale)) {
+    throw new Error(`Language ${locale} already exists`);
+  }
+  const exists = await fileManager.localeExists(locale);
+  if (exists) {
+    throw new Error(`File already exists: ${locale}.json`);
+  }
+  let baseContent = {};
+  if (options.from) {
+    const baseLocale = options.from;
+    if (!config.supportedLocales.includes(baseLocale)) {
+      throw new Error(`Base locale ${baseLocale} does not exist`);
+    }
+    baseContent = await fileManager.readLocale(baseLocale);
+  }
+  console.log(chalk2.cyan(`
+Preparing to add locale:`));
+  console.log(chalk2.yellow(`  ${locale}
+`));
+  if (ci && !yes) {
+    throw new Error(
+      `CI mode: locale "${locale}" would be created. Re-run with --yes to apply.`
+    );
+  }
+  const confirmed = await confirmAction(
+    `This will create new locale "${locale}". Continue?`,
+    { skip: yes ?? false, ci: ci ?? false }
+  );
+  if (!confirmed) {
+    console.log(chalk2.red("\nOperation cancelled."));
+    return;
+  }
+  await fileManager.createLocale(locale, baseContent, { dryRun: dryRun ?? false });
+  if (dryRun) {
+    console.log(
+      chalk2.yellow("\n[DRY RUN] No files were modified.")
+    );
+  } else {
+    console.log(
+      chalk2.green(`
+\u2714 Locale "${locale}" created successfully.`)
+    );
+    console.log(
+      chalk2.gray(
+        `Note: Add "${locale}" to supportedLocales in config manually.`
+      )
+    );
+  }
+}
+
+// src/commands/remove-lang.ts
+import chalk3 from "chalk";
+async function removeLangCommand(context, lang) {
+  const { config, fileManager, options } = context;
+  const { yes, dryRun, ci } = options;
+  const locale = lang.trim();
+  if (!config.supportedLocales.includes(locale)) {
+    throw new Error(
+      `Locale "${locale}" is not in supportedLocales.`
+    );
+  }
+  if (locale === config.defaultLocale) {
+    throw new Error(
+      `Cannot remove default locale "${locale}". Change defaultLocale first.`
+    );
+  }
+  const exists = await fileManager.localeExists(locale);
+  if (!exists) {
+    throw new Error(
+      `Locale file "${locale}.json" does not exist.`
+    );
+  }
+  console.log(chalk3.cyan(`
+Preparing to remove locale:`));
+  console.log(chalk3.yellow(`  ${locale}
+`));
+  if (ci && !yes) {
+    throw new Error(
+      `CI mode: locale "${locale}" would be removed. Re-run with --yes to apply.`
+    );
+  }
+  const confirmed = await confirmAction(
+    `This will permanently delete "${locale}.json". Continue?`,
+    { skip: yes ?? false, ci: ci ?? false }
+  );
+  if (!confirmed) {
+    console.log(chalk3.red("\nOperation cancelled."));
+    return;
+  }
+  await fileManager.deleteLocale(locale, { dryRun: dryRun ?? false });
+  if (dryRun) {
+    console.log(
+      chalk3.yellow("\n[DRY RUN] No files were modified.")
+    );
+  } else {
+    console.log(
+      chalk3.green(`
+\u2714 Locale "${locale}" removed successfully.`)
+    );
+    console.log(
+      chalk3.gray(
+        `Note: Remove "${locale}" from supportedLocales in config manually.`
+      )
+    );
+  }
+}
+
+// src/commands/add-key.ts
+import chalk4 from "chalk";
+
+// src/core/object-utils.ts
+var DANGEROUS_KEY_SEGMENTS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+function assertSafeKeySegment(segment) {
+  if (DANGEROUS_KEY_SEGMENTS.has(segment)) {
+    throw new Error(
+      `Unsafe key segment "${segment}" is not allowed.`
+    );
+  }
+}
+function flattenObject(obj, parentKey = "", result = /* @__PURE__ */ Object.create(null)) {
+  for (const key of Object.keys(obj)) {
+    assertSafeKeySegment(key);
+    const value = obj[key];
+    const newKey = parentKey ? `${parentKey}.${key}` : key;
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      flattenObject(value, newKey, result);
+    } else {
+      result[newKey] = value;
+    }
+  }
+  return result;
+}
+function unflattenObject(flatObj) {
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const flatKey of Object.keys(flatObj)) {
+    const keys = flatKey.split(".");
+    let current = result;
+    keys.forEach((key, index) => {
+      assertSafeKeySegment(key);
+      const isLast = index === keys.length - 1;
+      if (isLast) {
+        current[key] = flatObj[flatKey];
+      } else {
+        if (!current[key] || typeof current[key] !== "object") {
+          current[key] = /* @__PURE__ */ Object.create(null);
+        }
+        current = current[key];
+      }
+    });
+  }
+  return result;
+}
+function removeEmptyObjects(obj) {
+  if (Array.isArray(obj)) {
+    return obj;
+  }
+  if (obj !== null && typeof obj === "object") {
+    const cleaned = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.keys(obj)) {
+      assertSafeKeySegment(key);
+      const value = removeEmptyObjects(obj[key]);
+      if (value !== void 0 && (typeof value !== "object" || Object.keys(value).length > 0)) {
+        cleaned[key] = value;
+      }
+    }
+    return cleaned;
+  }
+  return obj;
+}
+
+// src/core/key-validator.ts
+function validateNoStructuralConflict(flatObject, newKey) {
+  const parts = newKey.split(".");
+  for (let i = 1; i < parts.length; i++) {
+    const parentPath = parts.slice(0, i).join(".");
+    if (flatObject[parentPath] !== void 0) {
+      throw new Error(
+        `Structural conflict detected:
+
+Cannot create key "${newKey}" because "${parentPath}" is already defined as a non-object value.
+
+Resolve conflict before proceeding.`
+      );
+    }
+  }
+  const prefix = `${newKey}.`;
+  for (const existingKey of Object.keys(flatObject)) {
+    if (existingKey.startsWith(prefix)) {
+      throw new Error(
+        `Structural conflict detected:
+
+Cannot create key "${newKey}" because it would overwrite nested keys like "${existingKey}".
+
+Resolve conflict before proceeding.`
+      );
+    }
+  }
+}
+
+// src/commands/add-key.ts
+async function addKeyCommand(context, key, options) {
+  const { config, fileManager } = context;
+  const { yes, dryRun, ci } = context.options;
+  const value = options.value;
+  if (!key || !value) {
+    throw new Error("Both key and --value are required.");
+  }
+  const locales = config.supportedLocales;
+  console.log(chalk4.cyan(`
+Preparing to add key:`));
+  console.log(chalk4.yellow(`  ${key}
+`));
+  const updatedLocales = [];
+  for (const locale of locales) {
+    const nested = await fileManager.readLocale(locale);
+    const flat = flattenObject(nested);
+    validateNoStructuralConflict(flat, key);
+    if (flat[key] !== void 0) {
+      throw new Error(
+        `Key "${key}" already exists in locale "${locale}". Use update:key instead.`
+      );
+    }
+    updatedLocales.push(locale);
+  }
+  console.log(chalk4.white("This operation will update:"));
+  updatedLocales.forEach(
+    (l) => console.log(chalk4.gray(`  \u2022 ${l}.json`))
+  );
+  if (ci && !yes) {
+    throw new Error(
+      `CI mode: key "${key}" would be added to ${updatedLocales.length} locale(s). Re-run with --yes to apply.`
+    );
+  }
+  const confirmed = await confirmAction(
+    "\nDo you want to continue?",
+    { skip: yes ?? false, ci: ci ?? false }
+  );
+  if (!confirmed) {
+    console.log(chalk4.red("\nOperation cancelled."));
+    return;
+  }
+  for (const locale of locales) {
+    const nested = await fileManager.readLocale(locale);
+    const flat = flattenObject(nested);
+    flat[key] = locale === config.defaultLocale ? value : "";
+    const finalData = config.keyStyle === "nested" ? unflattenObject(flat) : flat;
+    await fileManager.writeLocale(locale, finalData, { dryRun: dryRun ?? false });
+  }
+  if (dryRun) {
+    console.log(
+      chalk4.yellow("\n[DRY RUN] No files were modified.")
+    );
+  } else {
+    updatedLocales.forEach(
+      (l) => console.log(chalk4.green(`\u2714 Updated ${l}.json`))
+    );
+    console.log(
+      chalk4.green("\n\u2728 Key added successfully across all locales.")
+    );
+  }
+}
+
+// src/commands/update-key.ts
+import chalk5 from "chalk";
+async function updateKeyCommand(context, key, options) {
+  const { config, fileManager, options: globalOptions } = context;
+  const { yes, dryRun, ci } = globalOptions;
+  const { value, locale } = options;
+  if (!key || value === void 0) {
+    throw new Error("Both key and --value are required.");
+  }
+  const targetLocale = locale ?? config.defaultLocale;
+  if (!config.supportedLocales.includes(targetLocale)) {
+    throw new Error(
+      `Locale "${targetLocale}" is not defined in configuration.`
+    );
+  }
+  console.log(chalk5.cyan(`
+Preparing to update key:`));
+  console.log(chalk5.yellow(`  ${key}`));
+  console.log(chalk5.gray(`  Locale: ${targetLocale}
+`));
+  const nested = await fileManager.readLocale(targetLocale);
+  const flat = flattenObject(nested);
+  validateNoStructuralConflict(flat, key);
+  if (flat[key] === void 0) {
+    throw new Error(
+      `Key "${key}" does not exist in locale "${targetLocale}".`
+    );
+  }
+  console.log(
+    chalk5.white(
+      `Old value: ${chalk5.gray(JSON.stringify(flat[key]))}`
+    )
+  );
+  console.log(
+    chalk5.white(
+      `New value: ${chalk5.green(JSON.stringify(value))}`
+    )
+  );
+  if (ci && !yes) {
+    throw new Error(
+      `CI mode: key "${key}" in "${targetLocale}" would be updated. Re-run with --yes to apply.`
+    );
+  }
+  const confirmed = await confirmAction(
+    "\nDo you want to continue?",
+    { skip: yes ?? false, ci: ci ?? false }
+  );
+  if (!confirmed) {
+    console.log(chalk5.red("\nOperation cancelled."));
+    return;
+  }
+  flat[key] = value;
+  const rebuilt = config.keyStyle === "nested" ? unflattenObject(flat) : flat;
+  await fileManager.writeLocale(targetLocale, rebuilt, {
+    dryRun: dryRun ?? false
+  });
+  if (dryRun) {
+    console.log(
+      chalk5.yellow("\n[DRY RUN] No files were modified.")
+    );
+  } else {
+    console.log(
+      chalk5.green(
+        `
+\u2714 Successfully updated "${key}" in ${targetLocale}.json`
+      )
+    );
+  }
+}
+
+// src/commands/remove-key.ts
+import chalk6 from "chalk";
+async function removeKeyCommand(context, key) {
+  const { config, fileManager, options } = context;
+  const { yes, dryRun, ci } = options;
+  if (!key) {
+    throw new Error("Key is required.");
+  }
+  const locales = config.supportedLocales;
+  console.log(chalk6.cyan(`
+Preparing to remove key:`));
+  console.log(chalk6.yellow(`  ${key}
+`));
+  const localesContainingKey = [];
+  for (const locale of locales) {
+    const nested = await fileManager.readLocale(locale);
+    const flat = flattenObject(nested);
+    if (flat[key] !== void 0) {
+      localesContainingKey.push(locale);
+    }
+  }
+  if (localesContainingKey.length === 0) {
+    throw new Error(
+      `Key "${key}" does not exist in any locale.`
+    );
+  }
+  console.log(chalk6.white("This operation will update:"));
+  localesContainingKey.forEach(
+    (l) => console.log(chalk6.gray(`  \u2022 ${l}.json`))
+  );
+  if (ci && !yes) {
+    throw new Error(
+      `CI mode: key "${key}" would be removed from ${localesContainingKey.length} locale(s). Re-run with --yes to apply.`
+    );
+  }
+  const confirmed = await confirmAction(
+    "\nThis will remove the key from ALL locales. Continue?",
+    yes !== void 0 ? { skip: yes, ci: ci ?? false } : { ci: ci ?? false }
+  );
+  if (!confirmed) {
+    console.log(chalk6.red("\nOperation cancelled."));
+    return;
+  }
+  for (const locale of locales) {
+    const nested = await fileManager.readLocale(locale);
+    const flat = flattenObject(nested);
+    if (flat[key] !== void 0) {
+      delete flat[key];
+    }
+    const rebuilt = config.keyStyle === "nested" ? removeEmptyObjects(unflattenObject(flat)) : flat;
+    await fileManager.writeLocale(locale, rebuilt, dryRun !== void 0 ? { dryRun } : void 0);
+  }
+  if (dryRun) {
+    console.log(
+      chalk6.yellow("\n[DRY RUN] No files were modified.")
+    );
+  } else {
+    localesContainingKey.forEach(
+      (l) => console.log(chalk6.green(`\u2714 Updated ${l}.json`))
+    );
+    console.log(
+      chalk6.green("\n\u2728 Key removed successfully from all locales.")
+    );
+  }
+}
+
+// src/commands/clean-unused.ts
+import fs4 from "fs-extra";
+import { glob } from "glob";
+import chalk7 from "chalk";
+async function cleanUnusedCommand(context) {
+  const { config, fileManager, options } = context;
+  const { dryRun, yes, ci } = options;
+  console.log(chalk7.cyan("\nScanning project for translation usage...\n"));
+  const patterns = config.compiledUsagePatterns;
+  if (!patterns || patterns.length === 0) {
+    throw new Error(
+      "No usagePatterns defined in config."
+    );
+  }
+  const files = await glob("src/**/*.{ts,tsx,js,jsx,html}");
+  const usedKeys = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const content = await fs4.readFile(file, "utf8");
+    for (const regex of patterns) {
+      regex.lastIndex = 0;
+      let match;
+      while (match = regex.exec(content)) {
+        const key = match.groups?.key ?? match[1];
+        if (key) {
+          usedKeys.add(key);
+        }
+      }
+    }
+  }
+  console.log(
+    chalk7.gray(`Found ${usedKeys.size} used keys in project
+`)
+  );
+  const defaultLocale = config.defaultLocale;
+  const nested = await fileManager.readLocale(defaultLocale);
+  const flat = flattenObject(nested);
+  const localeKeys = Object.keys(flat);
+  const unusedKeys = localeKeys.filter(
+    (key) => !usedKeys.has(key)
+  );
+  if (unusedKeys.length === 0) {
+    console.log(
+      chalk7.green("\u2714 No unused translation keys found.\n")
+    );
+    return;
+  }
+  console.log(
+    chalk7.yellow(`Unused keys (${unusedKeys.length}):`)
+  );
+  unusedKeys.slice(0, 20).forEach(
+    (key) => console.log(`  - ${key}`)
+  );
+  if (unusedKeys.length > 20) {
+    console.log(
+      chalk7.gray(
+        `... and ${unusedKeys.length - 20} more`
+      )
+    );
+  }
+  console.log("");
+  if (ci && !yes) {
+    throw new Error(
+      `CI mode: ${unusedKeys.length} unused key(s) would be removed. Re-run with --yes to apply.`
+    );
+  }
+  const confirmed = await confirmAction(
+    `This will remove ${unusedKeys.length} keys from ALL locales. Continue?`,
+    { skip: yes ?? false, ci: ci ?? false }
+  );
+  if (!confirmed) {
+    console.log(chalk7.red("\nOperation cancelled.\n"));
+    return;
+  }
+  const locales = config.supportedLocales;
+  for (const locale of locales) {
+    const nestedLocale = await fileManager.readLocale(locale);
+    const flatLocale = flattenObject(nestedLocale);
+    for (const key of unusedKeys) {
+      delete flatLocale[key];
+    }
+    const rebuilt = config.keyStyle === "nested" ? unflattenObject(flatLocale) : flatLocale;
+    await fileManager.writeLocale(locale, rebuilt, {
+      dryRun: dryRun ?? false
+    });
+    console.log(chalk7.green(`\u2714 Updated ${locale}.json`));
+  }
+  if (dryRun) {
+    console.log(
+      chalk7.yellow("\n[DRY RUN] No files were modified.\n")
+    );
+  } else {
+    console.log(
+      chalk7.green(
+        `
+\u2728 Removed ${unusedKeys.length} unused keys from all locales.
+`
+      )
+    );
+  }
+}
+
+// src/bin/cli.ts
+var program = new Command();
+program.name("i18n-ai-cli").description("Professional CLI tool for managing translation files").version("1.0.0");
+function withGlobalOptions(command) {
+  return command.option("-y, --yes", "Skip confirmation prompts").option("--dry-run", "Preview changes without writing files").option("--ci", "Run in CI mode (no prompts, exit on issues)").option("-f, --force", "Force operation even if validation fails");
+}
+withGlobalOptions(
+  program.command("init").description("Create an i18n-cli configuration file").action(async (options) => {
+    await initCommand(options);
+  })
+);
+withGlobalOptions(
+  program.command("add:lang <lang>").option("--from <locale>", "Clone from existing locale").option("--strict", "Enable strict mode").description("Add new language locale").action(async (lang, options) => {
+    const context = await buildContext(options);
+    await addLang(lang, options, context);
+  })
+);
+withGlobalOptions(
+  program.command("remove:lang").argument("<lang>", "Language code to remove").description("Remove a language translation file").action(async (lang, options) => {
+    const context = await buildContext(options);
+    await removeLangCommand(context, lang);
+  })
+);
+withGlobalOptions(
+  program.command("add:key").argument("<key>", "Translation key (e.g., auth.login.title)").requiredOption("-v, --value <value>", "Value for default locale").description("Add new translation key to all locales").action(async (key, options) => {
+    const context = await buildContext(options);
+    await addKeyCommand(context, key, options);
+  })
+);
+withGlobalOptions(
+  program.command("update:key").argument("<key>", "Translation key").requiredOption("-v, --value <value>", "New value").option("-l, --locale <locale>", "Specific locale to update").description("Update translation key").action(async (key, options) => {
+    const context = await buildContext(options);
+    await updateKeyCommand(context, key, options);
+  })
+);
+withGlobalOptions(
+  program.command("remove:key").argument("<key>", "Translation key to remove").description("Remove translation key from all locales").action(async (key, options) => {
+    const context = await buildContext(options);
+    await removeKeyCommand(context, key);
+  })
+);
+withGlobalOptions(
+  program.command("clean:unused").description("Remove unused translation keys from all locales").action(async (options) => {
+    const context = await buildContext(options);
+    await cleanUnusedCommand(context);
+  })
+);
+program.exitOverride();
+try {
+  await program.parseAsync(process.argv);
+} catch (err) {
+  console.error(chalk8.red("\u274C Error:"), err.message);
+  process.exitCode = 1;
+}
+//# sourceMappingURL=cli.js.map