lingo.dev 0.83.0 → 0.85.0

package/build/cli.cjs

@@ -1635,9 +1635,9 @@ var _remarkgfm = require('remark-gfm'); var _remarkgfm2 = _interopRequireDefault
 var _remarkstringify = require('remark-stringify'); var _remarkstringify2 = _interopRequireDefault(_remarkstringify);
 var _remarkmdxfrontmatter = require('remark-mdx-frontmatter'); var _remarkmdxfrontmatter2 = _interopRequireDefault(_remarkmdxfrontmatter);
 var _vfile = require('vfile');
+var parser = _unified.unified.call(void 0, ).use(_remarkparse2.default).use(_remarkmdx2.default).use(_remarkfrontmatter2.default, ["yaml"]).use(_remarkmdxfrontmatter2.default).use(_remarkgfm2.default);
+var serializer = _unified.unified.call(void 0, ).use(_remarkstringify2.default).use(_remarkmdx2.default).use(_remarkfrontmatter2.default, ["yaml"]).use(_remarkmdxfrontmatter2.default).use(_remarkgfm2.default);
 function createMdxFormatLoader() {
-  const parser = _unified.unified.call(void 0, ).use(_remarkparse2.default).use(_remarkmdx2.default).use(_remarkfrontmatter2.default, ["yaml"]).use(_remarkmdxfrontmatter2.default).use(_remarkgfm2.default);
-  const serializer = _unified.unified.call(void 0, ).use(_remarkstringify2.default).use(_remarkmdx2.default).use(_remarkfrontmatter2.default, ["yaml"]).use(_remarkmdxfrontmatter2.default).use(_remarkgfm2.default);
   return createLoader({
     async pull(locale, input2) {
       const file = new (0, _vfile.VFile)(input2);
@@ -1646,8 +1646,21 @@ function createMdxFormatLoader() {
     },
     async push(locale, data) {
       const ast = data;
-      const file = serializer.stringify(ast);
-      return String(file);
+      const content = String(serializer.stringify(ast));
+      return content;
+    }
+  });
+}
+function createDoubleSerializationLoader() {
+  return createLoader({
+    async pull(locale, input2) {
+      return input2;
+    },
+    async push(locale, data) {
+      const file = new (0, _vfile.VFile)(data);
+      const ast = parser.parse(file);
+      const finalContent = String(serializer.stringify(ast));
+      return finalContent;
     }
   });
 }
@@ -2092,10 +2105,10 @@ function createXmlLoader() {
 // src/cli/loaders/srt.ts
 var _srtparser2 = require('srt-parser-2'); var _srtparser22 = _interopRequireDefault(_srtparser2);
 function createSrtLoader() {
-  const parser = new (0, _srtparser22.default)();
+  const parser2 = new (0, _srtparser22.default)();
   return createLoader({
     async pull(locale, input2) {
-      const parsed = parser.fromSrt(input2) || [];
+      const parsed = parser2.fromSrt(input2) || [];
       const result = {};
       parsed.forEach((entry) => {
         const key = `${entry.id}#${entry.startTime}-${entry.endTime}`;
@@ -2116,7 +2129,7 @@ function createSrtLoader() {
           text
         };
       });
-      const srtContent = parser.toSrt(output).trim().replace(/\r?\n/g, "\n");
+      const srtContent = parser2.toSrt(output).trim().replace(/\r?\n/g, "\n");
       return srtContent;
     }
   });
@@ -3075,7 +3088,10 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createAndroidLoader(),
         createFlatLoader(),
         createSyncLoader(),
-        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
+        createUnlocalizableLoader(
+          options.isCacheRestore,
+          options.returnUnlocalizedKeys
+        )
       );
     case "csv":
       return composeLoaders(
@@ -3083,7 +3099,10 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createCsvLoader(),
         createFlatLoader(),
         createSyncLoader(),
-        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
+        createUnlocalizableLoader(
+          options.isCacheRestore,
+          options.returnUnlocalizedKeys
+        )
       );
     case "html":
       return composeLoaders(
@@ -3091,7 +3110,10 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createPrettierLoader({ parser: "html", bucketPathPattern }),
         createHtmlLoader(),
         createSyncLoader(),
-        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
+        createUnlocalizableLoader(
+          options.isCacheRestore,
+          options.returnUnlocalizedKeys
+        )
       );
     case "json":
       return composeLoaders(
@@ -3102,7 +3124,10 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createFlatLoader(),
         createLockedKeysLoader(lockedKeys || [], options.isCacheRestore),
         createSyncLoader(),
-        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
+        createUnlocalizableLoader(
+          options.isCacheRestore,
+          options.returnUnlocalizedKeys
+        )
       );
     case "markdown":
       return composeLoaders(
@@ -3110,7 +3135,24 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createPrettierLoader({ parser: "markdown", bucketPathPattern }),
         createMarkdownLoader(),
         createSyncLoader(),
-        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
+        createUnlocalizableLoader(
+          options.isCacheRestore,
+          options.returnUnlocalizedKeys
+        )
+      );
+    case "mdx":
+      return composeLoaders(
+        createTextFileLoader(bucketPathPattern),
+        createDoubleSerializationLoader(),
+        createPrettierLoader({ parser: "mdx", bucketPathPattern }),
+        createMdxFormatLoader(),
+        createFlatLoader(),
+        createMdxStructureLoader(),
+        createSyncLoader(),
+        createUnlocalizableLoader(
+          options.isCacheRestore,
+          options.returnUnlocalizedKeys
+        )
       );
     case "mdx":
       return composeLoaders(
@@ -3129,21 +3171,30 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createFlatLoader(),
         createSyncLoader(),
         createVariableLoader({ type: "python" }),
-        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
+        createUnlocalizableLoader(
+          options.isCacheRestore,
+          options.returnUnlocalizedKeys
+        )
       );
     case "properties":
       return composeLoaders(
         createTextFileLoader(bucketPathPattern),
         createPropertiesLoader(),
         createSyncLoader(),
-        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
+        createUnlocalizableLoader(
+          options.isCacheRestore,
+          options.returnUnlocalizedKeys
+        )
       );
     case "xcode-strings":
       return composeLoaders(
         createTextFileLoader(bucketPathPattern),
         createXcodeStringsLoader(),
         createSyncLoader(),
-        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
+        createUnlocalizableLoader(
+          options.isCacheRestore,
+          options.returnUnlocalizedKeys
+        )
       );
     case "xcode-stringsdict":
       return composeLoaders(
@@ -3151,7 +3202,10 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createXcodeStringsdictLoader(),
         createFlatLoader(),
         createSyncLoader(),
-        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
+        createUnlocalizableLoader(
+          options.isCacheRestore,
+          options.returnUnlocalizedKeys
+        )
       );
     case "xcode-xcstrings":
       return composeLoaders(
@@ -3162,7 +3216,10 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createFlatLoader(),
         createSyncLoader(),
         createVariableLoader({ type: "ieee" }),
-        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
+        createUnlocalizableLoader(
+          options.isCacheRestore,
+          options.returnUnlocalizedKeys
+        )
       );
     case "yaml":
       return composeLoaders(
@@ -3172,7 +3229,10 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createFlatLoader(),
         createLockedKeysLoader(lockedKeys || [], options.isCacheRestore),
         createSyncLoader(),
-        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
+        createUnlocalizableLoader(
+          options.isCacheRestore,
+          options.returnUnlocalizedKeys
+        )
       );
     case "yaml-root-key":
       return composeLoaders(
@@ -3182,7 +3242,10 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createRootKeyLoader(true),
         createFlatLoader(),
         createSyncLoader(),
-        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
+        createUnlocalizableLoader(
+          options.isCacheRestore,
+          options.returnUnlocalizedKeys
+        )
       );
     case "flutter":
       return composeLoaders(
@@ -3192,7 +3255,10 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createFlutterLoader(),
         createFlatLoader(),
         createSyncLoader(),
-        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
+        createUnlocalizableLoader(
+          options.isCacheRestore,
+          options.returnUnlocalizedKeys
+        )
       );
     case "xliff":
       return composeLoaders(
@@ -3200,7 +3266,10 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createXliffLoader(),
         createFlatLoader(),
         createSyncLoader(),
-        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
+        createUnlocalizableLoader(
+          options.isCacheRestore,
+          options.returnUnlocalizedKeys
+        )
       );
     case "xml":
       return composeLoaders(
@@ -3208,28 +3277,40 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createXmlLoader(),
         createFlatLoader(),
         createSyncLoader(),
-        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
+        createUnlocalizableLoader(
+          options.isCacheRestore,
+          options.returnUnlocalizedKeys
+        )
       );
     case "srt":
       return composeLoaders(
         createTextFileLoader(bucketPathPattern),
         createSrtLoader(),
         createSyncLoader(),
-        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
+        createUnlocalizableLoader(
+          options.isCacheRestore,
+          options.returnUnlocalizedKeys
+        )
       );
     case "dato":
       return composeLoaders(
         createDatoLoader(bucketPathPattern),
         createSyncLoader(),
         createFlatLoader(),
-        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
+        createUnlocalizableLoader(
+          options.isCacheRestore,
+          options.returnUnlocalizedKeys
+        )
       );
     case "vtt":
       return composeLoaders(
         createTextFileLoader(bucketPathPattern),
         createVttLoader(),
         createSyncLoader(),
-        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
+        createUnlocalizableLoader(
+          options.isCacheRestore,
+          options.returnUnlocalizedKeys
+        )
       );
     case "php":
       return composeLoaders(
@@ -3237,7 +3318,10 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createPhpLoader(),
         createSyncLoader(),
         createFlatLoader(),
-        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
+        createUnlocalizableLoader(
+          options.isCacheRestore,
+          options.returnUnlocalizedKeys
+        )
       );
     case "vue-json":
       return composeLoaders(
@@ -3245,7 +3329,10 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createVueJsonLoader(),
         createSyncLoader(),
         createFlatLoader(),
-        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
+        createUnlocalizableLoader(
+          options.isCacheRestore,
+          options.returnUnlocalizedKeys
+        )
       );
   }
 }
