fix: retranslation with run command (#1208)

* fix: use initial checksums for all retranslation buckets

* chore: add changeset

* chore: fix formatting

Author: vrcprl

.changeset/six-forks-bathe.md

@@ -0,0 +1,5 @@
+---
+"lingo.dev": patch
+---
+
+Fix run retranslation with run command

packages/cli/src/cli/cmd/run/_types.ts

@@ -18,6 +18,9 @@ export type CmdRunContext = {
 export type CmdRunTaskResult = {
   status: "success" | "error" | "skipped";
   error?: Error;
+  pathPattern?: string;
+  sourceLocale?: string;
+  targetLocale?: string;
 };
 
 export type CmdRunTask = {

packages/cli/src/cli/cmd/run/execute.ts

@@ -34,13 +34,24 @@ export default async function execute(input: CmdRunContext) {
         title: `Processing localization tasks ${chalk.dim(
           `(tasks: ${input.tasks.length}, concurrency: ${effectiveConcurrency})`,
         )}`,
-        task: (ctx, task) => {
+        task: async (ctx, task) => {
           if (input.tasks.length < 1) {
             task.title = `Skipping, nothing to localize.`;
             task.skip();
             return;
           }
 
+          // Preload checksums for all unique bucket path patterns before starting any workers
+          const initialChecksumsMap = new Map<string, Record<string, string>>();
+          const uniqueBucketPatterns = _.uniq(
+            ctx.tasks.map((t) => t.bucketPathPattern),
+          );
+          for (const bucketPathPattern of uniqueBucketPatterns) {
+            const deltaProcessor = createDeltaProcessor(bucketPathPattern);
+            const checksums = await deltaProcessor.loadChecksums();
+            initialChecksumsMap.set(bucketPathPattern, checksums);
+          }
+
           const i18nLimiter = pLimit(effectiveConcurrency);
           const ioLimiter = pLimit(1);
           const workersCount = effectiveConcurrency;
@@ -56,6 +67,7 @@ export default async function execute(input: CmdRunContext) {
                 assignedTasks,
                 ioLimiter,
                 i18nLimiter,
+                initialChecksumsMap,
                 onDone() {
                   task.title = createExecutionProgressMessage(ctx);
                 },
@@ -140,6 +152,7 @@ function createWorkerTask(args: {
   ioLimiter: LimitFunction;
   i18nLimiter: LimitFunction;
   onDone: () => void;
+  initialChecksumsMap: Map<string, Record<string, string>>;
 }): ListrTask {
   return {
     title: "Initializing...",
@@ -154,6 +167,10 @@ function createWorkerTask(args: {
           assignedTask.bucketPathPattern,
         );
 
+        // Get initial checksums from the preloaded map
+        const initialChecksums =
+          args.initialChecksumsMap.get(assignedTask.bucketPathPattern) || {};
+
         const taskResult = await args.i18nLimiter(async () => {
           try {
             const sourceData = await bucketLoader.pull(
@@ -163,11 +180,10 @@ function createWorkerTask(args: {
             const targetData = await bucketLoader.pull(
               assignedTask.targetLocale,
             );
-            const checksums = await deltaProcessor.loadChecksums();
             const delta = await deltaProcessor.calculateDelta({
               sourceData,
               targetData,
-              checksums,
+              checksums: initialChecksums,
             });
 
             const processableData = _.chain(sourceData)
@@ -193,7 +209,12 @@ function createWorkerTask(args: {
                 // re-push in case some of the unlocalizable / meta data changed
                 await bucketLoader.push(assignedTask.targetLocale, targetData);
               });
-              return { status: "skipped" } satisfies CmdRunTaskResult;
+              return {
+                status: "skipped",
+                pathPattern: assignedTask.bucketPathPattern,
+                sourceLocale: assignedTask.sourceLocale,
+                targetLocale: assignedTask.targetLocale,
+              } satisfies CmdRunTaskResult;
             }
 
             const relevantHints = _.pick(hints, Object.keys(processableData));
@@ -268,11 +289,19 @@ function createWorkerTask(args: {
               }
             });
 
-            return { status: "success" } satisfies CmdRunTaskResult;
+            return {
+              status: "success",
+              pathPattern: assignedTask.bucketPathPattern,
+              sourceLocale: assignedTask.sourceLocale,
+              targetLocale: assignedTask.targetLocale,
+            } satisfies CmdRunTaskResult;
           } catch (error) {
             return {
               status: "error",
               error: error as Error,
+              pathPattern: assignedTask.bucketPathPattern,
+              sourceLocale: assignedTask.sourceLocale,
+              targetLocale: assignedTask.targetLocale,
             } satisfies CmdRunTaskResult;
           }
         });

packages/cli/src/cli/utils/ui.ts

@@ -77,28 +77,62 @@ export async function pauseIfDebug(debug: boolean) {
 export async function renderSummary(results: Map<any, any>) {
   console.log(chalk.hex(colors.green)("[Done]"));
 
-  const skippedTasksCount = Array.from(results.values()).filter(
+  const skippedResults = Array.from(results.values()).filter(
     (r) => r.status === "skipped",
-  ).length;
-  console.log(`• ${chalk.hex(colors.yellow)(skippedTasksCount)} from cache`);
-
-  const succeededTasksCount = Array.from(results.values()).filter(
+  );
+  const succeededResults = Array.from(results.values()).filter(
     (r) => r.status === "success",
-  ).length;
-  console.log(`• ${chalk.hex(colors.yellow)(succeededTasksCount)} processed`);
-
-  const failedTasksCount = Array.from(results.values()).filter(
+  );
+  const failedResults = Array.from(results.values()).filter(
     (r) => r.status === "error",
-  ).length;
-  console.log(`• ${chalk.hex(colors.yellow)(failedTasksCount)} failed`);
+  );
+
+  console.log(
+    `• ${chalk.hex(colors.yellow)(skippedResults.length)} from cache`,
+  );
+  console.log(
+    `• ${chalk.hex(colors.yellow)(succeededResults.length)} processed`,
+  );
+  console.log(`• ${chalk.hex(colors.yellow)(failedResults.length)} failed`);
+
+  // Show processed files
+  if (succeededResults.length > 0) {
+    console.log(chalk.hex(colors.green)("\n[Processed Files]"));
+    for (const result of succeededResults) {
+      const displayPath =
+        result.pathPattern?.replace("[locale]", result.targetLocale) ||
+        "unknown";
+      console.log(
+        `  ✓ ${chalk.dim(displayPath)} ${chalk.hex(colors.yellow)(`(${result.sourceLocale} → ${result.targetLocale})`)}`,
+      );
+    }
+  }
 
-  if (failedTasksCount > 0) {
-    console.log(chalk.hex(colors.orange)("\n[Failed]"));
-    for (const result of Array.from(results.values()).filter(
-      (r) => r.status === "error",
-    )) {
+  // Show cached files
+  if (skippedResults.length > 0) {
+    console.log(chalk.hex(colors.blue)("\n[Cached Files]"));
+    for (const result of skippedResults) {
+      const displayPath =
+        result.pathPattern?.replace("[locale]", result.targetLocale) ||
+        "unknown";
+      console.log(
+        `  ⚡ ${chalk.dim(displayPath)} ${chalk.hex(colors.yellow)(`(${result.sourceLocale} → ${result.targetLocale})`)}`,
+      );
+    }
+  }
+
+  // Show failed files
+  if (failedResults.length > 0) {
+    console.log(chalk.hex(colors.orange)("\n[Failed Files]"));
+    for (const result of failedResults) {
+      const displayPath =
+        result.pathPattern?.replace("[locale]", result.targetLocale) ||
+        "unknown";
+      console.log(
+        `  ❌ ${chalk.dim(displayPath)} ${chalk.hex(colors.yellow)(`(${result.sourceLocale} → ${result.targetLocale})`)}`,
+      );
       console.log(
-        `❌ ${chalk.hex(colors.white)(String(result.error.message))}\n`,
+        `     ${chalk.hex(colors.white)(String(result.error?.message || "Unknown error"))}`,
       );
     }
   }