lingo.dev 0.84.0 → 0.85.1

package/build/cli.mjs

@@ -3088,10 +3088,7 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createAndroidLoader(),
         createFlatLoader(),
         createSyncLoader(),
-        createUnlocalizableLoader(
-          options.isCacheRestore,
-          options.returnUnlocalizedKeys
-        )
+        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
       );
     case "csv":
       return composeLoaders(
@@ -3099,10 +3096,7 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createCsvLoader(),
         createFlatLoader(),
         createSyncLoader(),
-        createUnlocalizableLoader(
-          options.isCacheRestore,
-          options.returnUnlocalizedKeys
-        )
+        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
       );
     case "html":
       return composeLoaders(
@@ -3110,10 +3104,7 @@ 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(
@@ -3124,10 +3115,7 @@ 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(
@@ -3135,10 +3123,7 @@ 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(
@@ -3149,19 +3134,6 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createFlatLoader(),
         createMdxStructureLoader(),
         createSyncLoader(),
-        createUnlocalizableLoader(
-          options.isCacheRestore,
-          options.returnUnlocalizedKeys
-        )
-      );
-    case "mdx":
-      return composeLoaders(
-        createTextFileLoader(bucketPathPattern),
-        createPrettierLoader({ parser: "mdx", bucketPathPattern }),
-        createMdxFormatLoader(),
-        createFlatLoader(),
-        createMdxStructureLoader(),
-        createSyncLoader(),
         createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
       );
     case "po":
@@ -3171,30 +3143,21 @@ 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(
@@ -3202,10 +3165,7 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createXcodeStringsdictLoader(),
         createFlatLoader(),
         createSyncLoader(),
-        createUnlocalizableLoader(
-          options.isCacheRestore,
-          options.returnUnlocalizedKeys
-        )
+        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
       );
     case "xcode-xcstrings":
       return composeLoaders(
@@ -3216,10 +3176,7 @@ 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(
@@ -3229,10 +3186,7 @@ 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(
@@ -3242,10 +3196,7 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createRootKeyLoader(true),
         createFlatLoader(),
         createSyncLoader(),
-        createUnlocalizableLoader(
-          options.isCacheRestore,
-          options.returnUnlocalizedKeys
-        )
+        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
       );
     case "flutter":
       return composeLoaders(
@@ -3255,10 +3206,7 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createFlutterLoader(),
         createFlatLoader(),
         createSyncLoader(),
-        createUnlocalizableLoader(
-          options.isCacheRestore,
-          options.returnUnlocalizedKeys
-        )
+        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
       );
     case "xliff":
       return composeLoaders(
@@ -3266,10 +3214,7 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createXliffLoader(),
         createFlatLoader(),
         createSyncLoader(),
-        createUnlocalizableLoader(
-          options.isCacheRestore,
-          options.returnUnlocalizedKeys
-        )
+        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
       );
     case "xml":
       return composeLoaders(
@@ -3277,40 +3222,28 @@ 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(
@@ -3318,10 +3251,7 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createPhpLoader(),
         createSyncLoader(),
         createFlatLoader(),
-        createUnlocalizableLoader(
-          options.isCacheRestore,
-          options.returnUnlocalizedKeys
-        )
+        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
       );
     case "vue-json":
       return composeLoaders(
@@ -3329,10 +3259,7 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys)
         createVueJsonLoader(),
         createSyncLoader(),
         createFlatLoader(),
-        createUnlocalizableLoader(
-          options.isCacheRestore,
-          options.returnUnlocalizedKeys
-        )
+        createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
       );
   }
 }
@@ -5111,10 +5038,427 @@ var ci_default = new Command10().command("ci").description("Run Lingo.dev CI/CD
   main();
 });
 
+// src/cli/cmd/status.ts
+import { bucketTypeSchema as bucketTypeSchema3, localeCodeSchema as localeCodeSchema2, resolveOverriddenLocale as resolveOverriddenLocale6 } from "@lingo.dev/_spec";
+import { Command as Command11 } from "interactive-commander";
+import Z11 from "zod";
+import Ora8 from "ora";
+import chalk2 from "chalk";
+import Table from "cli-table3";
+var status_default = new Command11().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 = Ora8();
+  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 (flags.bucket?.length) {
+      buckets = buckets.filter((bucket) => flags.bucket.includes(bucket.type));
+    }
+    ora.succeed("Buckets retrieved");
+    if (flags.file?.length) {
+      buckets = buckets.map((bucket) => {
+        const paths = bucket.paths.filter((path18) => flags.file.find((file) => path18.pathPattern?.match(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 = flags.locale?.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 = Ora8({ indent: 2 }).info(`Analyzing path: ${bucketPath.pathPattern}`);
+          const sourceLocale = resolveOverriddenLocale6(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 = resolveOverriddenLocale6(_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.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.green(`100% complete`)} (${completeKeys.length}/${totalKeysInFile} keys)`
+              );
+            } else {
+              const message = `[${sourceLocale} -> ${targetLocale}] ${parseFloat(completionPercent) > 50 ? chalk2.yellow(`${completionPercent}% complete`) : chalk2.red(`${completionPercent}% complete`)} (${completeKeys.length}/${totalKeysInFile} keys)`;
+              bucketOra.succeed(message);
+              if (flags.verbose) {
+                if (missingKeys.length > 0) {
+                  console.log(`    ${chalk2.red(`Missing:`)} ${missingKeys.length} keys, ~${wordsToTranslate} words`);
+                  console.log(
+                    `    ${chalk2.dim(`Example missing: ${missingKeys.slice(0, 2).join(", ")}${missingKeys.length > 2 ? "..." : ""}`)}`
+                  );
+                }
+                if (updatedKeys.length > 0) {
+                  console.log(`    ${chalk2.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.green(`Localization status completed.`));
+    console.log(chalk2.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.bold.cyan(`\u2551   LOCALIZATION STATUS REPORT       \u2551`));
+    console.log(chalk2.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.bold(`
+\u{1F4DD} SOURCE CONTENT:`));
+    console.log(`\u2022 Source language: ${chalk2.green(i18nConfig.locale.source)}`);
+    console.log(`\u2022 Source keys: ${chalk2.yellow(totalSourceKeyCount.toString())} keys across all files`);
+    console.log(chalk2.bold(`
+\u{1F310} LANGUAGE BY LANGUAGE BREAKDOWN:`));
+    const table = new Table({
+      head: ["Language", "Status", "Complete", "Missing", "Updated", "Total Keys", "Words to Translate"],
+      style: {
+        head: ["white"],
+        // White color for headers
+        border: []
+        // No color for borders
+      },
+      colWidths: [12, 20, 18, 12, 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);
+      const totalNeeded = stats.missing + stats.updated;
+      let statusText;
+      let statusColor;
+      if (stats.missing === totalSourceKeyCount) {
+        statusText = "\u{1F534} Not started";
+        statusColor = chalk2.red;
+      } else if (stats.missing === 0 && stats.updated === 0) {
+        statusText = "\u2705 Complete";
+        statusColor = chalk2.green;
+      } else if (parseFloat(percentComplete) > 80) {
+        statusText = "\u{1F7E1} Almost done";
+        statusColor = chalk2.yellow;
+      } else if (parseFloat(percentComplete) > 0) {
+        statusText = "\u{1F7E0} In progress";
+        statusColor = chalk2.yellow;
+      } else {
+        statusText = "\u{1F534} Not started";
+        statusColor = chalk2.red;
+      }
+      const words = totalWordCount.get(locale) || 0;
+      totalWordsToTranslate += words;
+      table.push([
+        locale,
+        statusColor(statusText),
+        `${stats.complete}/${totalSourceKeyCount} (${percentComplete}%)`,
+        stats.missing > 0 ? chalk2.red(stats.missing.toString()) : "0",
+        stats.updated > 0 ? chalk2.yellow(stats.updated.toString()) : "0",
+        totalNeeded > 0 ? chalk2.magenta(totalNeeded.toString()) : "0",
+        words > 0 ? `~${words.toLocaleString()}` : "0"
+      ]);
+    }
+    console.log(table.toString());
+    console.log(chalk2.bold(`
+\u{1F4CA} USAGE ESTIMATE:`));
+    console.log(
+      `\u2022 WORDS TO BE CONSUMED: ~${chalk2.yellow.bold(totalWordsToTranslate.toLocaleString())} words across all languages`
+    );
+    console.log(`  (Words are counted from source language for keys that need translation in target 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.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.bold(`
+\u2022 ${path18}:`));
+        console.log(`  ${stats.sourceKeys} source keys, ~${stats.wordCount.toLocaleString()} source words`);
+        const fileTable = new Table({
+          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.green;
+          if (langStats.missing === total) {
+            status = "\u274C Not started";
+            statusColor = chalk2.red;
+          } else if (langStats.missing > 0 || langStats.updated > 0) {
+            status = `\u26A0\uFE0F ${completion}% complete`;
+            statusColor = chalk2.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.bold.green(`
+\u{1F4A1} OPTIMIZATION TIPS:`));
+    if (missingLanguages.length > 0) {
+      console.log(
+        `\u2022 ${chalk2.yellow(missingLanguages.join(", "))} ${missingLanguages.length === 1 ? "has" : "have"} no translations yet`
+      );
+    }
+    if (completeLanguages.length > 0) {
+      console.log(
+        `\u2022 ${chalk2.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 Z11.object({
+    locale: Z11.array(localeCodeSchema2).optional(),
+    bucket: Z11.array(bucketTypeSchema3).optional(),
+    force: Z11.boolean().optional(),
+    confirm: Z11.boolean().optional(),
+    verbose: Z11.boolean().optional(),
+    file: Z11.array(Z11.string()).optional(),
+    apiKey: Z11.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 (flags.locale?.some((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 (flags.bucket?.some((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.84.0",
+  version: "0.85.1",
   description: "Lingo.dev CLI",
   private: false,
   publishConfig: {
@@ -5184,6 +5528,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",
@@ -5289,7 +5634,7 @@ ${vice(
 
 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);
   }