@red-hat-developer-hub/translations-cli 0.0.1

package/dist/commands/upload.cjs.js

@@ -0,0 +1,506 @@
+'use strict';
+
+var path = require('node:path');
+var fs = require('fs-extra');
+var chalk = require('chalk');
+var validateFile = require('../lib/i18n/validateFile.cjs.js');
+var config = require('../lib/i18n/config.cjs.js');
+var uploadCache = require('../lib/i18n/uploadCache.cjs.js');
+var exec = require('../lib/utils/exec.cjs.js');
+var translationUtils = require('../lib/utils/translationUtils.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefaultCompat(path);
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+
+function detectRepoName(repoPath) {
+  const targetPath = repoPath || process.cwd();
+  try {
+    const gitRepoUrl = exec.safeExecSyncOrThrow(
+      "git",
+      ["config", "--get", "remote.origin.url"],
+      {
+        cwd: targetPath
+      }
+    );
+    if (gitRepoUrl) {
+      let repoName = gitRepoUrl.replace(/\.git$/, "");
+      const lastSlashIndex = repoName.lastIndexOf("/");
+      if (lastSlashIndex >= 0) {
+        repoName = repoName.substring(lastSlashIndex + 1);
+      }
+      if (repoName) {
+        return repoName;
+      }
+    }
+  } catch {
+  }
+  return path__default.default.basename(targetPath);
+}
+function extractSprintFromFilename(sourceFile) {
+  const sourceBasename = path__default.default.basename(sourceFile, path__default.default.extname(sourceFile));
+  let sprintMatch = sourceBasename.match(/^[a-z-]+-(s?\d+)$/i);
+  if (!sprintMatch) {
+    sprintMatch = sourceBasename.match(/-reference-(s?\d+)$/i);
+  }
+  return sprintMatch ? sprintMatch[1] : void 0;
+}
+function findGitRoot(sourceDir) {
+  let currentDir = sourceDir;
+  while (currentDir !== path__default.default.dirname(currentDir)) {
+    const gitDir = path__default.default.join(currentDir, ".git");
+    try {
+      if (fs__default.default.statSync(gitDir).isDirectory()) {
+        return currentDir;
+      }
+    } catch {
+    }
+    currentDir = path__default.default.dirname(currentDir);
+  }
+  return void 0;
+}
+function formatIdentifier(sprintValue) {
+  if (!sprintValue) {
+    return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  }
+  return sprintValue.startsWith("s") || sprintValue.startsWith("S") ? sprintValue.toLowerCase() : `s${sprintValue}`;
+}
+function generateUploadFileName(sourceFile, customName, sprint) {
+  if (customName) {
+    const ext2 = path__default.default.extname(sourceFile);
+    return customName.endsWith(ext2) ? customName : `${customName}${ext2}`;
+  }
+  const sprintValue = extractSprintFromFilename(sourceFile);
+  const sourceFileAbs = path__default.default.resolve(sourceFile);
+  const sourceDir = path__default.default.dirname(sourceFileAbs);
+  const repoRoot = findGitRoot(sourceDir);
+  const repoName = repoRoot ? detectRepoName(repoRoot) : detectRepoName();
+  const identifier = formatIdentifier(sprintValue);
+  const ext = path__default.default.extname(sourceFile);
+  return `${repoName}-${identifier}${ext}`;
+}
+async function prepareUploadFile(filePath, uploadFileName) {
+  const absoluteFilePath = path__default.default.resolve(filePath);
+  let fileToUpload = absoluteFilePath;
+  let tempFile = null;
+  if (uploadFileName && path__default.default.basename(absoluteFilePath) !== uploadFileName) {
+    const tempDir = path__default.default.join(path__default.default.dirname(absoluteFilePath), ".i18n-temp");
+    await fs__default.default.ensureDir(tempDir);
+    tempFile = path__default.default.join(tempDir, uploadFileName);
+    await fs__default.default.copy(absoluteFilePath, tempFile);
+    fileToUpload = tempFile;
+    console.log(
+      chalk__default.default.gray(`   Created temporary file with name: ${uploadFileName}`)
+    );
+  }
+  return { fileToUpload, tempFile };
+}
+function validateMemsourcePrerequisites() {
+  if (!exec.commandExists("memsource")) {
+    throw new Error(
+      "memsource CLI not found. Please ensure memsource-cli is installed and ~/.memsourcerc is sourced."
+    );
+  }
+}
+function buildUploadCommandArgs(projectId, targetLanguages, fileToUpload) {
+  if (targetLanguages.length === 0) {
+    throw new Error(
+      "Target languages are required. Please specify --target-languages or configure them in .i18n.config.json"
+    );
+  }
+  return [
+    "job",
+    "create",
+    "--project-id",
+    projectId,
+    "--target-langs",
+    ...targetLanguages,
+    "--filenames",
+    fileToUpload
+  ];
+}
+function extractErrorMessage(error) {
+  if (!(error instanceof Error)) {
+    return "Unknown error";
+  }
+  let errorMessage = error.message;
+  if ("stderr" in error && typeof error.stderr === "object") {
+    const stderr = error.stderr;
+    if (stderr) {
+      const stderrText = stderr.toString("utf-8");
+      if (stderrText) {
+        errorMessage = stderrText.trim();
+      }
+    }
+  }
+  return errorMessage;
+}
+async function countKeysFromFile(filePath) {
+  try {
+    const fileContent = await fs__default.default.readFile(filePath, "utf-8");
+    const data = JSON.parse(fileContent);
+    return translationUtils.countTranslationKeys(data);
+  } catch {
+    return 0;
+  }
+}
+async function cleanupTempFile(tempFile) {
+  try {
+    if (await fs__default.default.pathExists(tempFile)) {
+      await fs__default.default.remove(tempFile);
+    }
+    const tempDir = path__default.default.dirname(tempFile);
+    if (await fs__default.default.pathExists(tempDir)) {
+      const files = await fs__default.default.readdir(tempDir);
+      if (files.length === 0) {
+        await fs__default.default.remove(tempDir);
+      }
+    }
+  } catch (cleanupError) {
+    console.warn(
+      chalk__default.default.yellow(
+        `   Warning: Failed to clean up temporary file: ${cleanupError}`
+      )
+    );
+  }
+}
+async function executeMemsourceUpload(args, _fileToUpload) {
+  const output = exec.safeExecSyncOrThrow("memsource", args, {
+    encoding: "utf-8",
+    stdio: "pipe",
+    env: { ...process.env }
+  });
+  const trimmed = output?.trim();
+  if (trimmed) {
+    console.log(chalk__default.default.gray(`   ${trimmed}`));
+  }
+}
+async function uploadWithMemsourceCLI(filePath, projectId, targetLanguages, uploadFileName) {
+  validateMemsourcePrerequisites();
+  const absoluteFilePath = path__default.default.resolve(filePath);
+  const { fileToUpload, tempFile } = await prepareUploadFile(
+    filePath,
+    uploadFileName
+  );
+  const args = buildUploadCommandArgs(projectId, targetLanguages, fileToUpload);
+  try {
+    await executeMemsourceUpload(args, fileToUpload);
+    const keyCount = await countKeysFromFile(fileToUpload);
+    return {
+      fileName: uploadFileName || path__default.default.basename(absoluteFilePath),
+      keyCount
+    };
+  } catch (error) {
+    const errorMessage = extractErrorMessage(error);
+    throw new Error(`memsource CLI upload failed: ${errorMessage}`);
+  } finally {
+    if (tempFile) {
+      await cleanupTempFile(tempFile);
+    }
+  }
+}
+function extractStringOption(value) {
+  return value && typeof value === "string" ? value : void 0;
+}
+function validateTmsConfig(tmsUrl, tmsToken, projectId) {
+  const tmsUrlStr = extractStringOption(tmsUrl);
+  const tmsTokenStr = extractStringOption(tmsToken);
+  const projectIdStr = extractStringOption(projectId);
+  if (!tmsUrlStr || !tmsTokenStr || !projectIdStr) {
+    return null;
+  }
+  return { tmsUrl: tmsUrlStr, tmsToken: tmsTokenStr, projectId: projectIdStr };
+}
+function displayMissingConfigError(tmsUrlStr, tmsTokenStr, projectIdStr) {
+  console.error(chalk__default.default.red("\u274C Missing required TMS configuration:"));
+  console.error("");
+  const missingConfigs = [
+    {
+      value: tmsUrlStr,
+      label: "TMS URL",
+      messages: [
+        "     Set via: --tms-url <url> or I18N_TMS_URL or .i18n.config.json"
+      ]
+    },
+    {
+      value: tmsTokenStr,
+      label: "TMS Token",
+      messages: [
+        "     Primary: Source ~/.memsourcerc (sets MEMSOURCE_TOKEN)",
+        "     Fallback: --tms-token <token> or I18N_TMS_TOKEN or ~/.i18n.auth.json"
+      ]
+    },
+    {
+      value: projectIdStr,
+      label: "Project ID",
+      messages: [
+        "     Set via: --project-id <id> or I18N_TMS_PROJECT_ID or .i18n.config.json"
+      ]
+    }
+  ];
+  missingConfigs.filter((item) => !item.value).forEach((item) => {
+    console.error(chalk__default.default.yellow(`   \u2717 ${item.label}`));
+    item.messages.forEach((message) => {
+      console.error(chalk__default.default.gray(message));
+    });
+  });
+  console.error("");
+  console.error(chalk__default.default.blue("\u{1F4CB} Quick Setup Guide:"));
+  console.error(chalk__default.default.gray("   1. Run: translations-cli i18n init"));
+  console.error(chalk__default.default.gray("      This creates .i18n.config.json"));
+  console.error("");
+  console.error(
+    chalk__default.default.gray("   2. Edit .i18n.config.json in your project root:")
+  );
+  console.error(
+    chalk__default.default.gray(
+      '      - Add your TMS URL (e.g., "https://cloud.memsource.com/web")'
+    )
+  );
+  console.error(chalk__default.default.gray("      - Add your Project ID"));
+  console.error("");
+  console.error(
+    chalk__default.default.gray("   3. Set up Memsource authentication (recommended):")
+  );
+  console.error(
+    chalk__default.default.gray("      - Run: translations-cli i18n setup-memsource")
+  );
+  console.error(
+    chalk__default.default.gray(
+      "      - Or manually create ~/.memsourcerc following localization team instructions"
+    )
+  );
+  console.error(chalk__default.default.gray("      - Then source it: source ~/.memsourcerc"));
+  console.error("");
+  console.error(
+    chalk__default.default.gray(
+      "   OR use ~/.i18n.auth.json as fallback (run init to create it)"
+    )
+  );
+  console.error("");
+  console.error(
+    chalk__default.default.gray("   See docs/i18n-commands.md for detailed instructions.")
+  );
+}
+async function validateSourceFile(sourceFile) {
+  if (!await fs__default.default.pathExists(sourceFile)) {
+    throw new Error(`Source file not found: ${sourceFile}`);
+  }
+  console.log(chalk__default.default.yellow(`\u{1F50D} Validating ${sourceFile}...`));
+  const isValid = await validateFile.validateTranslationFile(sourceFile);
+  if (!isValid) {
+    throw new Error(`Invalid translation file format: ${sourceFile}`);
+  }
+  console.log(chalk__default.default.green(`\u2705 Translation file is valid`));
+}
+async function checkFileChangeAndWarn(sourceFile, projectId, tmsUrl, finalUploadFileName, force, cachedEntry) {
+  if (force) {
+    console.log(
+      chalk__default.default.yellow(`\u26A0\uFE0F  Force upload enabled - skipping cache check`)
+    );
+    return true;
+  }
+  const fileChanged = await uploadCache.hasFileChanged(sourceFile, projectId, tmsUrl);
+  const sameFilename = cachedEntry?.uploadFileName === finalUploadFileName;
+  if (!fileChanged && cachedEntry && sameFilename) {
+    console.log(
+      chalk__default.default.yellow(
+        `\u2139\uFE0F  File has not changed since last upload (${new Date(
+          cachedEntry.uploadedAt
+        ).toLocaleString()})`
+      )
+    );
+    console.log(chalk__default.default.gray(`   Upload filename: ${finalUploadFileName}`));
+    console.log(chalk__default.default.gray(`   Skipping upload to avoid duplicate.`));
+    console.log(
+      chalk__default.default.gray(
+        `   Use --force to upload anyway, or delete .i18n-cache to clear cache.`
+      )
+    );
+    return false;
+  }
+  if (!fileChanged && cachedEntry && !sameFilename) {
+    console.log(
+      chalk__default.default.yellow(
+        `\u26A0\uFE0F  File content unchanged, but upload filename differs from last upload:`
+      )
+    );
+    console.log(
+      chalk__default.default.gray(`   Last upload: ${cachedEntry.uploadFileName || "unknown"}`)
+    );
+    console.log(chalk__default.default.gray(`   This upload: ${finalUploadFileName}`));
+    console.log(chalk__default.default.gray(`   This will create a new job in Memsource.`));
+  }
+  return true;
+}
+async function uploadCommand(opts) {
+  console.log(chalk__default.default.blue("\u{1F4E4} Uploading translation reference files to TMS..."));
+  const config$1 = await config.loadI18nConfig();
+  const mergedOpts = await config.mergeConfigWithOptions(config$1, opts);
+  const {
+    tmsUrl,
+    tmsToken,
+    projectId,
+    sourceFile,
+    targetLanguages,
+    uploadFileName,
+    uploadFilename,
+    // Commander.js converts --upload-filename to uploadFilename
+    dryRun = false,
+    force = false
+  } = mergedOpts;
+  const finalUploadFileNameOption = uploadFilename || uploadFileName;
+  const tmsConfig = validateTmsConfig(tmsUrl, tmsToken, projectId);
+  if (!tmsConfig) {
+    const tmsUrlStr = extractStringOption(tmsUrl);
+    const tmsTokenStr = extractStringOption(tmsToken);
+    const projectIdStr = extractStringOption(projectId);
+    displayMissingConfigError(tmsUrlStr, tmsTokenStr, projectIdStr);
+    process.exit(1);
+  }
+  const sourceFileStr = extractStringOption(sourceFile);
+  if (!sourceFileStr) {
+    console.error(chalk__default.default.red("\u274C Missing required option: --source-file"));
+    process.exit(1);
+  }
+  try {
+    await validateSourceFile(sourceFileStr);
+    const finalUploadFileName = finalUploadFileNameOption && typeof finalUploadFileNameOption === "string" ? generateUploadFileName(sourceFileStr, finalUploadFileNameOption) : generateUploadFileName(sourceFileStr);
+    const cachedEntry = await uploadCache.getCachedUpload(
+      sourceFileStr,
+      tmsConfig.projectId,
+      tmsConfig.tmsUrl
+    );
+    const shouldProceed = await checkFileChangeAndWarn(
+      sourceFileStr,
+      tmsConfig.projectId,
+      tmsConfig.tmsUrl,
+      finalUploadFileName,
+      force,
+      cachedEntry
+    );
+    if (!shouldProceed) {
+      return;
+    }
+    if (dryRun) {
+      simulateUpload(
+        tmsConfig.tmsUrl,
+        tmsConfig.projectId,
+        sourceFileStr,
+        finalUploadFileName,
+        targetLanguages,
+        cachedEntry
+      );
+      return;
+    }
+    await performUpload(
+      tmsConfig.tmsUrl,
+      tmsConfig.tmsToken,
+      tmsConfig.projectId,
+      sourceFileStr,
+      finalUploadFileName,
+      targetLanguages,
+      force
+    );
+  } catch (error) {
+    console.error(chalk__default.default.red("\u274C Error uploading translation file:"), error);
+    throw error;
+  }
+}
+function simulateUpload(tmsUrl, projectId, sourceFile, uploadFileName, targetLanguages, cachedEntry) {
+  console.log(
+    chalk__default.default.yellow("\u{1F50D} Dry run mode - showing what would be uploaded:")
+  );
+  console.log(chalk__default.default.gray(`   TMS URL: ${tmsUrl}`));
+  console.log(chalk__default.default.gray(`   Project ID: ${projectId}`));
+  console.log(chalk__default.default.gray(`   Source file: ${sourceFile}`));
+  console.log(chalk__default.default.gray(`   Upload filename: ${uploadFileName}`));
+  console.log(
+    chalk__default.default.gray(
+      `   Target languages: ${targetLanguages || "All configured languages"}`
+    )
+  );
+  if (cachedEntry) {
+    console.log(
+      chalk__default.default.gray(
+        `   Last uploaded: ${new Date(
+          cachedEntry.uploadedAt
+        ).toLocaleString()}`
+      )
+    );
+  }
+}
+async function performUpload(tmsUrl, tmsToken, projectId, sourceFile, uploadFileName, targetLanguages, _force) {
+  if (!process.env.MEMSOURCE_TOKEN && !tmsToken) {
+    console.error(chalk__default.default.red("\u274C MEMSOURCE_TOKEN not found in environment"));
+    console.error(chalk__default.default.yellow("   Please source ~/.memsourcerc first:"));
+    console.error(chalk__default.default.gray("     source ~/.memsourcerc"));
+    console.error(chalk__default.default.gray("   Or set MEMSOURCE_TOKEN environment variable"));
+    process.exit(1);
+  }
+  const config$1 = await config.loadI18nConfig();
+  console.log(
+    chalk__default.default.yellow(`\u{1F517} Using memsource CLI to upload to project ${projectId}...`)
+  );
+  let languages = [];
+  if (targetLanguages && typeof targetLanguages === "string") {
+    languages = targetLanguages.split(",").map((lang) => lang.trim()).filter(Boolean);
+  } else if (config$1.languages && Array.isArray(config$1.languages) && config$1.languages.length > 0) {
+    languages = config$1.languages;
+    console.log(
+      chalk__default.default.gray(
+        `   Using target languages from config: ${languages.join(", ")}`
+      )
+    );
+  }
+  if (languages.length === 0) {
+    console.error(chalk__default.default.red("\u274C Target languages are required"));
+    console.error(chalk__default.default.yellow("   Please specify one of:"));
+    console.error(
+      chalk__default.default.gray("     1. --target-languages it (or other language codes)")
+    );
+    console.error(
+      chalk__default.default.gray('     2. Add "languages": ["it"] to .i18n.config.json')
+    );
+    process.exit(1);
+  }
+  console.log(chalk__default.default.yellow(`\u{1F4E4} Uploading ${sourceFile}...`));
+  console.log(chalk__default.default.gray(`   Upload filename: ${uploadFileName}`));
+  if (languages.length > 0) {
+    console.log(chalk__default.default.gray(`   Target languages: ${languages.join(", ")}`));
+  }
+  const uploadResult = await uploadWithMemsourceCLI(
+    sourceFile,
+    projectId,
+    languages,
+    uploadFileName
+  );
+  const fileContent = await fs__default.default.readFile(sourceFile, "utf-8");
+  let keyCount = uploadResult.keyCount;
+  if (keyCount === 0) {
+    try {
+      const data = JSON.parse(fileContent);
+      keyCount = translationUtils.countTranslationKeys(data);
+    } catch {
+      keyCount = 0;
+    }
+  }
+  await uploadCache.saveUploadCache(
+    sourceFile,
+    projectId,
+    tmsUrl,
+    keyCount,
+    uploadFileName
+  );
+  console.log(chalk__default.default.green(`\u2705 Upload completed successfully!`));
+  console.log(chalk__default.default.gray(`   File: ${uploadResult.fileName}`));
+  console.log(chalk__default.default.gray(`   Keys: ${keyCount}`));
+  if (languages.length > 0) {
+    console.log(chalk__default.default.gray(`   Target languages: ${languages.join(", ")}`));
+  }
+}
+
+exports.uploadCommand = uploadCommand;
+//# sourceMappingURL=upload.cjs.js.map

package/dist/index.cjs.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var chalk = require('chalk');
+var commander = require('commander');
+var index = require('./commands/index.cjs.js');
+var errors = require('./lib/errors.cjs.js');
+var version = require('./lib/version.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+
+const main = (argv) => {
+  commander.program.name("translations-cli").version(version.version);
+  index.registerCommands(commander.program);
+  commander.program.on("command:*", () => {
+    console.log();
+    console.log(chalk__default.default.red(`Invalid command: ${commander.program.args.join(" ")}`));
+    console.log();
+    commander.program.outputHelp();
+    process.exit(1);
+  });
+  commander.program.parse(argv);
+};
+process.on("unhandledRejection", (rejection) => {
+  const error = rejection instanceof Error ? rejection : new Error(`Unknown rejection: '${rejection}'`);
+  errors.exitWithError(error);
+});
+main(process.argv);
+//# sourceMappingURL=index.cjs.js.map

package/dist/lib/errors.cjs.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var chalk = require('chalk');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+
+class CustomError extends Error {
+  get name() {
+    return this.constructor.name;
+  }
+}
+class ExitCodeError extends CustomError {
+  code;
+  constructor(code, command) {
+    super(
+      command ? `Command '${command}' exited with code ${code}` : `Child exited with code ${code}`
+    );
+    this.code = code;
+  }
+}
+function exitWithError(error) {
+  const errorMessage = error instanceof ExitCodeError ? error.message : String(error);
+  const exitCode = error instanceof ExitCodeError ? error.code : 1;
+  process.stderr.write(`
+${chalk__default.default.red(errorMessage)}
+
+`);
+  process.exit(exitCode);
+}
+
+exports.CustomError = CustomError;
+exports.ExitCodeError = ExitCodeError;
+exports.exitWithError = exitWithError;
+//# sourceMappingURL=errors.cjs.js.map

package/dist/lib/i18n/analyzeStatus.cjs.js

@@ -0,0 +1,79 @@
+'use strict';
+
+var path = require('node:path');
+var fs = require('fs-extra');
+var glob = require('glob');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefaultCompat(path);
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var glob__default = /*#__PURE__*/_interopDefaultCompat(glob);
+
+async function analyzeTranslationStatus(options) {
+  const { sourceDir, i18nDir, localesDir } = options;
+  const sourceFiles = glob__default.default.sync("**/*.{ts,tsx,js,jsx}", {
+    cwd: sourceDir,
+    ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"]
+  });
+  const referenceFile = path__default.default.join(i18nDir, "reference.json");
+  let referenceKeys = [];
+  if (await fs__default.default.pathExists(referenceFile)) {
+    const referenceData = await fs__default.default.readJson(referenceFile);
+    referenceKeys = Object.keys(referenceData.translations || referenceData);
+  }
+  const languageFiles = await findLanguageFiles(localesDir);
+  const languages = languageFiles.map(
+    (file) => path__default.default.basename(file, path__default.default.extname(file))
+  );
+  const languageStats = {};
+  const extraKeys = {};
+  for (const languageFile of languageFiles) {
+    const language = path__default.default.basename(languageFile, path__default.default.extname(languageFile));
+    const fileData = await fs__default.default.readJson(languageFile);
+    const languageKeys = Object.keys(fileData.translations || fileData);
+    const translated = languageKeys.filter((key) => {
+      const value = (fileData.translations || fileData)[key];
+      return value && value.trim() !== "" && value !== key;
+    });
+    languageStats[language] = {
+      total: referenceKeys.length,
+      translated: translated.length,
+      completion: referenceKeys.length > 0 ? translated.length / referenceKeys.length * 100 : 0
+    };
+    extraKeys[language] = languageKeys.filter(
+      (key) => !referenceKeys.includes(key)
+    );
+  }
+  const missingKeys = referenceKeys.filter((key) => {
+    return !languages.some((lang) => {
+      const langKeys = Object.keys(languageStats[lang] || {});
+      return langKeys.includes(key);
+    });
+  });
+  const totalTranslations = languages.reduce(
+    (sum, lang) => sum + (languageStats[lang]?.translated || 0),
+    0
+  );
+  const totalPossible = referenceKeys.length * languages.length;
+  const overallCompletion = totalPossible > 0 ? totalTranslations / totalPossible * 100 : 0;
+  return {
+    sourceFiles,
+    totalKeys: referenceKeys.length,
+    languages,
+    overallCompletion,
+    languageStats,
+    missingKeys,
+    extraKeys
+  };
+}
+async function findLanguageFiles(localesDir) {
+  if (!await fs__default.default.pathExists(localesDir)) {
+    return [];
+  }
+  const files = await fs__default.default.readdir(localesDir);
+  return files.filter((file) => file.endsWith(".json")).map((file) => path__default.default.join(localesDir, file));
+}
+
+exports.analyzeTranslationStatus = analyzeTranslationStatus;
+//# sourceMappingURL=analyzeStatus.cjs.js.map