@vocoder/cli 0.2.4 → 0.8.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vocoder
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/bin.mjs

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
+import { createRequire as __createRequire } from 'module'; const require = __createRequire(import.meta.url);
 import {
   StringExtractor,
   buildInstallCommand,
   detectLocalEcosystem,
   getPackagesToInstall,
-  getSetupSnippets
-} from "./chunk-TFAPB25S.mjs";
+  getSetupSnippets,
+  loadVocoderConfig
+} from "./chunk-7LFRSUPU.mjs";
 
 // src/bin.ts
 import { Command } from "commander";
@@ -122,6 +124,7 @@ var VocoderAPI = class {
     return {
       projectName: data.projectName,
       organizationName: data.organizationName,
+      shortCode: data.shortCode,
       sourceLocale: data.sourceLocale,
       targetLocales: data.targetLocales,
       targetBranches: data.targetBranches ?? ["main"],
@@ -184,7 +187,7 @@ var VocoderAPI = class {
           branch,
           stringEntries,
           targetLocales,
-          stringsHash,
+          ...options?.force ? {} : { stringsHash },
           ...options?.requestedMode ? { requestedMode: options.requestedMode } : {},
           ...typeof options?.requestedMaxWaitMs === "number" ? { requestedMaxWaitMs: options.requestedMaxWaitMs } : {},
           ...options?.clientRunId ? { clientRunId: options.clientRunId } : {},
@@ -2932,7 +2935,6 @@ function matchBranchPattern(branch, pattern) {
 import * as p7 from "@clack/prompts";
 import chalk7 from "chalk";
 import { config as loadEnv2 } from "dotenv";
-import { loadVocoderConfig } from "@vocoder/extractor";
 loadEnv2();
 function validateLocalConfig(config) {
   if (!config.apiKey || config.apiKey.length === 0) {
@@ -3092,20 +3094,9 @@ async function getMergedConfig(cliOptions, verbose = false, _startDir) {
 }
 
 // src/commands/sync.ts
-function computeStringsHash(texts) {
+function computeFingerprint(shortCode, texts) {
   const sorted = [...texts].sort();
-  return createHash("sha256").update(sorted.join("\0")).digest("hex").slice(0, 16);
-}
-function readCachedStringsHash(projectRoot, branch) {
-  const filePath = getCacheFilePath(projectRoot, branch);
-  if (!existsSync3(filePath)) return null;
-  try {
-    const raw = JSON.parse(readFileSync3(filePath, "utf-8"));
-    if (isRecord(raw) && typeof raw.stringsHash === "string")
-      return raw.stringsHash;
-  } catch {
-  }
-  return null;
+  return createHash("sha256").update(`${shortCode}:${sorted.join("\0")}`).digest("hex").slice(0, 12);
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -3150,69 +3141,52 @@ function parseTranslations(value) {
   }
   return Object.keys(translations).length > 0 ? translations : null;
 }
-function getCacheFilePath(projectRoot, branch) {
-  const branchHash = createHash("sha1").update(branch).digest("hex").slice(0, 12);
-  return join4(
-    projectRoot,
-    "node_modules",
-    ".vocoder",
-    "cache",
-    "sync",
-    `${branchHash}.json`
-  );
+function getCacheFilePath(projectRoot, fingerprint) {
+  return join4(projectRoot, "node_modules", ".vocoder", "cache", `${fingerprint}.json`);
 }
-function readLocalSnapshotCache(params) {
-  const candidateBranches = params.branch === "main" ? ["main"] : [params.branch, "main"];
-  for (const candidateBranch of candidateBranches) {
-    const cacheFilePath = getCacheFilePath(params.projectRoot, candidateBranch);
-    if (!existsSync3(cacheFilePath)) {
-      continue;
-    }
-    try {
-      const raw = readFileSync3(cacheFilePath, "utf-8");
-      const parsed = JSON.parse(raw);
-      if (!isRecord(parsed)) {
-        continue;
-      }
-      const translations = parseTranslations(parsed.translations);
-      if (!translations) {
-        continue;
-      }
-      const localeMetadata = parseLocaleMetadata(parsed.localeMetadata);
-      return {
-        source: "local-cache",
-        translations,
-        localeMetadata,
-        snapshotBatchId: typeof parsed.snapshotBatchId === "string" ? parsed.snapshotBatchId : void 0,
-        completedAt: typeof parsed.completedAt === "string" ? parsed.completedAt : null,
-        cacheBranch: candidateBranch
-      };
-    } catch {
+function buildTranslationData(params) {
+  const textToHash = new Map(params.stringEntries.map((e) => [e.text, e.key]));
+  const hashKeyed = {};
+  for (const [locale, localeMap] of Object.entries(params.translations)) {
+    hashKeyed[locale] = {};
+    for (const [text2, translation] of Object.entries(localeMap)) {
+      const hash = textToHash.get(text2);
+      if (hash) hashKeyed[locale][hash] = translation;
     }
   }
-  return null;
-}
-function writeLocalSnapshotCache(params) {
-  const cacheFilePath = getCacheFilePath(params.projectRoot, params.branch);
-  mkdirSync2(
-    join4(params.projectRoot, "node_modules", ".vocoder", "cache", "sync"),
-    {
-      recursive: true
-    }
-  );
-  const payload = {
-    version: 1,
-    branch: params.branch,
-    sourceLocale: params.sourceLocale,
-    targetLocales: params.targetLocales,
-    savedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    ...params.stringsHash ? { stringsHash: params.stringsHash } : {},
-    ...params.snapshotBatchId ? { snapshotBatchId: params.snapshotBatchId } : {},
-    ...params.completedAt ? { completedAt: params.completedAt } : {},
-    ...params.localeMetadata ? { localeMetadata: params.localeMetadata } : {},
-    translations: params.translations
+  const locales = {};
+  for (const code of [params.sourceLocale, ...params.targetLocales]) {
+    const meta = params.localeMetadata?.[code];
+    if (meta) locales[code] = { nativeName: meta.nativeName, ...meta.dir ? { dir: meta.dir } : {} };
+  }
+  return {
+    config: { sourceLocale: params.sourceLocale, targetLocales: params.targetLocales, locales },
+    translations: hashKeyed,
+    updatedAt: params.updatedAt
   };
-  writeFileSync4(cacheFilePath, JSON.stringify(payload, null, 2), "utf-8");
+}
+function readLocalCache(params) {
+  const cacheFilePath = getCacheFilePath(params.projectRoot, params.fingerprint);
+  if (!existsSync3(cacheFilePath)) return null;
+  try {
+    const raw = readFileSync3(cacheFilePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!isRecord(parsed)) return null;
+    const inner = isRecord(parsed.config) ? parsed : null;
+    if (!inner) return null;
+    const translations = parseTranslations(inner.translations);
+    if (!translations) return null;
+    const localeMetadata = isRecord(inner.config) ? parseLocaleMetadata(inner.config.locales) : void 0;
+    return { source: "local-cache", translations, localeMetadata };
+  } catch {
+    return null;
+  }
+}
+function writeCache(params) {
+  const cacheDir = join4(params.projectRoot, "node_modules", ".vocoder", "cache");
+  mkdirSync2(cacheDir, { recursive: true });
+  const cacheFilePath = getCacheFilePath(params.projectRoot, params.fingerprint);
+  writeFileSync4(cacheFilePath, JSON.stringify(params.data), "utf-8");
   return cacheFilePath;
 }
 function resolveEffectiveModeFromPolicy(params) {
@@ -3469,30 +3443,20 @@ async function sync(options = {}) {
         `Deduped ${extractedStrings.length} extracted entries into ${stringEntries.length} unique source strings`
       );
     }
-    const currentHash = computeStringsHash(sourceStrings);
+    const fingerprint = computeFingerprint(config.shortCode, sourceStrings);
     if (!options.force) {
-      const cachedHash = readCachedStringsHash(projectRoot, branch);
-      if (options.verbose) {
-        const cacheFile = getCacheFilePath(projectRoot, branch);
-        if (cachedHash) {
-          p8.log.info(
-            `Local cache: ${chalk8.dim(cacheFile)}
-  cached hash ${chalk8.cyan(cachedHash.slice(0, 8))}\u2026 vs current ${chalk8.cyan(currentHash.slice(0, 8))}\u2026 \u2014 ${cachedHash === currentHash ? chalk8.green("match") : chalk8.yellow("changed")}`
-          );
-        } else {
-          p8.log.info(`No local cache found at ${chalk8.dim(cacheFile)} \u2014 will submit to API`);
-        }
-      }
-      if (cachedHash && cachedHash === currentHash) {
+      const cacheFile = getCacheFilePath(projectRoot, fingerprint);
+      if (existsSync3(cacheFile)) {
         if (options.verbose) {
-          p8.log.info(
-            "Skipping API submission \u2014 delete node_modules/.vocoder to force a fresh sync"
-          );
+          p8.log.info(`Cache hit: ${chalk8.dim(cacheFile)} (fingerprint ${chalk8.cyan(fingerprint)})`);
         }
         const duration2 = ((Date.now() - startTime) / 1e3).toFixed(1);
         p8.outro(`Up to date (${duration2}s)`);
         return 0;
       }
+      if (options.verbose) {
+        p8.log.info(`No cache for fingerprint ${chalk8.cyan(fingerprint)} \u2014 will submit to API`);
+      }
     }
     spinner4.start("Submitting strings to Vocoder API");
     const batchResponse = await api.submitTranslation(
@@ -3502,7 +3466,8 @@ async function sync(options = {}) {
       {
         requestedMode,
         requestedMaxWaitMs: waitTimeoutMs,
-        clientRunId: randomUUID()
+        clientRunId: randomUUID(),
+        force: options.force
       },
       repoIdentity ? { ...repoIdentity, commitSha } : { commitSha }
     );
@@ -3587,14 +3552,13 @@ async function sync(options = {}) {
         );
       }
       spinner4.start("Loading fallback translations");
-      const localFallback = readLocalSnapshotCache({
+      const localFallback = readLocalCache({
         projectRoot,
-        branch
+        fingerprint
       });
       if (localFallback) {
         artifacts = localFallback;
-        const cacheBranchLabel = localFallback.cacheBranch && localFallback.cacheBranch !== branch ? `${localFallback.cacheBranch} fallback` : localFallback.cacheBranch || branch;
-        spinner4.stop(`Using local cached snapshot (${cacheBranchLabel})`);
+        spinner4.stop(`Using local cached snapshot (${fingerprint})`);
       } else {
         try {
           const apiSnapshot = await fetchApiSnapshot(api, {
@@ -3633,24 +3597,22 @@ async function sync(options = {}) {
       translations: artifacts.translations
     });
     try {
-      const cachePath = writeLocalSnapshotCache({
-        projectRoot,
-        branch,
+      const data = buildTranslationData({
         sourceLocale: config.sourceLocale,
         targetLocales: config.targetLocales,
+        stringEntries,
         translations: finalTranslations,
         localeMetadata: artifacts.localeMetadata,
-        stringsHash: currentHash,
-        snapshotBatchId: artifacts.snapshotBatchId ?? (artifacts.source === "fresh" ? batchResponse.batchId : batchResponse.latestCompletedBatchId),
-        completedAt: artifacts.completedAt ?? (artifacts.source === "fresh" ? (/* @__PURE__ */ new Date()).toISOString() : null)
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
+      const cachePath = writeCache({ projectRoot, fingerprint, data });
       if (options.verbose) {
-        p8.log.info(`Cached snapshot: ${cachePath}`);
+        p8.log.info(`Cache written: ${cachePath}`);
       }
     } catch (error) {
       if (options.verbose) {
         const message = error instanceof Error ? error.message : "Unknown cache write error";
-        p8.log.warn(`Failed to write local snapshot cache: ${message}`);
+        p8.log.warn(`Failed to write cache: ${message}`);
       }
     }
     if (artifacts.source !== "fresh") {