@@ -5024,10 +5111,424 @@ var ci_default = new (0, _interactivecommander.Command)().command("ci").descript
   main();
 });
 
+// src/cli/cmd/status.ts
+
+
+
+
+
+var _clitable3 = require('cli-table3'); var _clitable32 = _interopRequireDefault(_clitable3);
+var status_default = new (0, _interactivecommander.Command)().command("status").description("Show the status of the localization process").helpOption("-h, --help", "Show help").option("--locale <locale>", "Locale to process", (val, prev) => prev ? [...prev, val] : [val]).option("--bucket <bucket>", "Bucket to process", (val, prev) => prev ? [...prev, val] : [val]).option(
+  "--file [files...]",
+  "File to process. Process only a specific path, may contain asterisk * to match multiple files."
+).option("--force", "Ignore lockfile and process all keys, useful for estimating full re-translation").option("--verbose", "Show detailed output including key-level word counts").option("--api-key <api-key>", "Explicitly set the API key to use, override the default API key from settings").action(async function(options) {
+  const ora = _ora2.default.call(void 0, );
+  const flags = parseFlags2(options);
+  let authId = null;
+  try {
+    ora.start("Loading configuration...");
+    const i18nConfig = getConfig();
+    const settings = getSettings(flags.apiKey);
+    ora.succeed("Configuration loaded");
+    try {
+      ora.start("Checking authentication status...");
+      const auth = await tryAuthenticate(settings);
+      if (auth) {
+        authId = auth.id;
+        ora.succeed(`Authenticated as ${auth.email}`);
+      } else {
+        ora.info(
+          "Not authenticated. Continuing without authentication. (Run `lingo.dev auth --login` to authenticate)"
+        );
+      }
+    } catch (error) {
+      ora.info("Authentication failed. Continuing without authentication.");
+    }
+    ora.start("Validating localization configuration...");
+    validateParams2(i18nConfig, flags);
+    ora.succeed("Localization configuration is valid");
+    trackEvent(authId || "status", "cmd.status.start", {
+      i18nConfig,
+      flags
+    });
+    let buckets = getBuckets(i18nConfig);
+    if (_optionalChain([flags, 'access', _179 => _179.bucket, 'optionalAccess', _180 => _180.length])) {
+      buckets = buckets.filter((bucket) => flags.bucket.includes(bucket.type));
+    }
+    ora.succeed("Buckets retrieved");
+    if (_optionalChain([flags, 'access', _181 => _181.file, 'optionalAccess', _182 => _182.length])) {
+      buckets = buckets.map((bucket) => {
+        const paths = bucket.paths.filter((path18) => flags.file.find((file) => _optionalChain([path18, 'access', _183 => _183.pathPattern, 'optionalAccess', _184 => _184.match, 'call', _185 => _185(file)])));
+        return { ...bucket, paths };
+      }).filter((bucket) => bucket.paths.length > 0);
+      if (buckets.length === 0) {
+        ora.fail("No buckets found. All buckets were filtered out by --file option.");
+        process.exit(1);
+      } else {
+        ora.info(`\x1B[36mProcessing only filtered buckets:\x1B[0m`);
+        buckets.map((bucket) => {
+          ora.info(`  ${bucket.type}:`);
+          bucket.paths.forEach((path18) => {
+            ora.info(`    - ${path18.pathPattern}`);
+          });
+        });
+      }
+    }
+    const targetLocales = _optionalChain([flags, 'access', _186 => _186.locale, 'optionalAccess', _187 => _187.length]) ? flags.locale : i18nConfig.locale.targets;
+    let totalSourceKeyCount = 0;
+    let uniqueKeysToTranslate = 0;
+    let totalExistingTranslations = 0;
+    const totalWordCount = /* @__PURE__ */ new Map();
+    const languageStats = {};
+    for (const locale of targetLocales) {
+      languageStats[locale] = {
+        complete: 0,
+        missing: 0,
+        updated: 0,
+        words: 0
+      };
+      totalWordCount.set(locale, 0);
+    }
+    const fileStats = {};
+    for (const bucket of buckets) {
+      try {
+        console.log();
+        ora.info(`Analyzing bucket: ${bucket.type}`);
+        for (const bucketPath of bucket.paths) {
+          const bucketOra = _ora2.default.call(void 0, { indent: 2 }).info(`Analyzing path: ${bucketPath.pathPattern}`);
+          const sourceLocale = __spec.resolveOverriddenLocale.call(void 0, i18nConfig.locale.source, bucketPath.delimiter);
+          const bucketLoader = createBucketLoader(
+            bucket.type,
+            bucketPath.pathPattern,
+            {
+              isCacheRestore: false,
+              defaultLocale: sourceLocale,
+              injectLocale: bucket.injectLocale
+            },
+            bucket.lockedKeys
+          );
+          bucketLoader.setDefaultLocale(sourceLocale);
+          await bucketLoader.init();
+          const filePath = bucketPath.pathPattern;
+          if (!fileStats[filePath]) {
+            fileStats[filePath] = {
+              path: filePath,
+              sourceKeys: 0,
+              wordCount: 0,
+              languageStats: {}
+            };
+            for (const locale of targetLocales) {
+              fileStats[filePath].languageStats[locale] = {
+                complete: 0,
+                missing: 0,
+                updated: 0,
+                words: 0
+              };
+            }
+          }
+          const sourceData = await bucketLoader.pull(sourceLocale);
+          const sourceKeys = Object.keys(sourceData);
+          fileStats[filePath].sourceKeys = sourceKeys.length;
+          totalSourceKeyCount += sourceKeys.length;
+          let sourceWordCount = 0;
+          for (const key of sourceKeys) {
+            const value = sourceData[key];
+            if (typeof value === "string") {
+              const words = value.trim().split(/\s+/).length;
+              sourceWordCount += words;
+            }
+          }
+          fileStats[filePath].wordCount = sourceWordCount;
+          for (const _targetLocale of targetLocales) {
+            const targetLocale = __spec.resolveOverriddenLocale.call(void 0, _targetLocale, bucketPath.delimiter);
+            bucketOra.start(`[${sourceLocale} -> ${targetLocale}] Analyzing translation status...`);
+            let targetData = {};
+            let fileExists = true;
+            try {
+              targetData = await bucketLoader.pull(targetLocale);
+            } catch (error) {
+              fileExists = false;
+              bucketOra.info(
+                `[${sourceLocale} -> ${targetLocale}] Target file not found, assuming all keys need translation.`
+              );
+            }
+            if (!fileExists) {
+              fileStats[filePath].languageStats[targetLocale].missing = sourceKeys.length;
+              fileStats[filePath].languageStats[targetLocale].words = sourceWordCount;
+              languageStats[targetLocale].missing += sourceKeys.length;
+              languageStats[targetLocale].words += sourceWordCount;
+              totalWordCount.set(targetLocale, (totalWordCount.get(targetLocale) || 0) + sourceWordCount);
+              bucketOra.succeed(
+                `[${sourceLocale} -> ${targetLocale}] ${_chalk2.default.red(`0% complete`)} (0/${sourceKeys.length} keys) - file not found`
+              );
+              continue;
+            }
+            const deltaProcessor = createDeltaProcessor(bucketPath.pathPattern);
+            const checksums = await deltaProcessor.loadChecksums();
+            const delta = await deltaProcessor.calculateDelta({
+              sourceData,
+              targetData,
+              checksums
+            });
+            const missingKeys = delta.added;
+            const updatedKeys = delta.updated;
+            const completeKeys = sourceKeys.filter((key) => !missingKeys.includes(key) && !updatedKeys.includes(key));
+            let wordsToTranslate = 0;
+            const keysToProcess = flags.force ? sourceKeys : [...missingKeys, ...updatedKeys];
+            for (const key of keysToProcess) {
+              const value = sourceData[String(key)];
+              if (typeof value === "string") {
+                const words = value.trim().split(/\s+/).length;
+                wordsToTranslate += words;
+              }
+            }
+            fileStats[filePath].languageStats[targetLocale].missing = missingKeys.length;
+            fileStats[filePath].languageStats[targetLocale].updated = updatedKeys.length;
+            fileStats[filePath].languageStats[targetLocale].complete = completeKeys.length;
+            fileStats[filePath].languageStats[targetLocale].words = wordsToTranslate;
+            languageStats[targetLocale].missing += missingKeys.length;
+            languageStats[targetLocale].updated += updatedKeys.length;
+            languageStats[targetLocale].complete += completeKeys.length;
+            languageStats[targetLocale].words += wordsToTranslate;
+            totalWordCount.set(targetLocale, (totalWordCount.get(targetLocale) || 0) + wordsToTranslate);
+            const totalKeysInFile = sourceKeys.length;
+            const completionPercent = (completeKeys.length / totalKeysInFile * 100).toFixed(1);
+            if (missingKeys.length === 0 && updatedKeys.length === 0) {
+              bucketOra.succeed(
+                `[${sourceLocale} -> ${targetLocale}] ${_chalk2.default.green(`100% complete`)} (${completeKeys.length}/${totalKeysInFile} keys)`
+              );
+            } else {
+              const message = `[${sourceLocale} -> ${targetLocale}] ${parseFloat(completionPercent) > 50 ? _chalk2.default.yellow(`${completionPercent}% complete`) : _chalk2.default.red(`${completionPercent}% complete`)} (${completeKeys.length}/${totalKeysInFile} keys)`;
+              bucketOra.succeed(message);
+              if (flags.verbose) {
+                if (missingKeys.length > 0) {
+                  console.log(`    ${_chalk2.default.red(`Missing:`)} ${missingKeys.length} keys, ~${wordsToTranslate} words`);
+                  console.log(
+                    `    ${_chalk2.default.dim(`Example missing: ${missingKeys.slice(0, 2).join(", ")}${missingKeys.length > 2 ? "..." : ""}`)}`
+                  );
+                }
+                if (updatedKeys.length > 0) {
+                  console.log(`    ${_chalk2.default.yellow(`Updated:`)} ${updatedKeys.length} keys that changed in source`);
+                }
+              }
+            }
+          }
+        }
+      } catch (error) {
+        ora.fail(`Failed to analyze bucket ${bucket.type}: ${error.message}`);
+      }
+    }
+    const totalKeysNeedingTranslation = Object.values(languageStats).reduce((sum, stats) => {
+      return sum + stats.missing + stats.updated;
+    }, 0);
+    const totalCompletedKeys = totalSourceKeyCount - totalKeysNeedingTranslation / targetLocales.length;
+    console.log();
+    ora.succeed(_chalk2.default.green(`Localization status completed.`));
+    console.log(_chalk2.default.bold.cyan(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557`));
+    console.log(_chalk2.default.bold.cyan(`\u2551   LOCALIZATION STATUS REPORT       \u2551`));
+    console.log(_chalk2.default.bold.cyan(`\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D`));
+    console.log(_chalk2.default.bold(`
+\u{1F4DD} SOURCE CONTENT:`));
+    console.log(`\u2022 Source language: ${_chalk2.default.green(i18nConfig.locale.source)}`);
+    console.log(`\u2022 Source keys: ${_chalk2.default.yellow(totalSourceKeyCount.toString())} keys across all files`);
+    console.log(_chalk2.default.bold(`
+\u{1F310} LANGUAGE BY LANGUAGE BREAKDOWN:`));
+    const table = new (0, _clitable32.default)({
+      head: ["Language", "Status", "Complete", "Missing", "Updated", "Words"],
+      style: {
+        head: ["white"],
+        // White color for headers
+        border: []
+        // No color for borders
+      },
+      colWidths: [12, 20, 18, 12, 12, 15]
+      // Explicit column widths, making Status column wider
+    });
+    let totalWordsToTranslate = 0;
+    for (const locale of targetLocales) {
+      const stats = languageStats[locale];
+      const percentComplete = (stats.complete / totalSourceKeyCount * 100).toFixed(1);
+      let statusText;
+      let statusColor;
+      if (stats.missing === totalSourceKeyCount) {
+        statusText = "\u{1F534} Not started";
+        statusColor = _chalk2.default.red;
+      } else if (stats.missing === 0 && stats.updated === 0) {
+        statusText = "\u2705 Complete";
+        statusColor = _chalk2.default.green;
+      } else if (parseFloat(percentComplete) > 80) {
+        statusText = "\u{1F7E1} Almost done";
+        statusColor = _chalk2.default.yellow;
+      } else if (parseFloat(percentComplete) > 0) {
+        statusText = "\u{1F7E0} In progress";
+        statusColor = _chalk2.default.yellow;
+      } else {
+        statusText = "\u{1F534} Not started";
+        statusColor = _chalk2.default.red;
+      }
+      const words = totalWordCount.get(locale) || 0;
+      totalWordsToTranslate += words;
+      table.push([
+        locale,
+        statusColor(statusText),
+        `${stats.complete}/${totalSourceKeyCount} (${percentComplete}%)`,
+        stats.missing > 0 ? _chalk2.default.red(stats.missing.toString()) : "0",
+        stats.updated > 0 ? _chalk2.default.yellow(stats.updated.toString()) : "0",
+        words > 0 ? `~${words.toLocaleString()}` : "0"
+      ]);
+    }
+    console.log(table.toString());
+    console.log(_chalk2.default.bold(`
+\u{1F4CA} USAGE ESTIMATE:`));
+    console.log(
+      `\u2022 TOTAL: ~${_chalk2.default.yellow.bold(totalWordsToTranslate.toLocaleString())} words to translate across all languages`
+    );
+    if (targetLocales.length > 1) {
+      console.log(`\u2022 Per-language breakdown:`);
+      for (const locale of targetLocales) {
+        const words = totalWordCount.get(locale) || 0;
+        const percent = (words / totalWordsToTranslate * 100).toFixed(1);
+        console.log(`  - ${locale}: ~${words.toLocaleString()} words (${percent}% of total)`);
+      }
+    }
+    if (flags.confirm && Object.keys(fileStats).length > 0) {
+      console.log(_chalk2.default.bold(`
+\u{1F4D1} BREAKDOWN BY FILE:`));
+      Object.entries(fileStats).sort((a, b) => b[1].wordCount - a[1].wordCount).forEach(([path18, stats]) => {
+        if (stats.sourceKeys === 0) return;
+        console.log(_chalk2.default.bold(`
+\u2022 ${path18}:`));
+        console.log(`  ${stats.sourceKeys} source keys, ~${stats.wordCount.toLocaleString()} source words`);
+        const fileTable = new (0, _clitable32.default)({
+          head: ["Language", "Status", "Details"],
+          style: {
+            head: ["white"],
+            border: []
+          },
+          colWidths: [12, 20, 50]
+          // Explicit column widths for file detail table
+        });
+        for (const locale of targetLocales) {
+          const langStats = stats.languageStats[locale];
+          const complete = langStats.complete;
+          const total = stats.sourceKeys;
+          const completion = (complete / total * 100).toFixed(1);
+          let status = "\u2705 Complete";
+          let statusColor = _chalk2.default.green;
+          if (langStats.missing === total) {
+            status = "\u274C Not started";
+            statusColor = _chalk2.default.red;
+          } else if (langStats.missing > 0 || langStats.updated > 0) {
+            status = `\u26A0\uFE0F ${completion}% complete`;
+            statusColor = _chalk2.default.yellow;
+          }
+          let details = "";
+          if (langStats.missing > 0 || langStats.updated > 0) {
+            const parts = [];
+            if (langStats.missing > 0) parts.push(`${langStats.missing} missing`);
+            if (langStats.updated > 0) parts.push(`${langStats.updated} changed`);
+            details = `${parts.join(", ")}, ~${langStats.words} words`;
+          } else {
+            details = "All keys translated";
+          }
+          fileTable.push([locale, statusColor(status), details]);
+        }
+        console.log(fileTable.toString());
+      });
+    }
+    const completeLanguages = targetLocales.filter(
+      (locale) => languageStats[locale].missing === 0 && languageStats[locale].updated === 0
+    );
+    const missingLanguages = targetLocales.filter((locale) => languageStats[locale].complete === 0);
+    console.log(_chalk2.default.bold.green(`
+\u{1F4A1} OPTIMIZATION TIPS:`));
+    if (missingLanguages.length > 0) {
+      console.log(
+        `\u2022 ${_chalk2.default.yellow(missingLanguages.join(", "))} ${missingLanguages.length === 1 ? "has" : "have"} no translations yet`
+      );
+    }
+    if (completeLanguages.length > 0) {
+      console.log(
+        `\u2022 ${_chalk2.default.green(completeLanguages.join(", "))} ${completeLanguages.length === 1 ? "is" : "are"} completely translated`
+      );
+    }
+    if (targetLocales.length > 1) {
+      console.log(`\u2022 Translating one language at a time reduces complexity`);
+      console.log(`\u2022 Try 'lingo.dev@latest i18n --locale ${targetLocales[0]}' to process just one language`);
+    }
+    trackEvent(authId || "status", "cmd.status.success", {
+      i18nConfig,
+      flags,
+      totalSourceKeyCount,
+      languageStats,
+      totalWordsToTranslate,
+      authenticated: !!authId
+    });
+  } catch (error) {
+    ora.fail(error.message);
+    trackEvent(authId || "status", "cmd.status.error", {
+      flags,
+      error: error.message,
+      authenticated: !!authId
+    });
+    process.exit(1);
+  }
+});
+function parseFlags2(options) {
+  return _zod2.default.object({
+    locale: _zod2.default.array(__spec.localeCodeSchema).optional(),
+    bucket: _zod2.default.array(__spec.bucketTypeSchema).optional(),
+    force: _zod2.default.boolean().optional(),
+    confirm: _zod2.default.boolean().optional(),
+    verbose: _zod2.default.boolean().optional(),
+    file: _zod2.default.array(_zod2.default.string()).optional(),
+    apiKey: _zod2.default.string().optional()
+  }).parse(options);
+}
+async function tryAuthenticate(settings) {
+  if (!settings.auth.apiKey) {
+    return null;
+  }
+  try {
+    const authenticator = createAuthenticator({
+      apiKey: settings.auth.apiKey,
+      apiUrl: settings.auth.apiUrl
+    });
+    const user = await authenticator.whoami();
+    return user;
+  } catch (error) {
+    return null;
+  }
+}
+function validateParams2(i18nConfig, flags) {
+  if (!i18nConfig) {
+    throw new CLIError({
+      message: "i18n.json not found. Please run `lingo.dev init` to initialize the project.",
+      docUrl: "i18nNotFound"
+    });
+  } else if (!i18nConfig.buckets || !Object.keys(i18nConfig.buckets).length) {
+    throw new CLIError({
+      message: "No buckets found in i18n.json. Please add at least one bucket containing i18n content.",
+      docUrl: "bucketNotFound"
+    });
+  } else if (_optionalChain([flags, 'access', _188 => _188.locale, 'optionalAccess', _189 => _189.some, 'call', _190 => _190((locale) => !i18nConfig.locale.targets.includes(locale))])) {
+    throw new CLIError({
+      message: `One or more specified locales do not exist in i18n.json locale.targets. Please add them to the list and try again.`,
+      docUrl: "localeTargetNotFound"
+    });
+  } else if (_optionalChain([flags, 'access', _191 => _191.bucket, 'optionalAccess', _192 => _192.some, 'call', _193 => _193((bucket) => !i18nConfig.buckets[bucket])])) {
+    throw new CLIError({
+      message: `One or more specified buckets do not exist in i18n.json. Please add them to the list and try again.`,
+      docUrl: "bucketNotFound"
+    });
+  }
+}
+
 // package.json
 var package_default = {
   name: "lingo.dev",
-  version: "0.83.0",
+  version: "0.85.0",
   description: "Lingo.dev CLI",
   private: false,
   publishConfig: {
@@ -5097,6 +5598,7 @@ var package_default = {
     ai: "^4.3.2",
     bitbucket: "^2.12.0",
     chalk: "^5.4.1",
+    "cli-table3": "^0.6.5",
     cors: "^2.8.5",
     "csv-parse": "^5.6.0",
     "csv-stringify": "^6.5.2",
@@ -5202,7 +5704,7 @@ ${_gradientstring.vice.call(void 0,
 
 Star the the repo :) https://github.com/LingoDotDev/lingo.dev
 `
-).version(`v${package_default.version}`, "-v, --version", "Show version").addCommand(init_default).interactive("-y, --no-interactive", "Disable interactive mode").addCommand(i18n_default).addCommand(auth_default).addCommand(show_default).addCommand(lockfile_default).addCommand(cleanup_default).addCommand(mcp_default).addCommand(ci_default).exitOverride((err) => {
+).version(`v${package_default.version}`, "-v, --version", "Show version").addCommand(init_default).interactive("-y, --no-interactive", "Disable interactive mode").addCommand(i18n_default).addCommand(auth_default).addCommand(show_default).addCommand(lockfile_default).addCommand(cleanup_default).addCommand(mcp_default).addCommand(ci_default).addCommand(status_default).exitOverride((err) => {
   if (err.code === "commander.helpDisplayed" || err.code === "commander.version" || err.code === "commander.help") {
     process.exit(0);
   }