solid-translate 1.1.0 → 1.2.0

package/dist/cli.js

@@ -1,15 +1,17 @@
 #!/usr/bin/env node
-#!/usr/bin/env node
+import {
+  translateBatch
+} from "./chunk-2BKJUY37.js";
 import "./chunk-FYS2JH42.js";
 
 // src/cli.ts
 import {
-  readFileSync,
-  writeFileSync,
-  existsSync,
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2,
+  existsSync as existsSync2,
   mkdirSync
 } from "fs";
-import { resolve, join, dirname, relative, basename } from "path";
+import { resolve, join as join2, dirname, relative, basename } from "path";
 
 // src/hash.ts
 import { createHash } from "crypto";
@@ -17,77 +19,6 @@ function hashContent(content) {
   return createHash("sha256").update(content).digest("hex").slice(0, 16);
 }
 
-// src/translate.ts
-import { generateObject } from "ai";
-import { z } from "zod";
-async function translateBatch(model, entries, targetLocale, sourceLocale, systemPrompt, contexts) {
-  const keys = Object.keys(entries);
-  if (keys.length === 0) return {};
-  const defaultSystem = [
-    `You are a professional translator specializing in software localization.`,
-    `Translate text from "${sourceLocale}" to "${targetLocale}".`,
-    `Rules:`,
-    `- Preserve the original tone and meaning`,
-    `- Keep placeholders like {{variable}}, {variable}, {0}, {1} unchanged`,
-    `- Keep HTML tags unchanged`,
-    `- Do not add or remove content`,
-    `- Return natural, idiomatic translations`
-  ].join("\n");
-  let contextSection = "";
-  if (contexts && Object.keys(contexts).length > 0) {
-    const contextLines = Object.entries(contexts).filter(([key]) => key in entries).map(([key, ctx]) => `  "${key}": ${ctx}`);
-    if (contextLines.length > 0) {
-      contextSection = [
-        ``,
-        `Context hints for disambiguation:`,
-        ...contextLines,
-        ``
-      ].join("\n");
-    }
-  }
-  const { object } = await generateObject({
-    model,
-    schema: z.object({
-      translations: z.record(z.string(), z.string())
-    }),
-    system: systemPrompt || defaultSystem,
-    prompt: [
-      `Translate each value in this JSON object from "${sourceLocale}" to "${targetLocale}".`,
-      `Return a JSON object with the exact same keys and the translated values.`,
-      contextSection,
-      JSON.stringify(entries, null, 2)
-    ].join("\n")
-  });
-  return object.translations;
-}
-async function translateMarkdown(model, content, targetLocale, sourceLocale, systemPrompt) {
-  const defaultSystem = [
-    `You are a professional translator specializing in documentation.`,
-    `Translate Markdown/MDX content from "${sourceLocale}" to "${targetLocale}".`,
-    `Rules:`,
-    `- Preserve all Markdown formatting (headers, lists, bold, italic, links, etc.)`,
-    `- Preserve code blocks and inline code unchanged`,
-    `- Preserve frontmatter YAML keys (only translate values)`,
-    `- Preserve MDX component syntax and JSX expressions`,
-    `- Preserve URLs and file paths unchanged`,
-    `- Return natural, idiomatic translations`
-  ].join("\n");
-  const { object } = await generateObject({
-    model,
-    schema: z.object({
-      translated: z.string()
-    }),
-    system: systemPrompt || defaultSystem,
-    prompt: [
-      `Translate this Markdown/MDX content from "${sourceLocale}" to "${targetLocale}".`,
-      `Return the complete translated document.`,
-      ``,
-      content
-    ].join("\n")
-  });
-  return object.translated;
-}
-
 // src/extract.ts
 function extractStringsFromSource(code, filePath) {
   const results = [];
@@ -127,6 +58,161 @@ function extractStringsFromSource(code, filePath) {
   return results;
 }
 
+// src/lock.ts
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+function diffLock(sourceDict, lock, contexts) {
+  const changedKeys = {};
+  const pendingEntries = {};
+  for (const [key, value] of Object.entries(sourceDict)) {
+    const hash = hashContent(value);
+    const existing = lock.keys[key];
+    const newContext = contexts ? contexts[key] : existing?.context;
+    const contextChanged = contexts !== void 0 && existing?.context !== contexts[key];
+    if (!existing || existing.hash !== hash || contextChanged) {
+      changedKeys[key] = value;
+      pendingEntries[key] = { hash, source: value, context: newContext };
+    }
+  }
+  const deletedKeys = Object.keys(lock.keys).filter(
+    (key) => !(key in sourceDict)
+  );
+  return { changedKeys, pendingEntries, deletedKeys };
+}
+async function syncLocaleFiles(options) {
+  const {
+    localesDir,
+    sourceLocale,
+    targetLocales,
+    batchSize,
+    translate,
+    contexts,
+    log = () => {
+    }
+  } = options;
+  const sourceFilePath = join(localesDir, `${sourceLocale}.json`);
+  if (!existsSync(sourceFilePath)) {
+    return {
+      status: "no-source",
+      translatedKeys: [],
+      deletedKeys: [],
+      failures: []
+    };
+  }
+  const sourceDict = JSON.parse(
+    readFileSync(sourceFilePath, "utf-8")
+  );
+  const lockFilePath = join(localesDir, ".solid-translate.lock");
+  let lock = { version: 1, sourceLocale, keys: {} };
+  if (existsSync(lockFilePath)) {
+    try {
+      lock = JSON.parse(readFileSync(lockFilePath, "utf-8"));
+    } catch {
+    }
+  }
+  const { changedKeys, pendingEntries, deletedKeys } = diffLock(
+    sourceDict,
+    lock,
+    contexts
+  );
+  for (const key of deletedKeys) {
+    delete lock.keys[key];
+  }
+  const changedCount = Object.keys(changedKeys).length;
+  if (changedCount === 0 && deletedKeys.length === 0) {
+    log("No changes detected in locale files.");
+    return {
+      status: "no-changes",
+      translatedKeys: [],
+      deletedKeys: [],
+      failures: []
+    };
+  }
+  if (changedCount === 0) {
+    for (const targetLocale of targetLocales) {
+      const targetFilePath = join(localesDir, `${targetLocale}.json`);
+      const existing = readTargetFile(targetFilePath);
+      writeTargetFile(targetFilePath, existing, sourceDict);
+      log(`  ${targetLocale}: pruned deleted keys`);
+    }
+    writeFileSync(lockFilePath, JSON.stringify(lock, null, 2) + "\n");
+    log(
+      `Removed ${deletedKeys.length} deleted key${deletedKeys.length > 1 ? "s" : ""} from target locales.`
+    );
+    return { status: "synced", translatedKeys: [], deletedKeys, failures: [] };
+  }
+  log(
+    `Translating ${changedCount} key${changedCount > 1 ? "s" : ""} to ${targetLocales.length} locale${targetLocales.length > 1 ? "s" : ""}...`
+  );
+  const changedContexts = {};
+  for (const key of Object.keys(changedKeys)) {
+    const ctx = pendingEntries[key]?.context;
+    if (ctx) changedContexts[key] = ctx;
+  }
+  const failures = [];
+  const failedKeys = /* @__PURE__ */ new Set();
+  for (const targetLocale of targetLocales) {
+    const targetFilePath = join(localesDir, `${targetLocale}.json`);
+    const existing = readTargetFile(targetFilePath);
+    const entries = Object.entries(changedKeys);
+    for (let i = 0; i < entries.length; i += batchSize) {
+      const batch = Object.fromEntries(entries.slice(i, i + batchSize));
+      try {
+        const translated = await translate(
+          batch,
+          targetLocale,
+          changedContexts
+        );
+        Object.assign(existing, translated);
+      } catch (err) {
+        failures.push({
+          locale: targetLocale,
+          keys: Object.keys(batch),
+          error: err
+        });
+        for (const key of Object.keys(batch)) {
+          failedKeys.add(key);
+        }
+      }
+    }
+    writeTargetFile(targetFilePath, existing, sourceDict);
+    log(`  ${targetLocale}: ${Object.keys(existing).length} keys`);
+  }
+  const translatedKeys = [];
+  for (const [key, entry] of Object.entries(pendingEntries)) {
+    if (failedKeys.has(key)) continue;
+    lock.keys[key] = entry;
+    translatedKeys.push(key);
+  }
+  writeFileSync(lockFilePath, JSON.stringify(lock, null, 2) + "\n");
+  return { status: "synced", translatedKeys, deletedKeys, failures };
+}
+function formatSyncFailures(failures) {
+  return failures.map((failure) => {
+    const message = failure.error instanceof Error ? failure.error.message : String(failure.error);
+    return `${failure.locale}: ${failure.keys.length} key${failure.keys.length > 1 ? "s" : ""} [${failure.keys.join(", ")}] \u2014 ${message}`;
+  });
+}
+function readTargetFile(targetFilePath) {
+  if (!existsSync(targetFilePath)) return {};
+  try {
+    return JSON.parse(readFileSync(targetFilePath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeTargetFile(targetFilePath, translations, sourceDict) {
+  for (const key of Object.keys(translations)) {
+    if (!(key in sourceDict)) {
+      delete translations[key];
+    }
+  }
+  const sorted = Object.fromEntries(
+    Object.entries(translations).sort(([a], [b]) => a.localeCompare(b))
+  );
+  writeFileSync(targetFilePath, JSON.stringify(sorted, null, 2) + "\n");
+}
+
 // src/cli.ts
 var CONFIG_FILENAMES = [
   "solid-translate.config.json",
@@ -152,6 +238,10 @@ async function main() {
     await runTranslate();
     return;
   }
+  if (command === "check") {
+    await runCheck(args.includes("--json"));
+    return;
+  }
   console.error(`Unknown command: ${command}`);
   printUsage();
   process.exit(1);
@@ -164,6 +254,8 @@ Usage:
   solid-translate init         Create a config file
   solid-translate extract      Extract strings from source files
   solid-translate translate    Translate source strings + files to target locales
+  solid-translate check        Verify translations are up to date (no AI calls)
+                               Exit 0 = fresh, 1 = stale. Use --json for machine output
 
 Config: solid-translate.config.json (or .js/.ts)
 
@@ -176,7 +268,7 @@ Environment variables:
 }
 async function initConfig() {
   const configPath = resolve("solid-translate.config.json");
-  if (existsSync(configPath)) {
+  if (existsSync2(configPath)) {
     console.log("Config already exists: solid-translate.config.json");
     return;
   }
@@ -194,16 +286,16 @@ async function initConfig() {
       mdx: { include: [] }
     }
   };
-  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  writeFileSync2(configPath, JSON.stringify(config, null, 2) + "\n");
   console.log("Created solid-translate.config.json");
   console.log("Edit it to set your target locales and AI provider.");
 }
 async function loadConfig() {
   for (const name of CONFIG_FILENAMES) {
     const path = resolve(name);
-    if (existsSync(path)) {
+    if (existsSync2(path)) {
       if (name.endsWith(".json")) {
-        return JSON.parse(readFileSync(path, "utf-8"));
+        return JSON.parse(readFileSync2(path, "utf-8"));
       }
       const mod = await import(path);
       return mod.default || mod;
@@ -267,7 +359,7 @@ async function runExtract() {
     "src/**/*.ts",
     "src/**/*.jsx"
   ];
-  if (!existsSync(localesDir)) {
+  if (!existsSync2(localesDir)) {
     mkdirSync(localesDir, { recursive: true });
   }
   const { glob } = await import("glob");
@@ -277,7 +369,7 @@ async function runExtract() {
     const files = await glob(pattern, { cwd: root, absolute: true });
     for (const file of files) {
       try {
-        const code = readFileSync(file, "utf-8");
+        const code = readFileSync2(file, "utf-8");
         const extracted = extractStringsFromSource(
           code,
           relative(root, file)
@@ -290,11 +382,11 @@ async function runExtract() {
       }
     }
   }
-  const sourceFilePath = join(localesDir, `${sourceLocale}.json`);
+  const sourceFilePath = join2(localesDir, `${sourceLocale}.json`);
   let existing = {};
-  if (existsSync(sourceFilePath)) {
+  if (existsSync2(sourceFilePath)) {
     try {
-      existing = JSON.parse(readFileSync(sourceFilePath, "utf-8"));
+      existing = JSON.parse(readFileSync2(sourceFilePath, "utf-8"));
     } catch {
     }
   }
@@ -308,12 +400,157 @@ async function runExtract() {
   const sorted = Object.fromEntries(
     Object.entries(existing).sort(([a], [b]) => a.localeCompare(b))
   );
-  writeFileSync(sourceFilePath, JSON.stringify(sorted, null, 2) + "\n");
+  writeFileSync2(sourceFilePath, JSON.stringify(sorted, null, 2) + "\n");
   console.log(
     `Extracted ${total} strings (${newKeys} new) \u2192 ${relative(root, sourceFilePath)}`
   );
 }
+async function runCheck(jsonOutput) {
+  const config = await loadConfig();
+  const root = process.cwd();
+  const sourceLocale = config.sourceLocale || "en";
+  const targetLocales = config.targetLocales || [];
+  const localesDir = resolve(config.localesDir || "./src/locales");
+  const patterns = config.include || [
+    "src/**/*.tsx",
+    "src/**/*.ts",
+    "src/**/*.jsx"
+  ];
+  const { glob } = await import("glob");
+  const extracted = {};
+  const contexts = {};
+  for (const pattern of patterns) {
+    const files = await glob(pattern, { cwd: root, absolute: true });
+    for (const file of files) {
+      try {
+        const code = readFileSync2(file, "utf-8");
+        const entries = extractStringsFromSource(
+          code,
+          relative(root, file)
+        );
+        for (const entry of entries) {
+          extracted[entry.key] = entry.source;
+          if (entry.context) {
+            contexts[entry.key] = entry.context;
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  const sourceFilePath = join2(localesDir, `${sourceLocale}.json`);
+  const sourceDict = {};
+  if (existsSync2(sourceFilePath)) {
+    try {
+      Object.assign(
+        sourceDict,
+        JSON.parse(readFileSync2(sourceFilePath, "utf-8"))
+      );
+    } catch {
+    }
+  }
+  for (const [key, value] of Object.entries(extracted)) {
+    if (!(key in sourceDict)) {
+      sourceDict[key] = value;
+    }
+  }
+  const lockFilePath = join2(localesDir, ".solid-translate.lock");
+  let lock = { version: 1, sourceLocale, keys: {} };
+  if (existsSync2(lockFilePath)) {
+    try {
+      lock = JSON.parse(readFileSync2(lockFilePath, "utf-8"));
+    } catch {
+    }
+  }
+  const report = {
+    fresh: true,
+    lock: { missing: [], changed: [], orphaned: [] },
+    locales: {}
+  };
+  for (const [key, value] of Object.entries(sourceDict)) {
+    const entry = lock.keys[key];
+    if (!entry) {
+      report.lock.missing.push(key);
+    } else if (entry.hash !== hashContent(value) || (entry.context ?? void 0) !== (contexts[key] ?? void 0)) {
+      report.lock.changed.push(key);
+    }
+  }
+  for (const key of Object.keys(lock.keys)) {
+    if (!(key in sourceDict)) {
+      report.lock.orphaned.push(key);
+    }
+  }
+  const sourceKeys = Object.keys(sourceDict);
+  for (const targetLocale of targetLocales) {
+    const targetFilePath = join2(localesDir, `${targetLocale}.json`);
+    let dict = {};
+    let fileExists = existsSync2(targetFilePath);
+    if (fileExists) {
+      try {
+        dict = JSON.parse(readFileSync2(targetFilePath, "utf-8"));
+      } catch {
+        fileExists = false;
+      }
+    }
+    const localeReport = {
+      missing: sourceKeys.filter((key) => !(key in dict)),
+      orphaned: Object.keys(dict).filter((key) => !(key in sourceDict)),
+      fileExists
+    };
+    report.locales[targetLocale] = localeReport;
+  }
+  report.fresh = report.lock.missing.length === 0 && report.lock.changed.length === 0 && report.lock.orphaned.length === 0 && Object.values(report.locales).every(
+    (l) => l.missing.length === 0 && l.orphaned.length === 0
+  );
+  if (jsonOutput) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    printCheckReport(report, sourceLocale);
+  }
+  process.exit(report.fresh ? 0 : 1);
+}
+function printCheckReport(report, sourceLocale) {
+  if (report.fresh) {
+    console.log("Translations are up to date.");
+    return;
+  }
+  console.log("Translations are stale:\n");
+  const { missing, changed, orphaned } = report.lock;
+  if (missing.length || changed.length || orphaned.length) {
+    console.log(".solid-translate.lock:");
+    for (const key of missing) {
+      console.log(`  missing:  ${JSON.stringify(key)} (never translated)`);
+    }
+    for (const key of changed) {
+      console.log(`  changed:  ${JSON.stringify(key)} (text or context changed)`);
+    }
+    for (const key of orphaned) {
+      console.log(`  orphaned: ${JSON.stringify(key)} (no longer in source)`);
+    }
+  }
+  for (const [locale, localeReport] of Object.entries(report.locales)) {
+    if (!localeReport.missing.length && !localeReport.orphaned.length) {
+      continue;
+    }
+    if (!localeReport.fileExists) {
+      console.log(`${locale}.json: (file missing)`);
+    } else {
+      console.log(`${locale}.json:`);
+    }
+    for (const key of localeReport.missing) {
+      console.log(`  missing:  ${JSON.stringify(key)}`);
+    }
+    for (const key of localeReport.orphaned) {
+      console.log(`  orphaned: ${JSON.stringify(key)}`);
+    }
+  }
+  console.log(
+    `
+Run \`solid-translate translate\` to refresh ${sourceLocale} \u2192 targets.`
+  );
+}
 async function runTranslate() {
+  const { translateBatch: translateBatch2, translateMarkdown: translateMarkdown2 } = await import("./translate-M737VQHG.js");
   const config = await loadConfig();
   const root = process.cwd();
   const sourceLocale = config.sourceLocale || "en";
@@ -350,7 +587,7 @@ async function runTranslate() {
           absolute: true
         });
         for (const file of files) {
-          const content = readFileSync(file, "utf-8");
+          const content = readFileSync2(file, "utf-8");
           for (const targetLocale of targetLocales) {
             const targetPath = resolve(
               root,
@@ -366,7 +603,7 @@ async function runTranslate() {
             if (format === "json") {
               try {
                 const sourceDict = JSON.parse(content);
-                const translated = await translateBatch(
+                const translated = await translateBatch2(
                   model,
                   sourceDict,
                   targetLocale,
@@ -374,7 +611,7 @@ async function runTranslate() {
                   config.systemPrompt
                 );
                 mkdirSync(dirname(actualTarget), { recursive: true });
-                writeFileSync(
+                writeFileSync2(
                   actualTarget,
                   JSON.stringify(translated, null, 2) + "\n"
                 );
@@ -389,7 +626,7 @@ async function runTranslate() {
               }
             } else {
               try {
-                const translated = await translateMarkdown(
+                const translated = await translateMarkdown2(
                   model,
                   content,
                   targetLocale,
@@ -397,7 +634,7 @@ async function runTranslate() {
                   config.systemPrompt
                 );
                 mkdirSync(dirname(actualTarget), { recursive: true });
-                writeFileSync(actualTarget, translated);
+                writeFileSync2(actualTarget, translated);
                 console.log(
                   `${format}: ${relative(root, actualTarget)}`
                 );
@@ -416,86 +653,37 @@ async function runTranslate() {
   console.log("\nTranslation complete.");
 }
 async function translateLocaleFiles(model, localesDir, sourceLocale, targetLocales, batchSize, systemPrompt) {
-  const sourceFilePath = join(localesDir, `${sourceLocale}.json`);
-  if (!existsSync(sourceFilePath)) {
+  const result = await syncLocaleFiles({
+    localesDir,
+    sourceLocale,
+    targetLocales,
+    batchSize,
+    translate: (batch, targetLocale, contexts) => translateBatch(
+      model,
+      batch,
+      targetLocale,
+      sourceLocale,
+      systemPrompt,
+      contexts
+    ),
+    log: (message) => console.log(message)
+  });
+  if (result.status === "no-source") {
     console.log(
       "No source locale file found. Run `solid-translate extract` first."
     );
     return;
   }
-  const sourceDict = JSON.parse(
-    readFileSync(sourceFilePath, "utf-8")
-  );
-  const lockFilePath = join(localesDir, ".solid-translate.lock");
-  let lock = { version: 1, sourceLocale, keys: {} };
-  if (existsSync(lockFilePath)) {
-    try {
-      lock = JSON.parse(readFileSync(lockFilePath, "utf-8"));
-    } catch {
-    }
-  }
-  const changedKeys = {};
-  for (const [key, value] of Object.entries(sourceDict)) {
-    const hash = hashContent(value);
-    const existing = lock.keys[key];
-    if (!existing || existing.hash !== hash) {
-      changedKeys[key] = value;
-      lock.keys[key] = { hash, source: value };
-    }
-  }
-  for (const key of Object.keys(lock.keys)) {
-    if (!(key in sourceDict)) {
-      delete lock.keys[key];
-    }
-  }
-  if (Object.keys(changedKeys).length === 0) {
-    console.log("No changes detected in locale files.");
-    return;
-  }
-  const count = Object.keys(changedKeys).length;
-  console.log(
-    `Translating ${count} key${count > 1 ? "s" : ""} to ${targetLocales.length} locale${targetLocales.length > 1 ? "s" : ""}...`
-  );
-  for (const targetLocale of targetLocales) {
-    const targetFilePath = join(localesDir, `${targetLocale}.json`);
-    let existing = {};
-    if (existsSync(targetFilePath)) {
-      try {
-        existing = JSON.parse(readFileSync(targetFilePath, "utf-8"));
-      } catch {
-      }
+  if (result.failures.length > 0) {
+    console.error("\nTranslation failed for some batches:");
+    for (const line of formatSyncFailures(result.failures)) {
+      console.error(`  ${line}`);
     }
-    const entries = Object.entries(changedKeys);
-    for (let i = 0; i < entries.length; i += batchSize) {
-      const batch = Object.fromEntries(entries.slice(i, i + batchSize));
-      try {
-        const translated = await translateBatch(
-          model,
-          batch,
-          targetLocale,
-          sourceLocale,
-          systemPrompt
-        );
-        Object.assign(existing, translated);
-      } catch (err) {
-        console.error(
-          `Failed to translate batch for ${targetLocale}:`,
-          err
-        );
-      }
-    }
-    for (const key of Object.keys(existing)) {
-      if (!(key in sourceDict)) {
-        delete existing[key];
-      }
-    }
-    const sorted = Object.fromEntries(
-      Object.entries(existing).sort(([a], [b]) => a.localeCompare(b))
+    console.error(
+      "Failed keys were not recorded in the lock file \u2014 fix the error and rerun `solid-translate translate` to retry them."
     );
-    writeFileSync(targetFilePath, JSON.stringify(sorted, null, 2) + "\n");
-    console.log(`  ${targetLocale}: ${Object.keys(sorted).length} keys`);
+    process.exit(1);
   }
-  writeFileSync(lockFilePath, JSON.stringify(lock, null, 2) + "\n");
 }
 main().catch((err) => {
   console.error(err);