lingo.dev 0.80.1 → 0.82.0

package/build/cli.mjs

@@ -621,9 +621,9 @@ function makeGitlabInitializer(spinner) {
 
 // src/cli/cmd/init.ts
 import open2 from "open";
-var openUrl = (path15) => {
+var openUrl = (path18) => {
   const settings = getSettings(void 0);
-  open2(`${settings.auth.webUrl}${path15}`, { wait: false });
+  open2(`${settings.auth.webUrl}${path18}`, { wait: false });
 };
 var throwHelpError = (option, value) => {
   if (value === "help") {
@@ -862,6 +862,9 @@ function getBuckets(i18nConfig) {
     if (bucketEntry.injectLocale) {
       config.injectLocale = bucketEntry.injectLocale;
     }
+    if (bucketEntry.lockedKeys) {
+      config.lockedKeys = bucketEntry.lockedKeys;
+    }
     return config;
   });
   return result;
@@ -967,8 +970,8 @@ var files_default = new Command4().command("files").description("Print out the l
           } else if (type.target) {
             result.push(...targetPaths);
           }
-          result.forEach((path15) => {
-            console.log(path15);
+          result.forEach((path18) => {
+            console.log(path18);
           });
         }
       }
@@ -990,8 +993,9 @@ var show_default = new Command5().command("show").description("Prints out the cu
 // src/cli/cmd/i18n.ts
 import { bucketTypeSchema, localeCodeSchema, resolveOverriddenLocale as resolveOverriddenLocale3 } from "@lingo.dev/_spec";
 import { Command as Command6 } from "interactive-commander";
-import Z4 from "zod";
-import _20 from "lodash";
+import Z3 from "zod";
+import _21 from "lodash";
+import * as path15 from "path";
 import Ora5 from "ora";
 
 // src/cli/loaders/_utils.ts
@@ -1198,7 +1202,7 @@ function createTextFileLoader(pathPattern) {
       const trimmedResult = result.trim();
       return trimmedResult;
     },
-    async push(locale, data, _22, originalLocale) {
+    async push(locale, data, _24, originalLocale) {
       const draftPath = pathPattern.replaceAll("[locale]", locale);
       const finalPath = path10.resolve(draftPath);
       const dirPath = path10.dirname(finalPath);
@@ -1535,9 +1539,9 @@ function createHtmlLoader() {
         const bDepth = b.split("/").length;
         return aDepth - bDepth;
       });
-      paths.forEach((path15) => {
-        const value = data[path15];
-        const [nodePath, attribute] = path15.split("#");
+      paths.forEach((path18) => {
+        const value = data[path18];
+        const [nodePath, attribute] = path18.split("#");
         const [rootTag, ...indices] = nodePath.split("/");
         let parent = rootTag === "head" ? document.head : document.body;
         let current = parent;
@@ -1640,7 +1644,7 @@ function createPropertiesLoader() {
       return result;
     },
     async push(locale, payload) {
-      const result = Object.entries(payload).filter(([_22, value]) => value != null).map(([key, value]) => `${key}=${value}`).join("\n");
+      const result = Object.entries(payload).filter(([_24, value]) => value != null).map(([key, value]) => `${key}=${value}`).join("\n");
       return result;
     }
   });
@@ -1889,10 +1893,10 @@ function createUnlocalizableLoader(isCacheRestore = false, returnUnlocalizedKeys
           }
         }
         return false;
-      }).map(([key, _22]) => key);
-      const result = _10.omitBy(input2, (_22, key) => passthroughKeys.includes(key));
+      }).map(([key, _24]) => key);
+      const result = _10.omitBy(input2, (_24, key) => passthroughKeys.includes(key));
       if (returnUnlocalizedKeys) {
-        result.unlocalizable = _10.omitBy(input2, (_22, key) => !passthroughKeys.includes(key));
+        result.unlocalizable = _10.omitBy(input2, (_24, key) => !passthroughKeys.includes(key));
       }
       return result;
     },
@@ -2583,18 +2587,18 @@ function createRawDatoValue(parsedDatoValue, originalRawDatoValue, isClean = fal
 }
 function serializeStructuredText(rawStructuredText) {
   return serializeStructuredTextNode(rawStructuredText);
-  function serializeStructuredTextNode(node, path15 = [], acc = {}) {
+  function serializeStructuredTextNode(node, path18 = [], acc = {}) {
     if ("document" in node) {
-      return serializeStructuredTextNode(node.document, [...path15, "document"], acc);
+      return serializeStructuredTextNode(node.document, [...path18, "document"], acc);
     }
     if (!_15.isNil(node.value)) {
-      acc[[...path15, "value"].join(".")] = node.value;
+      acc[[...path18, "value"].join(".")] = node.value;
     } else if (_15.get(node, "type") === "block") {
-      acc[[...path15, "item"].join(".")] = serializeBlock(node.item);
+      acc[[...path18, "item"].join(".")] = serializeBlock(node.item);
     }
     if (node.children) {
       for (let i = 0; i < node.children.length; i++) {
-        serializeStructuredTextNode(node.children[i], [...path15, i.toString()], acc);
+        serializeStructuredTextNode(node.children[i], [...path18, i.toString()], acc);
       }
     }
     return acc;
@@ -2653,8 +2657,8 @@ function deserializeBlockList(parsedBlockList, originalRawBlockList, isClean = f
 }
 function deserializeStructuredText(parsedStructuredText, originalRawStructuredText) {
   const result = _15.cloneDeep(originalRawStructuredText);
-  for (const [path15, value] of _15.entries(parsedStructuredText)) {
-    const realPath = _15.chain(path15.split(".")).flatMap((s) => !_15.isNaN(_15.toNumber(s)) ? ["children", s] : s).value();
+  for (const [path18, value] of _15.entries(parsedStructuredText)) {
+    const realPath = _15.chain(path18.split(".")).flatMap((s) => !_15.isNaN(_15.toNumber(s)) ? ["children", s] : s).value();
     const deserializedValue = createRawDatoValue(value, _15.get(originalRawStructuredText, realPath), true);
     _15.set(result, realPath, deserializedValue);
   }
@@ -3005,8 +3009,24 @@ function createInjectLocaleLoader(injectLocaleKeys) {
   });
 }
 
+// src/cli/loaders/locked-keys.ts
+import _19 from "lodash";
+function createLockedKeysLoader(lockedKeys, isCacheRestore = false) {
+  return createLoader({
+    pull: async (locale, data) => _19.chain(data).pickBy((value, key) => !lockedKeys.includes(key)).value(),
+    push: async (locale, data, originalInput) => {
+      const lockedSubObject = _19.chain(originalInput).pickBy((value, key) => lockedKeys.includes(key)).value();
+      if (isCacheRestore) {
+        return _19.merge({}, data, lockedSubObject);
+      } else {
+        return _19.merge({}, originalInput, data, lockedSubObject);
+      }
+    }
+  });
+}
+
 // src/cli/loaders/index.ts
-function createBucketLoader(bucketType, bucketPathPattern, options) {
+function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys) {
   switch (bucketType) {
     default:
       throw new Error(`Unsupported bucket type: ${bucketType}`);
@@ -3041,6 +3061,7 @@ function createBucketLoader(bucketType, bucketPathPattern, options) {
         createJsonLoader(),
         createInjectLocaleLoader(options.injectLocale),
         createFlatLoader(),
+        createLockedKeysLoader(lockedKeys || [], options.isCacheRestore),
         createSyncLoader(),
         createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
       );
@@ -3100,6 +3121,7 @@ function createBucketLoader(bucketType, bucketPathPattern, options) {
         createPrettierLoader({ parser: "yaml", bucketPathPattern }),
         createYamlLoader(),
         createFlatLoader(),
+        createLockedKeysLoader(lockedKeys || [], options.isCacheRestore),
         createSyncLoader(),
         createUnlocalizableLoader(options.isCacheRestore, options.returnUnlocalizedKeys)
       );
@@ -3179,75 +3201,6 @@ function createBucketLoader(bucketType, bucketPathPattern, options) {
   }
 }
 
-// src/cli/utils/lockfile.ts
-import fs10 from "fs";
-import path12 from "path";
-import Z3 from "zod";
-import YAML3 from "yaml";
-import { MD5 } from "object-hash";
-import _19 from "lodash";
-function createLockfileHelper() {
-  return {
-    isLockfileExists: () => {
-      const lockfilePath = _getLockfilePath();
-      return fs10.existsSync(lockfilePath);
-    },
-    registerSourceData: (pathPattern, sourceData) => {
-      const lockfile = _loadLockfile();
-      const sectionKey = MD5(pathPattern);
-      const sectionChecksums = _19.mapValues(sourceData, (value) => MD5(value));
-      lockfile.checksums[sectionKey] = sectionChecksums;
-      _saveLockfile(lockfile);
-    },
-    registerPartialSourceData: (pathPattern, partialSourceData) => {
-      const lockfile = _loadLockfile();
-      const sectionKey = MD5(pathPattern);
-      const sectionChecksums = _19.mapValues(partialSourceData, (value) => MD5(value));
-      lockfile.checksums[sectionKey] = _19.merge({}, lockfile.checksums[sectionKey] ?? {}, sectionChecksums);
-      _saveLockfile(lockfile);
-    },
-    extractUpdatedData: (pathPattern, sourceData) => {
-      const lockfile = _loadLockfile();
-      const sectionKey = MD5(pathPattern);
-      const currentChecksums = _19.mapValues(sourceData, (value) => MD5(value));
-      const savedChecksums = lockfile.checksums[sectionKey] || {};
-      const updatedData = _19.pickBy(sourceData, (value, key) => savedChecksums[key] !== currentChecksums[key]);
-      return updatedData;
-    }
-  };
-  function _loadLockfile() {
-    const lockfilePath = _getLockfilePath();
-    if (!fs10.existsSync(lockfilePath)) {
-      return LockfileSchema.parse({});
-    }
-    const content = fs10.readFileSync(lockfilePath, "utf-8");
-    const result = LockfileSchema.parse(YAML3.parse(content));
-    return result;
-  }
-  function _saveLockfile(lockfile) {
-    const lockfilePath = _getLockfilePath();
-    const content = YAML3.stringify(lockfile);
-    fs10.writeFileSync(lockfilePath, content);
-  }
-  function _getLockfilePath() {
-    return path12.join(process.cwd(), "i18n.lock");
-  }
-}
-var LockfileSchema = Z3.object({
-  version: Z3.literal(1).default(1),
-  checksums: Z3.record(
-    Z3.string(),
-    // localizable files' keys
-    Z3.record(
-      // checksums hashmap
-      Z3.string(),
-      // key
-      Z3.string()
-      // checksum of the key's value in the source locale
-    ).default({})
-  ).default({})
-});
-
 // src/cli/cmd/i18n.ts
 import chalk from "chalk";
 import { createTwoFilesPatch } from "diff";
@@ -3255,8 +3208,8 @@ import inquirer2 from "inquirer";
 import externalEditor from "external-editor";
 
 // src/cli/utils/cache.ts
-import path13 from "path";
-import fs11 from "fs";
+import path12 from "path";
+import fs10 from "fs";
 var cacheChunk = (targetLocale, sourceChunk, processedChunk) => {
   const rows = Object.entries(sourceChunk).map(([key, source]) => ({
     targetLocale,
@@ -3286,26 +3239,26 @@ function getNormalizedCache() {
 function deleteCache() {
   const cacheFilePath = _getCacheFilePath();
   try {
-    fs11.unlinkSync(cacheFilePath);
+    fs10.unlinkSync(cacheFilePath);
   } catch (e) {
   }
 }
 function _loadCache() {
   const cacheFilePath = _getCacheFilePath();
-  if (!fs11.existsSync(cacheFilePath)) {
+  if (!fs10.existsSync(cacheFilePath)) {
     return [];
   }
-  const content = fs11.readFileSync(cacheFilePath, "utf-8");
+  const content = fs10.readFileSync(cacheFilePath, "utf-8");
   const result = _parseJSONLines(content);
   return result;
 }
 function _appendToCache(rows) {
   const cacheFilePath = _getCacheFilePath();
   const lines = _buildJSONLines(rows);
-  fs11.appendFileSync(cacheFilePath, lines);
+  fs10.appendFileSync(cacheFilePath, lines);
 }
 function _getCacheFilePath() {
-  return path13.join(process.cwd(), "i18n.cache");
+  return path12.join(process.cwd(), "i18n.cache");
 }
 function _buildJSONLines(rows) {
   return rows.map((row) => JSON.stringify(row)).join("\n") + "\n";
@@ -3325,6 +3278,9 @@ function _tryParseJSON(line) {
 import { LingoDotDevEngine } from "@lingo.dev/_sdk";
 function createLingoLocalizer(params) {
   return async (input2, onProgress) => {
+    if (!Object.keys(input2.processableData).length) {
+      return input2.processableData;
+    }
     const lingo = new LingoDotDevEngine({
       apiKey: params.apiKey,
       apiUrl: params.apiUrl
@@ -3345,10 +3301,13 @@ function createLingoLocalizer(params) {
   };
 }
 
-// src/cli/processor/openai.ts
+// src/cli/processor/basic.ts
 import { generateText } from "ai";
 function createBasicTranslator(model, systemPrompt) {
   return async (input2, onProgress) => {
+    if (!Object.keys(input2.processableData).length) {
+      return input2.processableData;
+    }
     if (!process.env.OPENAI_API_KEY) {
       throw new Error("OPENAI_API_KEY is not set");
     }
@@ -3393,7 +3352,7 @@ function createBasicTranslator(model, systemPrompt) {
       ]
     });
     const result = JSON.parse(response.text);
-    return result;
+    return result?.data || {};
   };
 }
 
@@ -3454,20 +3413,141 @@ async function trackEvent(distinctId, event, properties) {
   if (process.env.DO_NOT_TRACK) {
     return;
   }
-  const posthog = new PostHog("phc_eR0iSoQufBxNY36k0f0T15UvHJdTfHlh8rJcxsfhfXk", {
-    host: "https://eu.i.posthog.com",
-    flushAt: 1,
-    flushInterval: 0
-  });
-  await posthog.capture({
-    distinctId,
-    event,
-    properties
-  });
-  await posthog.shutdown();
+  try {
+    const posthog = new PostHog("phc_eR0iSoQufBxNY36k0f0T15UvHJdTfHlh8rJcxsfhfXk", {
+      host: "https://eu.i.posthog.com",
+      flushAt: 1,
+      flushInterval: 0
+    });
+    await posthog.capture({
+      distinctId,
+      event,
+      properties: {
+        ...properties,
+        meta: {
+          version: process.env.npm_package_version,
+          isCi: process.env.CI === "true"
+        }
+      }
+    });
+    await posthog.shutdown();
+  } catch (error) {
+    if (process.env.DEBUG) {
+      console.error(error);
+    }
+  }
+}
+
+// src/cli/utils/delta.ts
+import _20 from "lodash";
+import z from "zod";
+import { MD5 } from "object-hash";
+
+// src/cli/utils/fs.ts
+import * as fs11 from "fs";
+import * as path13 from "path";
+function tryReadFile(filePath, defaultValue = null) {
+  try {
+    const content = fs11.readFileSync(filePath, "utf-8");
+    return content;
+  } catch (error) {
+    return defaultValue;
+  }
+}
+function writeFile(filePath, content) {
+  const dir = path13.dirname(filePath);
+  if (!fs11.existsSync(dir)) {
+    fs11.mkdirSync(dir, { recursive: true });
+  }
+  fs11.writeFileSync(filePath, content);
+}
+function checkIfFileExists(filePath) {
+  return fs11.existsSync(filePath);
+}
+
+// src/cli/utils/delta.ts
+import * as path14 from "path";
+import YAML3 from "yaml";
+var LockSchema = z.object({
+  version: z.literal(1).default(1),
+  checksums: z.record(
+    z.string(),
+    // localizable files' keys
+    // checksums hashmap
+    z.record(
+      // key
+      z.string(),
+      // checksum of the key's value in the source locale
+      z.string()
+    ).default({})
+  ).default({})
+});
+function createDeltaProcessor(fileKey) {
+  const lockfilePath = path14.join(process.cwd(), "i18n.lock");
+  return {
+    async checkIfLockExists() {
+      return checkIfFileExists(lockfilePath);
+    },
+    async calculateDelta(params) {
+      let added = _20.difference(Object.keys(params.sourceData), Object.keys(params.targetData));
+      let removed = _20.difference(Object.keys(params.targetData), Object.keys(params.sourceData));
+      const updated = _20.filter(Object.keys(params.sourceData), (key) => {
+        return MD5(params.sourceData[key]) !== params.checksums[key] && params.checksums[key];
+      });
+      const renamed = [];
+      for (const addedKey of added) {
+        const addedHash = MD5(params.sourceData[addedKey]);
+        for (const removedKey of removed) {
+          if (params.checksums[removedKey] === addedHash) {
+            renamed.push([removedKey, addedKey]);
+            break;
+          }
+        }
+      }
+      added = added.filter((key) => !renamed.some(([oldKey, newKey]) => newKey === key));
+      removed = removed.filter((key) => !renamed.some(([oldKey, newKey]) => oldKey === key));
+      const hasChanges = [added.length > 0, removed.length > 0, updated.length > 0, renamed.length > 0].some((v) => v);
+      return {
+        added,
+        removed,
+        updated,
+        renamed,
+        hasChanges
+      };
+    },
+    async loadLock() {
+      const lockfileContent = tryReadFile(lockfilePath, null);
+      const lockfileYaml = lockfileContent ? YAML3.parse(lockfileContent) : null;
+      const lockfileData = lockfileYaml ? LockSchema.parse(lockfileYaml) : {
+        version: 1,
+        checksums: {}
+      };
+      return lockfileData;
+    },
+    async saveLock(lockData) {
+      const lockfileYaml = YAML3.stringify(lockData);
+      writeFile(lockfilePath, lockfileYaml);
+    },
+    async loadChecksums() {
+      const id = MD5(fileKey);
+      const lockfileData = await this.loadLock();
+      return lockfileData.checksums[id] || {};
+    },
+    async saveChecksums(checksums) {
+      const id = MD5(fileKey);
+      const lockfileData = await this.loadLock();
+      lockfileData.checksums[id] = checksums;
+      await this.saveLock(lockfileData);
+    },
+    async createChecksums(sourceData) {
+      const checksums = _20.mapValues(sourceData, (value) => MD5(value));
+      return checksums;
+    }
+  };
 }
 
 // src/cli/cmd/i18n.ts
+import { flatten as flatten2, unflatten as unflatten2 } from "flat";
 var i18n_default = new Command6().command("i18n").description("Run Localization engine").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(
   "--key <key>",
   "Key to process. Process only a specific translation key, useful for debugging or updating a single entry"
@@ -3515,7 +3595,7 @@ var i18n_default = new Command6().command("i18n").description("Run Localization
     ora.succeed("Buckets retrieved");
     if (flags.file?.length) {
       buckets = buckets.map((bucket) => {
-        const paths = bucket.paths.filter((path15) => flags.file.find((file) => path15.pathPattern?.match(file)));
+        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) {
@@ -3525,34 +3605,94 @@ var i18n_default = new Command6().command("i18n").description("Run Localization
         ora.info(`\x1B[36mProcessing only filtered buckets:\x1B[0m`);
         buckets.map((bucket) => {
           ora.info(`  ${bucket.type}:`);
-          bucket.paths.forEach((path15) => {
-            ora.info(`    - ${path15.pathPattern}`);
+          bucket.paths.forEach((path18) => {
+            ora.info(`    - ${path18.pathPattern}`);
           });
         });
       }
     }
     const targetLocales = flags.locale?.length ? flags.locale : i18nConfig.locale.targets;
-    const lockfileHelper = createLockfileHelper();
-    ora.start("Ensuring i18n.lock exists...");
-    if (!lockfileHelper.isLockfileExists()) {
+    ora.start("Setting up localization cache...");
+    const checkLockfileProcessor = createDeltaProcessor("");
+    const lockfileExists = await checkLockfileProcessor.checkIfLockExists();
+    if (!lockfileExists) {
       ora.start("Creating i18n.lock...");
       for (const bucket of buckets) {
         for (const bucketPath of bucket.paths) {
           const sourceLocale = resolveOverriddenLocale3(i18nConfig.locale.source, bucketPath.delimiter);
-          const bucketLoader = createBucketLoader(bucket.type, bucketPath.pathPattern, {
-            isCacheRestore: false,
-            defaultLocale: sourceLocale,
-            injectLocale: bucket.injectLocale
-          });
+          const bucketLoader = createBucketLoader(
+            bucket.type,
+            bucketPath.pathPattern,
+            {
+              isCacheRestore: false,
+              defaultLocale: sourceLocale,
+              injectLocale: bucket.injectLocale
+            },
+            bucket.lockedKeys
+          );
           bucketLoader.setDefaultLocale(sourceLocale);
           await bucketLoader.init();
           const sourceData = await bucketLoader.pull(i18nConfig.locale.source);
-          lockfileHelper.registerSourceData(bucketPath.pathPattern, sourceData);
+          const deltaProcessor = createDeltaProcessor(bucketPath.pathPattern);
+          const checksums = await deltaProcessor.createChecksums(sourceData);
+          await deltaProcessor.saveChecksums(checksums);
         }
       }
-      ora.succeed("i18n.lock created");
+      ora.succeed("Localization cache initialized");
     } else {
-      ora.succeed("i18n.lock loaded");
+      ora.succeed("Localization cache loaded");
+    }
+    for (const bucket of buckets) {
+      if (bucket.type !== "json") {
+        continue;
+      }
+      ora.start("Validating localization state...");
+      for (const bucketPath of bucket.paths) {
+        const sourceLocale = resolveOverriddenLocale3(i18nConfig.locale.source, bucketPath.delimiter);
+        const deltaProcessor = createDeltaProcessor(bucketPath.pathPattern);
+        const sourcePath = path15.join(process.cwd(), bucketPath.pathPattern.replace("[locale]", sourceLocale));
+        const sourceContent = tryReadFile(sourcePath, null);
+        const sourceData = JSON.parse(sourceContent || "{}");
+        const sourceFlattenedData = flatten2(sourceData, {
+          delimiter: "/",
+          transformKey(key) {
+            return encodeURIComponent(key);
+          }
+        });
+        for (const _targetLocale of targetLocales) {
+          const targetLocale = resolveOverriddenLocale3(_targetLocale, bucketPath.delimiter);
+          const targetPath = path15.join(process.cwd(), bucketPath.pathPattern.replace("[locale]", targetLocale));
+          const targetContent = tryReadFile(targetPath, null);
+          const targetData = JSON.parse(targetContent || "{}");
+          const targetFlattenedData = flatten2(targetData, {
+            delimiter: "/",
+            transformKey(key) {
+              return encodeURIComponent(key);
+            }
+          });
+          const checksums = await deltaProcessor.loadChecksums();
+          const delta = await deltaProcessor.calculateDelta({
+            sourceData: sourceFlattenedData,
+            targetData: targetFlattenedData,
+            checksums
+          });
+          if (!delta.hasChanges) {
+            continue;
+          }
+          for (const [oldKey, newKey] of delta.renamed) {
+            targetFlattenedData[newKey] = targetFlattenedData[oldKey];
+            delete targetFlattenedData[oldKey];
+          }
+          const updatedTargetData = unflatten2(targetFlattenedData, {
+            delimiter: "/",
+            transformKey(key) {
+              return decodeURIComponent(key);
+            }
+          });
+          await writeFile(targetPath, JSON.stringify(updatedTargetData, null, 2));
+        }
+      }
+      ora.succeed("Localization state check completed");
     }
     const cache = getNormalizedCache();
     if (cache) {
@@ -3565,11 +3705,16 @@ var i18n_default = new Command6().command("i18n").description("Run Localization
           const bucketOra = Ora5({ indent: 4 });
           bucketOra.info(`Processing path: ${bucketPath.pathPattern}`);
           const sourceLocale = resolveOverriddenLocale3(i18nConfig.locale.source, bucketPath.delimiter);
-          const bucketLoader = createBucketLoader(bucket.type, bucketPath.pathPattern, {
-            isCacheRestore: true,
-            defaultLocale: sourceLocale,
-            injectLocale: bucket.injectLocale
-          });
+          const bucketLoader = createBucketLoader(
+            bucket.type,
+            bucketPath.pathPattern,
+            {
+              isCacheRestore: true,
+              defaultLocale: sourceLocale,
+              injectLocale: bucket.injectLocale
+            },
+            bucket.lockedKeys
+          );
           bucketLoader.setDefaultLocale(sourceLocale);
           await bucketLoader.init();
           const sourceData = await bucketLoader.pull(sourceLocale);
@@ -3584,7 +3729,9 @@ var i18n_default = new Command6().command("i18n").description("Run Localization
               }
             }
             await bucketLoader.push(targetLocale, targetData);
-            lockfileHelper.registerPartialSourceData(bucketPath.pathPattern, cachedSourceData);
+            const deltaProcessor = createDeltaProcessor(bucketPath.pathPattern);
+            const checksums = await deltaProcessor.createChecksums(cachedSourceData);
+            await deltaProcessor.saveChecksums(checksums);
             bucketOra.succeed(
               `[${sourceLocale} -> ${targetLocale}] Recovered ${Object.keys(cachedSourceData).length} entries from cache`
             );
@@ -3604,18 +3751,29 @@ var i18n_default = new Command6().command("i18n").description("Run Localization
       bucketLoop: for (const bucket of buckets) {
         for (const bucketPath of bucket.paths) {
           const sourceLocale = resolveOverriddenLocale3(i18nConfig.locale.source, bucketPath.delimiter);
-          const bucketLoader = createBucketLoader(bucket.type, bucketPath.pathPattern, {
-            isCacheRestore: false,
-            defaultLocale: sourceLocale,
-            returnUnlocalizedKeys: true,
-            injectLocale: bucket.injectLocale
-          });
+          const bucketLoader = createBucketLoader(
+            bucket.type,
+            bucketPath.pathPattern,
+            {
+              isCacheRestore: false,
+              defaultLocale: sourceLocale,
+              returnUnlocalizedKeys: true,
+              injectLocale: bucket.injectLocale
+            },
+            bucket.lockedKeys
+          );
           bucketLoader.setDefaultLocale(sourceLocale);
           await bucketLoader.init();
           const { unlocalizable: sourceUnlocalizable, ...sourceData } = await bucketLoader.pull(
             i18nConfig.locale.source
           );
-          const updatedSourceData = lockfileHelper.extractUpdatedData(bucketPath.pathPattern, sourceData);
+          const deltaProcessor = createDeltaProcessor(bucketPath.pathPattern);
+          const sourceChecksums = await deltaProcessor.createChecksums(sourceData);
+          const savedChecksums = await deltaProcessor.loadChecksums();
+          const updatedSourceData = _21.pickBy(
+            sourceData,
+            (value, key) => sourceChecksums[key] !== savedChecksums[key]
+          );
           if (Object.keys(updatedSourceData).length > 0) {
             requiresUpdate = "updated";
             break bucketLoop;
@@ -3623,9 +3781,9 @@ var i18n_default = new Command6().command("i18n").description("Run Localization
           for (const _targetLocale of targetLocales) {
             const targetLocale = resolveOverriddenLocale3(_targetLocale, bucketPath.delimiter);
             const { unlocalizable: targetUnlocalizable, ...targetData } = await bucketLoader.pull(targetLocale);
-            const missingKeys = _20.difference(Object.keys(sourceData), Object.keys(targetData));
-            const extraKeys = _20.difference(Object.keys(targetData), Object.keys(sourceData));
-            const unlocalizableDataDiff = !_20.isEqual(sourceUnlocalizable, targetUnlocalizable);
+            const missingKeys = _21.difference(Object.keys(sourceData), Object.keys(targetData));
+            const extraKeys = _21.difference(Object.keys(targetData), Object.keys(sourceData));
+            const unlocalizableDataDiff = !_21.isEqual(sourceUnlocalizable, targetUnlocalizable);
             if (missingKeys.length > 0) {
               requiresUpdate = "missing";
               break bucketLoop;
@@ -3662,11 +3820,16 @@ var i18n_default = new Command6().command("i18n").description("Run Localization
         for (const bucketPath of bucket.paths) {
           const bucketOra = Ora5({ indent: 2 }).info(`Processing path: ${bucketPath.pathPattern}`);
           const sourceLocale = resolveOverriddenLocale3(i18nConfig.locale.source, bucketPath.delimiter);
-          const bucketLoader = createBucketLoader(bucket.type, bucketPath.pathPattern, {
-            isCacheRestore: false,
-            defaultLocale: sourceLocale,
-            injectLocale: bucket.injectLocale
-          });
+          const bucketLoader = createBucketLoader(
+            bucket.type,
+            bucketPath.pathPattern,
+            {
+              isCacheRestore: false,
+              defaultLocale: sourceLocale,
+              injectLocale: bucket.injectLocale
+            },
+            bucket.lockedKeys
+          );
           bucketLoader.setDefaultLocale(sourceLocale);
           await bucketLoader.init();
           let sourceData = await bucketLoader.pull(sourceLocale);
@@ -3675,15 +3838,17 @@ var i18n_default = new Command6().command("i18n").description("Run Localization
             try {
               bucketOra.start(`[${sourceLocale} -> ${targetLocale}] (0%) Localization in progress...`);
               sourceData = await bucketLoader.pull(sourceLocale);
-              const updatedSourceData = flags.force ? sourceData : lockfileHelper.extractUpdatedData(bucketPath.pathPattern, sourceData);
               const targetData = await bucketLoader.pull(targetLocale);
-              let processableData = calculateDataDelta({
+              const deltaProcessor2 = createDeltaProcessor(bucketPath.pathPattern);
+              const checksums2 = await deltaProcessor2.loadChecksums();
+              const delta = await deltaProcessor2.calculateDelta({
                 sourceData,
-                updatedSourceData,
-                targetData
+                targetData,
+                checksums: checksums2
               });
+              let processableData = _21.chain(sourceData).entries().filter(([key, value]) => delta.added.includes(key) || delta.updated.includes(key) || !!flags.force).fromPairs().value();
               if (flags.key) {
-                processableData = _20.pickBy(processableData, (_22, key) => key === flags.key);
+                processableData = _21.pickBy(processableData, (_24, key) => key === flags.key);
               }
               if (flags.verbose) {
                 bucketOra.info(JSON.stringify(processableData, null, 2));
@@ -3720,7 +3885,7 @@ var i18n_default = new Command6().command("i18n").description("Run Localization
               if (flags.verbose) {
                 bucketOra.info(JSON.stringify(processedTargetData, null, 2));
               }
-              let finalTargetData = _20.merge({}, sourceData, targetData, processedTargetData);
+              let finalTargetData = _21.merge({}, sourceData, targetData, processedTargetData);
               if (flags.interactive) {
                 bucketOra.stop();
                 const reviewedData = await reviewChanges({
@@ -3734,7 +3899,7 @@ var i18n_default = new Command6().command("i18n").description("Run Localization
                 finalTargetData = reviewedData;
                 bucketOra.start(`Applying changes to ${bucketPath} (${targetLocale})`);
               }
-              const finalDiffSize = _20.chain(finalTargetData).omitBy((value, key) => value === targetData[key]).size().value();
+              const finalDiffSize = _21.chain(finalTargetData).omitBy((value, key) => value === targetData[key]).size().value();
               await bucketLoader.push(targetLocale, finalTargetData);
               if (finalDiffSize > 0 || flags.force) {
                 bucketOra.succeed(`[${sourceLocale} -> ${targetLocale}] Localization completed`);
@@ -3751,7 +3916,9 @@ var i18n_default = new Command6().command("i18n").description("Run Localization
               }
             }
           }
-          lockfileHelper.registerSourceData(bucketPath.pathPattern, sourceData);
+          const deltaProcessor = createDeltaProcessor(bucketPath.pathPattern);
+          const checksums = await deltaProcessor.createChecksums(sourceData);
+          await deltaProcessor.saveChecksums(checksums);
         }
       } catch (_error) {
         const error = new Error(`Failed to process bucket ${bucket.type}: ${_error.message}`);
@@ -3786,25 +3953,19 @@ var i18n_default = new Command6().command("i18n").description("Run Localization
     process.exit(1);
   }
 });
-function calculateDataDelta(args) {
-  const newKeys = _20.difference(Object.keys(args.sourceData), Object.keys(args.targetData));
-  const updatedKeys = Object.keys(args.updatedSourceData);
-  const result = _20.chain(args.sourceData).pickBy((value, key) => newKeys.includes(key) || updatedKeys.includes(key)).value();
-  return result;
-}
 function parseFlags(options) {
-  return Z4.object({
-    apiKey: Z4.string().optional(),
-    locale: Z4.array(localeCodeSchema).optional(),
-    bucket: Z4.array(bucketTypeSchema).optional(),
-    force: Z4.boolean().optional(),
-    frozen: Z4.boolean().optional(),
-    verbose: Z4.boolean().optional(),
-    strict: Z4.boolean().optional(),
-    key: Z4.string().optional(),
-    file: Z4.array(Z4.string()).optional(),
-    interactive: Z4.boolean().default(false),
-    debug: Z4.boolean().default(false)
+  return Z3.object({
+    apiKey: Z3.string().optional(),
+    locale: Z3.array(localeCodeSchema).optional(),
+    bucket: Z3.array(bucketTypeSchema).optional(),
+    force: Z3.boolean().optional(),
+    frozen: Z3.boolean().optional(),
+    verbose: Z3.boolean().optional(),
+    strict: Z3.boolean().optional(),
+    key: Z3.string().optional(),
+    file: Z3.array(Z3.string()).optional(),
+    interactive: Z3.boolean().default(false),
+    debug: Z3.boolean().default(false)
   }).parse(options);
 }
 async function validateAuth(settings) {
@@ -3898,7 +4059,7 @@ Reviewing changes for ${chalk.blue(args.pathPattern)} (${chalk.yellow(args.targe
     return args.currentData;
   }
   const customData = { ...args.currentData };
-  const changes = _20.reduce(
+  const changes = _21.reduce(
     args.proposedData,
     (result, value, key) => {
       if (args.currentData[key] !== value) {
@@ -3950,6 +4111,77 @@ Editing value for: ${chalk.cyan(key)}`);
 import { Command as Command7 } from "interactive-commander";
 import Z5 from "zod";
 import Ora6 from "ora";
+
+// src/cli/utils/lockfile.ts
+import fs12 from "fs";
+import path16 from "path";
+import Z4 from "zod";
+import YAML4 from "yaml";
+import { MD5 as MD52 } from "object-hash";
+import _22 from "lodash";
+function createLockfileHelper() {
+  return {
+    isLockfileExists: () => {
+      const lockfilePath = _getLockfilePath();
+      return fs12.existsSync(lockfilePath);
+    },
+    registerSourceData: (pathPattern, sourceData) => {
+      const lockfile = _loadLockfile();
+      const sectionKey = MD52(pathPattern);
+      const sectionChecksums = _22.mapValues(sourceData, (value) => MD52(value));
+      lockfile.checksums[sectionKey] = sectionChecksums;
+      _saveLockfile(lockfile);
+    },
+    registerPartialSourceData: (pathPattern, partialSourceData) => {
+      const lockfile = _loadLockfile();
+      const sectionKey = MD52(pathPattern);
+      const sectionChecksums = _22.mapValues(partialSourceData, (value) => MD52(value));
+      lockfile.checksums[sectionKey] = _22.merge({}, lockfile.checksums[sectionKey] ?? {}, sectionChecksums);
+      _saveLockfile(lockfile);
+    },
+    extractUpdatedData: (pathPattern, sourceData) => {
+      const lockfile = _loadLockfile();
+      const sectionKey = MD52(pathPattern);
+      const currentChecksums = _22.mapValues(sourceData, (value) => MD52(value));
+      const savedChecksums = lockfile.checksums[sectionKey] || {};
+      const updatedData = _22.pickBy(sourceData, (value, key) => savedChecksums[key] !== currentChecksums[key]);
+      return updatedData;
+    }
+  };
+  function _loadLockfile() {
+    const lockfilePath = _getLockfilePath();
+    if (!fs12.existsSync(lockfilePath)) {
+      return LockfileSchema.parse({});
+    }
+    const content = fs12.readFileSync(lockfilePath, "utf-8");
+    const result = LockfileSchema.parse(YAML4.parse(content));
+    return result;
+  }
+  function _saveLockfile(lockfile) {
+    const lockfilePath = _getLockfilePath();
+    const content = YAML4.stringify(lockfile);
+    fs12.writeFileSync(lockfilePath, content);
+  }
+  function _getLockfilePath() {
+    return path16.join(process.cwd(), "i18n.lock");
+  }
+}
+var LockfileSchema = Z4.object({
+  version: Z4.literal(1).default(1),
+  checksums: Z4.record(
+    Z4.string(),
+    // localizable files' keys
+    Z4.record(
+      // checksums hashmap
+      Z4.string(),
+      // key
+      Z4.string()
+      // checksum of the key's value in the source locale
+    ).default({})
+  ).default({})
+});
+
+// src/cli/cmd/lockfile.ts
 import { resolveOverriddenLocale as resolveOverriddenLocale4 } from "@lingo.dev/_spec";
 var lockfile_default = new Command7().command("lockfile").description("Create a lockfile if it does not exist").helpOption("-h, --help", "Show help").option("-f, --force", "Force create a lockfile").action(async (options) => {
   const flags = flagsSchema.parse(options);
@@ -3982,7 +4214,7 @@ var flagsSchema = Z5.object({
 // src/cli/cmd/cleanup.ts
 import { resolveOverriddenLocale as resolveOverriddenLocale5 } from "@lingo.dev/_spec";
 import { Command as Command8 } from "interactive-commander";
-import _21 from "lodash";
+import _23 from "lodash";
 import Ora7 from "ora";
 var cleanup_default = new Command8().command("cleanup").description("Remove keys from target files that do not exist in the source file").helpOption("-h, --help", "Show help").option("--locale <locale>", "Specific locale to cleanup").option("--bucket <bucket>", "Specific bucket to cleanup").option("--dry-run", "Show what would be removed without making changes").option(
   "--verbose",
@@ -4018,7 +4250,7 @@ var cleanup_default = new Command8().command("cleanup").description("Remove keys
           try {
             const targetData = await bucketLoader.pull(targetLocale);
             const targetKeys = Object.keys(targetData);
-            const keysToRemove = _21.difference(targetKeys, sourceKeys);
+            const keysToRemove = _23.difference(targetKeys, sourceKeys);
             if (keysToRemove.length === 0) {
               bucketOra.succeed(`[${targetLocale}] No keys to remove`);
               continue;
@@ -4027,7 +4259,7 @@ var cleanup_default = new Command8().command("cleanup").description("Remove keys
               bucketOra.info(`[${targetLocale}] Keys to remove: ${JSON.stringify(keysToRemove, null, 2)}`);
             }
             if (!options.dryRun) {
-              const cleanedData = _21.pick(targetData, sourceKeys);
+              const cleanedData = _23.pick(targetData, sourceKeys);
               await bucketLoader.push(targetLocale, cleanedData);
               bucketOra.succeed(`[${targetLocale}] Removed ${keysToRemove.length} keys`);
             } else {
@@ -4082,7 +4314,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import Z6 from "zod";
 import { ReplexicaEngine } from "@lingo.dev/_sdk";
-var mcp_default = new Command9().command("mcp").description("Use Lingo.dev model context provider with your AI agent").helpOption("-h, --help", "Show help").action(async (_22, program) => {
+var mcp_default = new Command9().command("mcp").description("Use Lingo.dev model context provider with your AI agent").helpOption("-h, --help", "Show help").action(async (_24, program) => {
   const apiKey = program.args[0];
   const settings = getSettings(apiKey);
   if (!settings.auth.apiKey) {
@@ -4140,7 +4372,7 @@ import { execSync as execSync2 } from "child_process";
 
 // ../../action/src/flows/in-branch.ts
 import { execSync } from "child_process";
-import path14 from "path";
+import path17 from "path";
 
 // ../../action/src/flows/_base.ts
 var IntegrationFlow = class {
@@ -4218,7 +4450,7 @@ var InBranchFlow = class extends IntegrationFlow {
         return false;
       }
     }
-    const workingDir = path14.resolve(process.cwd(), this.platformKit.config.workingDir);
+    const workingDir = path17.resolve(process.cwd(), this.platformKit.config.workingDir);
     if (workingDir !== process.cwd()) {
       this.ora.info(`Changing to working directory: ${this.platformKit.config.workingDir}`);
       process.chdir(workingDir);
@@ -4387,15 +4619,21 @@ Hey team,
 };
 
 // ../../action/src/platforms/bitbucket.ts
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 import bbLib from "bitbucket";
 import Z8 from "zod";
 
 // ../../action/src/platforms/_base.ts
+import { execSync as execSync3 } from "child_process";
 import Z7 from "zod";
 var defaultMessage = "feat: update translations via @lingodotdev";
 var PlatformKit = class {
-  gitConfig() {
+  gitConfig(token, repoUrl) {
+    if (token && repoUrl) {
+      execSync3(`git remote set-url origin ${repoUrl}`, {
+        stdio: "inherit"
+      });
+    }
   }
   get config() {
     const env = Z7.object({
@@ -4479,10 +4717,10 @@ var BitbucketPlatformKit = class extends PlatformKit {
     });
   }
   async gitConfig() {
-    execSync3("git config --unset http.${BITBUCKET_GIT_HTTP_ORIGIN}.proxy", {
+    execSync4("git config --unset http.${BITBUCKET_GIT_HTTP_ORIGIN}.proxy", {
       stdio: "inherit"
     });
-    execSync3("git config http.${BITBUCKET_GIT_HTTP_ORIGIN}.proxy http://host.docker.internal:29418/", {
+    execSync4("git config http.${BITBUCKET_GIT_HTTP_ORIGIN}.proxy http://host.docker.internal:29418/", {
       stdio: "inherit"
     });
   }
@@ -4509,7 +4747,6 @@ var BitbucketPlatformKit = class extends PlatformKit {
 // ../../action/src/platforms/github.ts
 import { Octokit } from "octokit";
 import Z9 from "zod";
-import { execSync as execSync4 } from "child_process";
 var GitHubPlatformKit = class extends PlatformKit {
   _octokit;
   get octokit() {
@@ -4566,9 +4803,7 @@ var GitHubPlatformKit = class extends PlatformKit {
     if (ghToken && processOwnCommits) {
       console.log("Using provided GH_TOKEN. This will trigger your CI/CD pipeline to run again.");
       const url = `https://${ghToken}@github.com/${repositoryOwner}/${repositoryName}.git`;
-      execSync4(`git remote set-url origin ${url}`, {
-        stdio: "inherit"
-      });
+      super.gitConfig(ghToken, url);
     }
   }
   get platformConfig() {
@@ -4596,7 +4831,6 @@ var GitHubPlatformKit = class extends PlatformKit {
 // ../../action/src/platforms/gitlab.ts
 import { Gitlab } from "@gitbeaker/rest";
 import Z10 from "zod";
-import { execSync as execSync5 } from "child_process";
 var gl = new Gitlab({ token: "" });
 var GitlabPlatformKit = class extends PlatformKit {
   _gitlab;
@@ -4671,10 +4905,9 @@ var GitlabPlatformKit = class extends PlatformKit {
     await this.gitlab.MergeRequestNotes.create(this.platformConfig.gitlabProjectId, pullRequestNumber, body);
   }
   gitConfig() {
-    const url = `https://oauth2:${this.platformConfig.glToken}@gitlab.com/${this.platformConfig.repositoryOwner}/${this.platformConfig.repositoryName}.git`;
-    execSync5(`git remote set-url origin ${url}`, {
-      stdio: "inherit"
-    });
+    const glToken = this.platformConfig.glToken;
+    const url = `https://oauth2:${glToken}@gitlab.com/${this.platformConfig.repositoryOwner}/${this.platformConfig.repositoryName}.git`;
+    super.gitConfig(glToken, url);
   }
   buildPullRequestUrl(pullRequestNumber) {
     return `https://gitlab.com/${this.platformConfig.repositoryOwner}/${this.platformConfig.repositoryName}/-/merge_requests/${pullRequestNumber}`;
@@ -4745,7 +4978,7 @@ var ci_default = new Command10().command("ci").description("Run Lingo.dev CI/CD
 // package.json
 var package_default = {
   name: "lingo.dev",
-  version: "0.80.1",
+  version: "0.82.0",
   description: "Lingo.dev CLI",
   private: false,
   publishConfig: {