@scoutello/i18n-magic 0.15.2 → 0.18.0

package/dist/i18n-magic.esm.js

@@ -1,11 +1,9 @@
-import { Command } from 'commander';
-import dotenv from 'dotenv';
-import OpenAI from 'openai';
 import glob from 'fast-glob';
 import { Parser } from 'i18next-scanner';
 import fs from 'node:fs';
 import path from 'node:path';
 import prompts from 'prompts';
+import console$1 from 'console';
 
 function _construct(t, e, r) {
   if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
@@ -965,6 +963,403 @@ var checkMissing = /*#__PURE__*/function () {
   };
 }();
 
+var removeUnusedKeys = /*#__PURE__*/function () {
+  var _ref = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(config) {
+    var globPatterns, namespaces, defaultNamespace, locales, loadPath, savePath, parser, files, extractedKeys, _iterator, _step, file, content, uniqueExtractedKeys, stats, _iterator2, _step2, namespace, usedKeysSet, _iterator3, _step3, key, pureKey, _iterator4, _step4, locale, existingKeys, existingKeysCount, cleanedKeys, removedCount, _i, _Object$entries, _Object$entries$_i, _key, value;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          globPatterns = config.globPatterns, namespaces = config.namespaces, defaultNamespace = config.defaultNamespace, locales = config.locales, loadPath = config.loadPath, savePath = config.savePath; // Set up the parser
+          parser = new Parser({
+            nsSeparator: false,
+            keySeparator: false
+          }); // Find all files to scan
+          _context.next = 4;
+          return glob([].concat(globPatterns, ["!**/node_modules/**"]));
+        case 4:
+          files = _context.sent;
+          // Extract all translation keys from the codebase
+          extractedKeys = [];
+          for (_iterator = _createForOfIteratorHelperLoose(files); !(_step = _iterator()).done;) {
+            file = _step.value;
+            content = fs.readFileSync(file, "utf-8");
+            parser.parseFuncFromString(content, {
+              list: ["t"]
+            }, function (key) {
+              extractedKeys.push(key);
+            });
+          }
+          // Remove duplicates
+          uniqueExtractedKeys = removeDuplicatesFromArray(extractedKeys); // Track stats for reporting
+          stats = {
+            total: 0,
+            removed: 0
+          }; // Process each namespace and locale
+          _iterator2 = _createForOfIteratorHelperLoose(namespaces);
+        case 10:
+          if ((_step2 = _iterator2()).done) {
+            _context.next = 37;
+            break;
+          }
+          namespace = _step2.value;
+          // Build a set of pure keys that are actually used in the codebase for this namespace
+          usedKeysSet = new Set();
+          for (_iterator3 = _createForOfIteratorHelperLoose(uniqueExtractedKeys); !(_step3 = _iterator3()).done;) {
+            key = _step3.value;
+            pureKey = getPureKey(key, namespace, namespace === defaultNamespace);
+            if (pureKey) {
+              usedKeysSet.add(pureKey);
+            }
+          }
+          // Process each locale
+          _iterator4 = _createForOfIteratorHelperLoose(locales);
+        case 15:
+          if ((_step4 = _iterator4()).done) {
+            _context.next = 35;
+            break;
+          }
+          locale = _step4.value;
+          _context.next = 19;
+          return loadLocalesFile(loadPath, locale, namespace);
+        case 19:
+          existingKeys = _context.sent;
+          existingKeysCount = Object.keys(existingKeys).length;
+          stats.total += existingKeysCount;
+          // Create a new object with only the keys that are used
+          cleanedKeys = {};
+          removedCount = 0;
+          for (_i = 0, _Object$entries = Object.entries(existingKeys); _i < _Object$entries.length; _i++) {
+            _Object$entries$_i = _Object$entries[_i], _key = _Object$entries$_i[0], value = _Object$entries$_i[1];
+            if (usedKeysSet.has(_key)) {
+              cleanedKeys[_key] = value;
+            } else {
+              removedCount++;
+            }
+          }
+          stats.removed += removedCount;
+          // Only write the file if keys were removed
+          if (!(removedCount > 0)) {
+            _context.next = 32;
+            break;
+          }
+          _context.next = 29;
+          return writeLocalesFile(savePath, locale, namespace, cleanedKeys);
+        case 29:
+          console.log("\u2713 Removed " + removedCount + " unused keys from " + locale + ":" + namespace + " (" + Object.keys(cleanedKeys).length + " keys remaining)");
+          _context.next = 33;
+          break;
+        case 32:
+          console.log("No unused keys found in " + locale + ":" + namespace);
+        case 33:
+          _context.next = 15;
+          break;
+        case 35:
+          _context.next = 10;
+          break;
+        case 37:
+          if (stats.removed > 0) {
+            console.log("\u2705 Removed " + stats.removed + " unused keys (out of " + stats.total + " total keys)");
+          } else {
+            console.log("\u2705 No unused keys found in the project (" + stats.total + " total keys)");
+          }
+        case 38:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function removeUnusedKeys(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+var createPrunedNamespace = /*#__PURE__*/function () {
+  var _ref = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(config) {
+    var namespaces, loadPath, savePath, locales, defaultNamespace, sourceNamespaceResponse, sourceNamespace, newNamespaceResponse, newNamespace, globPatternsResponse, selectedGlobPatterns, parser, files, extractedKeys, _iterator, _step, file, content, uniqueExtractedKeys, relevantKeys, _iterator2, _step2, key, pureKey, _iterator3, _step3, locale, sourceTranslations, newNamespaceTranslations, _iterator4, _step4, _key;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          namespaces = config.namespaces, loadPath = config.loadPath, savePath = config.savePath, locales = config.locales, defaultNamespace = config.defaultNamespace; // Step 1: Ask for source namespace
+          _context.next = 3;
+          return prompts({
+            type: "select",
+            name: "value",
+            message: "Select source namespace to create pruned version from:",
+            choices: namespaces.map(function (namespace) {
+              return {
+                title: namespace,
+                value: namespace
+              };
+            }),
+            onState: function onState(state) {
+              if (state.aborted) {
+                process.nextTick(function () {
+                  process.exit(0);
+                });
+              }
+            }
+          });
+        case 3:
+          sourceNamespaceResponse = _context.sent;
+          sourceNamespace = sourceNamespaceResponse.value; // Step 2: Ask for new namespace name
+          _context.next = 7;
+          return prompts({
+            type: "text",
+            name: "value",
+            message: "Enter the name for the new namespace:",
+            validate: function validate(value) {
+              if (!value) return "Namespace name cannot be empty";
+              if (namespaces.includes(value)) return "Namespace already exists";
+              return true;
+            },
+            onState: function onState(state) {
+              if (state.aborted) {
+                process.nextTick(function () {
+                  process.exit(0);
+                });
+              }
+            }
+          });
+        case 7:
+          newNamespaceResponse = _context.sent;
+          newNamespace = newNamespaceResponse.value; // Step 3: Ask for glob patterns to find relevant keys
+          _context.next = 11;
+          return prompts({
+            type: "list",
+            name: "value",
+            message: "Enter glob patterns to find relevant keys (comma separated):",
+            initial: config.globPatterns.join(","),
+            separator: ",",
+            onState: function onState(state) {
+              if (state.aborted) {
+                process.nextTick(function () {
+                  process.exit(0);
+                });
+              }
+            }
+          });
+        case 11:
+          globPatternsResponse = _context.sent;
+          selectedGlobPatterns = globPatternsResponse.value;
+          console.log("Finding keys used in files matching: " + selectedGlobPatterns.join(", "));
+          // Extract keys from files matching the glob patterns
+          parser = new Parser({
+            nsSeparator: false,
+            keySeparator: false
+          });
+          _context.next = 17;
+          return glob([].concat(selectedGlobPatterns, ["!**/node_modules/**"]));
+        case 17:
+          files = _context.sent;
+          console.log("Found " + files.length + " files to scan");
+          extractedKeys = [];
+          for (_iterator = _createForOfIteratorHelperLoose(files); !(_step = _iterator()).done;) {
+            file = _step.value;
+            content = fs.readFileSync(file, "utf-8");
+            parser.parseFuncFromString(content, {
+              list: ["t"]
+            }, function (key) {
+              extractedKeys.push(key);
+            });
+          }
+          uniqueExtractedKeys = removeDuplicatesFromArray(extractedKeys);
+          console.log("Found " + uniqueExtractedKeys.length + " unique translation keys");
+          // Filter keys that belong to the source namespace
+          relevantKeys = [];
+          for (_iterator2 = _createForOfIteratorHelperLoose(uniqueExtractedKeys); !(_step2 = _iterator2()).done;) {
+            key = _step2.value;
+            pureKey = getPureKey(key, sourceNamespace, sourceNamespace === defaultNamespace);
+            if (pureKey) {
+              relevantKeys.push(pureKey);
+            }
+          }
+          console.log("Found " + relevantKeys.length + " keys from namespace '" + sourceNamespace + "'");
+          if (!(relevantKeys.length === 0)) {
+            _context.next = 29;
+            break;
+          }
+          console.log("No relevant keys found. Exiting...");
+          return _context.abrupt("return");
+        case 29:
+          _iterator3 = _createForOfIteratorHelperLoose(locales);
+        case 30:
+          if ((_step3 = _iterator3()).done) {
+            _context.next = 48;
+            break;
+          }
+          locale = _step3.value;
+          _context.prev = 32;
+          _context.next = 35;
+          return loadLocalesFile(loadPath, locale, sourceNamespace);
+        case 35:
+          sourceTranslations = _context.sent;
+          // Create new namespace with only the keys used in the glob pattern files
+          newNamespaceTranslations = {};
+          for (_iterator4 = _createForOfIteratorHelperLoose(relevantKeys); !(_step4 = _iterator4()).done;) {
+            _key = _step4.value;
+            if (sourceTranslations[_key]) {
+              newNamespaceTranslations[_key] = sourceTranslations[_key];
+            }
+          }
+          // Write the new namespace file
+          _context.next = 40;
+          return writeLocalesFile(savePath, locale, newNamespace, newNamespaceTranslations);
+        case 40:
+          console.log("Created pruned namespace '" + newNamespace + "' for locale '" + locale + "' with " + Object.keys(newNamespaceTranslations).length + " keys");
+          _context.next = 46;
+          break;
+        case 43:
+          _context.prev = 43;
+          _context.t0 = _context["catch"](32);
+          console.error("Error creating pruned namespace for locale '" + locale + "':", _context.t0);
+        case 46:
+          _context.next = 30;
+          break;
+        case 48:
+          console.log("\u2705 Successfully created pruned namespace '" + newNamespace + "'");
+        case 49:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[32, 43]]);
+  }));
+  return function createPrunedNamespace(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+var createPrunedNamespaceAutomated = /*#__PURE__*/function () {
+  var _ref = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(config, options) {
+    var namespaces, loadPath, savePath, locales, defaultNamespace, sourceNamespace, newNamespace, globPatterns, parser, files, extractedKeys, _iterator, _step, file, content, uniqueExtractedKeys, relevantKeys, _iterator2, _step2, key, pureKey, results, _iterator3, _step3, locale, sourceTranslations, newNamespaceTranslations, _iterator4, _step4, _key, keyCount;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          namespaces = config.namespaces, loadPath = config.loadPath, savePath = config.savePath, locales = config.locales, defaultNamespace = config.defaultNamespace;
+          sourceNamespace = options.sourceNamespace, newNamespace = options.newNamespace, globPatterns = options.globPatterns; // Validate inputs
+          if (namespaces.includes(sourceNamespace)) {
+            _context.next = 4;
+            break;
+          }
+          throw new Error("Source namespace '" + sourceNamespace + "' not found in configuration");
+        case 4:
+          if (!namespaces.includes(newNamespace)) {
+            _context.next = 6;
+            break;
+          }
+          throw new Error("Namespace '" + newNamespace + "' already exists");
+        case 6:
+          console.log("Creating pruned namespace '" + newNamespace + "' from '" + sourceNamespace + "'");
+          console.log("Using glob patterns: " + globPatterns.join(", "));
+          // Extract keys from files matching the glob patterns
+          parser = new Parser({
+            nsSeparator: false,
+            keySeparator: false
+          });
+          _context.next = 11;
+          return glob([].concat(globPatterns, ["!**/node_modules/**"]));
+        case 11:
+          files = _context.sent;
+          console.log("Found " + files.length + " files to scan");
+          extractedKeys = [];
+          for (_iterator = _createForOfIteratorHelperLoose(files); !(_step = _iterator()).done;) {
+            file = _step.value;
+            content = fs.readFileSync(file, "utf-8");
+            parser.parseFuncFromString(content, {
+              list: ["t"]
+            }, function (key) {
+              extractedKeys.push(key);
+            });
+          }
+          uniqueExtractedKeys = removeDuplicatesFromArray(extractedKeys);
+          console.log("Found " + uniqueExtractedKeys.length + " unique translation keys");
+          // Filter keys that belong to the source namespace
+          relevantKeys = [];
+          for (_iterator2 = _createForOfIteratorHelperLoose(uniqueExtractedKeys); !(_step2 = _iterator2()).done;) {
+            key = _step2.value;
+            pureKey = getPureKey(key, sourceNamespace, sourceNamespace === defaultNamespace);
+            if (pureKey) {
+              relevantKeys.push(pureKey);
+            }
+          }
+          console.log("Found " + relevantKeys.length + " keys from namespace '" + sourceNamespace + "'");
+          if (!(relevantKeys.length === 0)) {
+            _context.next = 23;
+            break;
+          }
+          console.log("No relevant keys found. Exiting...");
+          return _context.abrupt("return", {
+            success: false,
+            message: "No relevant keys found",
+            keysCount: 0
+          });
+        case 23:
+          // Get translations from source namespace and create new namespace files
+          results = [];
+          _iterator3 = _createForOfIteratorHelperLoose(locales);
+        case 25:
+          if ((_step3 = _iterator3()).done) {
+            _context.next = 46;
+            break;
+          }
+          locale = _step3.value;
+          _context.prev = 27;
+          _context.next = 30;
+          return loadLocalesFile(loadPath, locale, sourceNamespace);
+        case 30:
+          sourceTranslations = _context.sent;
+          // Create new namespace with only the keys used in the glob pattern files
+          newNamespaceTranslations = {};
+          for (_iterator4 = _createForOfIteratorHelperLoose(relevantKeys); !(_step4 = _iterator4()).done;) {
+            _key = _step4.value;
+            if (sourceTranslations[_key]) {
+              newNamespaceTranslations[_key] = sourceTranslations[_key];
+            }
+          }
+          // Write the new namespace file
+          _context.next = 35;
+          return writeLocalesFile(savePath, locale, newNamespace, newNamespaceTranslations);
+        case 35:
+          keyCount = Object.keys(newNamespaceTranslations).length;
+          console.log("Created pruned namespace '" + newNamespace + "' for locale '" + locale + "' with " + keyCount + " keys");
+          results.push({
+            locale: locale,
+            keyCount: keyCount,
+            success: true
+          });
+          _context.next = 44;
+          break;
+        case 40:
+          _context.prev = 40;
+          _context.t0 = _context["catch"](27);
+          console.error("Error creating pruned namespace for locale '" + locale + "':", _context.t0);
+          results.push({
+            locale: locale,
+            keyCount: 0,
+            success: false,
+            error: _context.t0 instanceof Error ? _context.t0.message : String(_context.t0)
+          });
+        case 44:
+          _context.next = 25;
+          break;
+        case 46:
+          console.log("\u2705 Successfully created pruned namespace '" + newNamespace + "'");
+          return _context.abrupt("return", {
+            success: true,
+            message: "Created pruned namespace '" + newNamespace + "' with " + relevantKeys.length + " keys",
+            keysCount: relevantKeys.length,
+            results: results
+          });
+        case 48:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[27, 40]]);
+  }));
+  return function createPrunedNamespaceAutomated(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
 var getKeyToReplace = /*#__PURE__*/function () {
   var _ref = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(keys) {
     var keyToReplace;
@@ -1092,69 +1487,79 @@ var replaceTranslation = /*#__PURE__*/function () {
 
 var translateMissing = /*#__PURE__*/function () {
   var _ref = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(config) {
-    var loadPath, savePath, defaultLocale, namespaces, locales, context, openai, disableTranslation, newKeys, newKeysWithDefaultLocale, _iterator, _step, newKey, answer, newKeysObject, allLocales, _iterator2, _step2, locale, translatedValues, _loop, _iterator3, _step3;
+    var loadPath, savePath, defaultLocale, namespaces, locales, context, openai, disableTranslation, autoClear, newKeys, newKeysWithDefaultLocale, _iterator, _step, newKey, answer, newKeysObject, allLocales, _iterator2, _step2, locale, translatedValues, _loop, _iterator3, _step3;
     return _regeneratorRuntime().wrap(function _callee$(_context2) {
       while (1) switch (_context2.prev = _context2.next) {
         case 0:
-          loadPath = config.loadPath, savePath = config.savePath, defaultLocale = config.defaultLocale, namespaces = config.namespaces, locales = config.locales, context = config.context, openai = config.openai, disableTranslation = config.disableTranslation;
-          _context2.next = 3;
+          loadPath = config.loadPath, savePath = config.savePath, defaultLocale = config.defaultLocale, namespaces = config.namespaces, locales = config.locales, context = config.context, openai = config.openai, disableTranslation = config.disableTranslation, autoClear = config.autoClear; // Run clean command first if autoClear is enabled
+          if (!autoClear) {
+            _context2.next = 6;
+            break;
+          }
+          console$1.log("🧹 Auto-clearing unused translations before scanning...");
+          _context2.next = 5;
+          return removeUnusedKeys(config);
+        case 5:
+          console$1.log("✅ Auto-clear completed. Now scanning for missing translations...\n");
+        case 6:
+          _context2.next = 8;
           return getMissingKeys(config);
-        case 3:
+        case 8:
           newKeys = _context2.sent;
           if (!(newKeys.length === 0)) {
-            _context2.next = 9;
+            _context2.next = 14;
             break;
           }
-          console.log("No new keys found.");
-          _context2.next = 8;
+          console$1.log("No new keys found.");
+          _context2.next = 13;
           return checkAllKeysExist(config);
-        case 8:
+        case 13:
           return _context2.abrupt("return");
-        case 9:
-          console.log(newKeys.length + " keys are missing. Please provide the values for the following keys in " + defaultLocale + ":");
+        case 14:
+          console$1.log(newKeys.length + " keys are missing. Please provide the values for the following keys in " + defaultLocale + ":");
           newKeysWithDefaultLocale = [];
           _iterator = _createForOfIteratorHelperLoose(newKeys);
-        case 12:
+        case 17:
           if ((_step = _iterator()).done) {
-            _context2.next = 20;
+            _context2.next = 25;
             break;
           }
           newKey = _step.value;
-          _context2.next = 16;
+          _context2.next = 21;
           return getTextInput(newKey.key);
-        case 16:
+        case 21:
           answer = _context2.sent;
           newKeysWithDefaultLocale.push({
             key: newKey.key,
             namespace: newKey.namespace,
             value: answer
           });
-        case 18:
-          _context2.next = 12;
+        case 23:
+          _context2.next = 17;
           break;
-        case 20:
+        case 25:
           newKeysObject = newKeysWithDefaultLocale.reduce(function (prev, next) {
             prev[next.key] = next.value;
             return prev;
           }, {});
           allLocales = disableTranslation ? [defaultLocale] : locales;
           _iterator2 = _createForOfIteratorHelperLoose(allLocales);
-        case 23:
+        case 28:
           if ((_step2 = _iterator2()).done) {
-            _context2.next = 43;
+            _context2.next = 48;
             break;
           }
           locale = _step2.value;
           translatedValues = {};
           if (!(locale === defaultLocale)) {
-            _context2.next = 30;
+            _context2.next = 35;
             break;
           }
           translatedValues = newKeysObject;
-          _context2.next = 33;
+          _context2.next = 38;
           break;
-        case 30:
-          _context2.next = 32;
+        case 35:
+          _context2.next = 37;
           return translateKey({
             inputLanguage: defaultLocale,
             outputLanguage: locale,
@@ -1163,9 +1568,9 @@ var translateMissing = /*#__PURE__*/function () {
             openai: openai,
             model: config.model
           });
-        case 32:
+        case 37:
           translatedValues = _context2.sent;
-        case 33:
+        case 38:
           _loop = /*#__PURE__*/_regeneratorRuntime().mark(function _loop() {
             var namespace, existingKeys, relevantKeys, _iterator4, _step4, key;
             return _regeneratorRuntime().wrap(function _loop$(_context) {
@@ -1197,30 +1602,30 @@ var translateMissing = /*#__PURE__*/function () {
             }, _loop);
           });
           _iterator3 = _createForOfIteratorHelperLoose(namespaces);
-        case 35:
+        case 40:
           if ((_step3 = _iterator3()).done) {
-            _context2.next = 41;
+            _context2.next = 46;
             break;
           }
-          return _context2.delegateYield(_loop(), "t0", 37);
-        case 37:
+          return _context2.delegateYield(_loop(), "t0", 42);
+        case 42:
           if (!_context2.t0) {
-            _context2.next = 39;
+            _context2.next = 44;
             break;
           }
-          return _context2.abrupt("continue", 39);
-        case 39:
-          _context2.next = 35;
+          return _context2.abrupt("continue", 44);
+        case 44:
+          _context2.next = 40;
           break;
-        case 41:
-          _context2.next = 23;
+        case 46:
+          _context2.next = 28;
           break;
-        case 43:
-          _context2.next = 45;
+        case 48:
+          _context2.next = 50;
           return checkAllKeysExist(config);
-        case 45:
-          console.log("Successfully translated " + newKeys.length + " keys.");
-        case 46:
+        case 50:
+          console$1.log("Successfully translated " + newKeys.length + " keys.");
+        case 51:
         case "end":
           return _context2.stop();
       }
@@ -1367,87 +1772,5 @@ var syncLocales = /*#__PURE__*/function () {
   };
 }();
 
-// Only run CLI initialization when this file is executed directly
-var program = /*#__PURE__*/new Command();
-program.name("i18n-magic").description("CLI to help you manage your locales JSON with translations, replacements, etc. with OpenAI.").version("0.2.0").option("-c, --config <path>", "path to config file").option("-e, --env <path>", "path to .env file");
-var commands = [{
-  name: "scan",
-  description: "Scan for missing translations, get prompted for each, translate it to the other locales and save it to the JSON file.",
-  action: translateMissing
-}, {
-  name: "replace",
-  description: "Replace a translation based on the key, and translate it to the other locales and save it to the JSON file.",
-  action: replaceTranslation
-}, {
-  name: "check-missing",
-  description: "Check if there are any missing translations. Useful for a CI/CD pipeline or husky hook.",
-  action: checkMissing
-}, {
-  name: "sync",
-  description: "Sync the translations from the default locale to the other locales. Useful for a CI/CD pipeline or husky hook.",
-  action: syncLocales
-}];
-var _loop = function _loop() {
-  var command = _commands[_i];
-  var cmd = program.command(command.name).description(command.description);
-  // Add key option to replace command
-  if (command.name === "replace") {
-    cmd.option("-k, --key <key>", "translation key to replace").allowExcessArguments(true).argument("[key]", "translation key to replace");
-  }
-  cmd.action( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(arg, options) {
-      var _config$model;
-      var res, config, isGemini, openaiKey, geminiKey, key, keyType, openai, keyToUse;
-      return _regeneratorRuntime().wrap(function _callee$(_context) {
-        while (1) switch (_context.prev = _context.next) {
-          case 0:
-            res = dotenv.config({
-              path: program.opts().env || ".env"
-            });
-            _context.next = 3;
-            return loadConfig({
-              configPath: program.opts().config
-            });
-          case 3:
-            config = _context.sent;
-            isGemini = (_config$model = config.model) == null ? void 0 : _config$model.includes("gemini"); // Get API key from environment or config
-            openaiKey = res.parsed.OPENAI_API_KEY || config.OPENAI_API_KEY;
-            geminiKey = res.parsed.GEMINI_API_KEY || config.GEMINI_API_KEY; // Select appropriate key based on model type
-            key = isGemini ? geminiKey : openaiKey;
-            if (!key) {
-              keyType = isGemini ? "GEMINI_API_KEY" : "OPENAI_API_KEY";
-              console.error("Please provide a" + (isGemini ? " Gemini" : "n OpenAI") + " API key in your .env file or config, called " + keyType + ".");
-              process.exit(1);
-            }
-            openai = new OpenAI(_extends({
-              apiKey: key
-            }, isGemini && {
-              baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/"
-            })); // For replace command, check for key in argument or option
-            if (command.name === "replace") {
-              // If key is provided as positional argument, use that first
-              keyToUse = typeof arg === "string" ? arg : options.key;
-              command.action(_extends({}, config, {
-                openai: openai
-              }), keyToUse);
-            } else {
-              command.action(_extends({}, config, {
-                openai: openai
-              }));
-            }
-          case 11:
-          case "end":
-            return _context.stop();
-        }
-      }, _callee);
-    }));
-    return function (_x, _x2) {
-      return _ref.apply(this, arguments);
-    };
-  }());
-};
-for (var _i = 0, _commands = commands; _i < _commands.length; _i++) {
-  _loop();
-}
-program.parse(process.argv);
+export { checkMissing, createPrunedNamespace, createPrunedNamespaceAutomated, loadConfig, removeUnusedKeys, replaceTranslation, syncLocales, translateMissing };
 //# sourceMappingURL=i18n-magic.esm.js.map