@cgaravitoq/i18n-ai 0.2.3

package/dist/index.js

@@ -0,0 +1,326 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TranslationService: () => TranslationService,
+  analyzeLocale: () => analyzeLocale,
+  translateBatch: () => translateBatch,
+  updateLock: () => updateLock,
+  withLockFile: () => withLockFile
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/lock.ts
+var import_node_crypto = require("crypto");
+var import_promises = require("fs/promises");
+var import_proper_lockfile = require("proper-lockfile");
+var hash = (text) => (0, import_node_crypto.createHash)("sha256").update(text).digest("hex").slice(0, 32);
+var hashesMatch = (current, stored) => current === stored || stored.length === 16 && current.startsWith(stored);
+async function loadLock(path) {
+  try {
+    return JSON.parse(await (0, import_promises.readFile)(path, "utf-8"));
+  } catch (e) {
+    if (e.code === "ENOENT") return { locales: {} };
+    if (e instanceof SyntaxError)
+      throw new Error(`Lock file corrupted: ${path}`);
+    throw e;
+  }
+}
+async function saveLock(path, lock) {
+  await (0, import_promises.writeFile)(path, `${JSON.stringify(lock, null, 2)}
+`);
+}
+async function withLockFile(path, fn) {
+  let lock = await loadLock(path);
+  if (Object.keys(lock.locales).length === 0) await saveLock(path, lock);
+  const release = await (0, import_proper_lockfile.lock)(path, {
+    retries: { retries: 5, factor: 2, minTimeout: 1e3, maxTimeout: 5e3 },
+    stale: 3e4
+  });
+  try {
+    lock = await loadLock(path);
+    const result = await fn(lock);
+    await saveLock(path, lock);
+    return result;
+  } finally {
+    await release();
+  }
+}
+function analyzeLocale(base, target, locale, lock) {
+  const result = {
+    locale,
+    toTranslate: [],
+    toPreserve: /* @__PURE__ */ new Map(),
+    toRemove: /* @__PURE__ */ new Set(),
+    manualEdits: /* @__PURE__ */ new Map()
+  };
+  const localeData = lock.locales[locale] ?? {};
+  for (const [key, text] of base) {
+    const entry = localeData[key];
+    const current = target.get(key);
+    const currentHash = hash(text);
+    if (!entry) {
+      current ? result.toPreserve.set(key, current) : result.toTranslate.push({ key, text, status: "new" });
+    } else if (!hashesMatch(currentHash, entry.sourceHash)) {
+      result.toTranslate.push({ key, text, status: "modified" });
+    } else if (current && current !== entry.translation) {
+      result.manualEdits.set(key, current);
+    } else {
+      result.toPreserve.set(key, current ?? entry.translation);
+    }
+  }
+  for (const key of target.keys()) {
+    if (!base.has(key)) result.toRemove.add(key);
+  }
+  return result;
+}
+function updateLock(lock, locale, base, final) {
+  lock.locales[locale] ??= {};
+  const localeData = lock.locales[locale];
+  for (const [key, translation] of final) {
+    const sourceText = base.get(key);
+    if (sourceText) {
+      localeData[key] = {
+        sourceHash: hash(sourceText),
+        sourceText,
+        translation
+      };
+    }
+  }
+  for (const key of Object.keys(localeData)) {
+    if (!base.has(key)) delete localeData[key];
+  }
+}
+
+// src/core/translator.ts
+var import_ai_sdk_provider = require("@openrouter/ai-sdk-provider");
+var import_ai = require("ai");
+var z2 = __toESM(require("zod"));
+
+// src/env.ts
+var import_env_core = require("@t3-oss/env-core");
+var z = __toESM(require("zod"));
+var env = (0, import_env_core.createEnv)({
+  server: {
+    OPENROUTER_API_KEY: z.string()
+  },
+  runtimeEnv: process.env
+});
+
+// src/core/translator.ts
+var DEFAULT_MODEL = "google/gemini-2.5-flash";
+var translationSchema = z2.object({
+  translations: z2.array(
+    z2.object({
+      key: z2.string(),
+      value: z2.string()
+    })
+  )
+});
+var openrouter = null;
+var getOpenRouter = () => openrouter ?? (openrouter = (0, import_ai_sdk_provider.createOpenRouter)({ apiKey: env.OPENROUTER_API_KEY }));
+var SYSTEM_PROMPT = `You are a professional translator.
+
+RULES:
+1. Translate the provided key-value pairs from the source language to the target language
+2. Return an array of translations with the EXACT same keys and their translated values
+3. Do NOT translate variables in curly braces: {name}, {count}, etc. Keep them exactly as-is
+4. Maintain original tone and context
+5. For single words or short phrases, translate directly`;
+async function withRetry(fn, maxAttempts = 3) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      const msg = error.message?.toLowerCase() ?? "";
+      const retryable = msg.includes("network") || msg.includes("timeout") || msg.includes("econnreset") || msg.includes("429") || msg.includes("503") || msg.includes("502");
+      if (attempt === maxAttempts || !retryable) throw error;
+      await new Promise((r) => setTimeout(r, 2 ** (attempt - 1) * 1e3));
+    }
+  }
+  throw new Error("Unreachable");
+}
+async function translateBatch(batch) {
+  if (batch.entries.length === 0) return /* @__PURE__ */ new Map();
+  const inputArray = batch.entries.map((e) => ({ key: e.key, text: e.text }));
+  return withRetry(async () => {
+    const { output } = await (0, import_ai.generateText)({
+      model: getOpenRouter().languageModel(DEFAULT_MODEL),
+      output: import_ai.Output.object({
+        schema: translationSchema
+      }),
+      system: SYSTEM_PROMPT,
+      prompt: `Translate from "${batch.sourceLang}" to "${batch.targetLang}":
+
+${JSON.stringify(inputArray, null, 2)}
+
+Return the translations array with the same keys and translated values.`
+    });
+    if (!output.translations || output.translations.length === 0) {
+      throw new Error("Translation returned empty result");
+    }
+    const resultMap = new Map(output.translations.map((t) => [t.key, t.value]));
+    const missingKeys = batch.entries.filter((e) => !resultMap.has(e.key));
+    if (missingKeys.length > 0) {
+      throw new Error(
+        `Missing translations for keys: ${missingKeys.map((e) => e.key).join(", ")}`
+      );
+    }
+    return resultMap;
+  });
+}
+
+// src/core/sync.ts
+var import_promises2 = require("fs/promises");
+var import_node_path = require("path");
+var import_p_queue = __toESM(require("p-queue"));
+var chunk = (arr, n) => Array.from(
+  { length: Math.ceil(arr.length / n) },
+  (_, i) => arr.slice(i * n, (i + 1) * n)
+);
+var flatten = (obj, prefix = "") => {
+  const result = /* @__PURE__ */ new Map();
+  for (const [k, v] of Object.entries(obj)) {
+    const path = prefix ? `${prefix}.${k}` : k;
+    typeof v === "string" ? result.set(path, v) : flatten(v, path).forEach((val, p) => result.set(p, val));
+  }
+  return result;
+};
+var unflatten = (flat) => {
+  const result = {};
+  for (const [path, value] of flat) {
+    const keys = path.split(".");
+    let cur = result;
+    for (let i = 0; i < keys.length - 1; i++) {
+      cur = cur[keys[i]] ??= {};
+    }
+    cur[keys.at(-1)] = value;
+  }
+  return result;
+};
+var readJson = async (path) => {
+  try {
+    return JSON.parse(await (0, import_promises2.readFile)(path, "utf-8"));
+  } catch (e) {
+    if (e.code === "ENOENT") return null;
+    throw e;
+  }
+};
+var writeJsonAtomic = async (path, data) => {
+  const tmp = `${path}.tmp`;
+  await (0, import_promises2.writeFile)(tmp, `${JSON.stringify(data, null, 2)}
+`);
+  await (0, import_promises2.rename)(tmp, path);
+};
+var TranslationService = class {
+  constructor(config) {
+    this.config = config;
+    this.queue = new import_p_queue.default({ concurrency: config.concurrency ?? 10 });
+    this.batchSize = config.batchSize ?? 20;
+  }
+  queue;
+  batchSize;
+  async sync() {
+    const basePath = (0, import_node_path.join)(
+      this.config.messagesDir,
+      `${this.config.defaultLocale}.json`
+    );
+    const baseObj = await readJson(basePath);
+    if (!baseObj) throw new Error(`Base locale file not found: ${basePath}`);
+    const base = flatten(baseObj);
+    console.log(
+      `[ok] Loaded ${this.config.defaultLocale}.json (${base.size} keys)`
+    );
+    await withLockFile(this.config.lockFilePath, async (lock) => {
+      const locales = this.config.locales.filter(
+        (l) => l !== this.config.defaultLocale
+      );
+      await Promise.all(
+        locales.map((locale) => this.syncLocale(locale, base, lock))
+      );
+    });
+    console.log("\n[done] Synchronization complete!");
+  }
+  async syncLocale(locale, base, lock) {
+    const targetPath = (0, import_node_path.join)(this.config.messagesDir, `${locale}.json`);
+    const targetObj = await readJson(targetPath) ?? {};
+    const target = flatten(targetObj);
+    const changes = analyzeLocale(base, target, locale, lock);
+    const hasWork = changes.toTranslate.length > 0 || changes.toRemove.size > 0 || changes.manualEdits.size > 0;
+    console.log(
+      `
+[${locale}] ${changes.toTranslate.length} to translate, ${changes.toRemove.size} obsolete`
+    );
+    if (!hasWork) {
+      console.log("  [ok] Already synchronized");
+      return;
+    }
+    const translations = await this.translateAll(changes);
+    const final = new Map([
+      ...changes.toPreserve,
+      ...changes.manualEdits,
+      ...translations
+    ]);
+    changes.toRemove.forEach((k) => final.delete(k));
+    updateLock(lock, locale, base, final);
+    await writeJsonAtomic(targetPath, unflatten(final));
+    console.log(`  [ok] Updated ${targetPath}`);
+  }
+  async translateAll(changes) {
+    if (changes.toTranslate.length === 0) return /* @__PURE__ */ new Map();
+    const batches = chunk(changes.toTranslate, this.batchSize);
+    const results = await Promise.all(
+      batches.map(
+        (batch) => this.queue.add(
+          () => translateBatch({
+            entries: batch,
+            sourceLang: this.config.defaultLocale,
+            targetLang: changes.locale,
+            apiKey: this.config.apiKey,
+            model: this.config.model
+          })
+        )
+      )
+    );
+    return results.reduce(
+      (acc, r) => r ? new Map([...acc, ...r]) : acc,
+      /* @__PURE__ */ new Map()
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TranslationService,
+  analyzeLocale,
+  translateBatch,
+  updateLock,
+  withLockFile
+});

package/dist/index.mjs

@@ -0,0 +1,14 @@
+import {
+  TranslationService,
+  analyzeLocale,
+  translateBatch,
+  updateLock,
+  withLockFile
+} from "./chunk-IOH4K3A3.mjs";
+export {
+  TranslationService,
+  analyzeLocale,
+  translateBatch,
+  updateLock,
+  withLockFile
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@cgaravitoq/i18n-ai",
+  "version": "0.2.3",
+  "description": "AI-powered i18n translation and synchronization library",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "i18n-ai": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "start": "node dist/cli.js",
+    "lint": "tsc --noEmit"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CarlosPProjects/i18n-ai.git"
+  },
+  "keywords": [
+    "i18n",
+    "ai",
+    "translation",
+    "automation"
+  ],
+  "author": "Carlos Garavito",
+  "license": "ISC",
+  "dependencies": {
+    "@openrouter/ai-sdk-provider": "^1.5.4",
+    "@t3-oss/env-core": "^0.13.10",
+    "ai": "^6.0.37",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
+    "dotenv": "^17.2.3",
+    "p-queue": "^9.1.0",
+    "prompts": "^2.4.2",
+    "proper-lockfile": "^4.1.2",
+    "zod": "^4.3.5"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.9",
+    "@types/prompts": "^2.4.9",
+    "@types/proper-lockfile": "^4.1.4",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}