@ccgp/i18n-ai 0.0.1

package/README.md

@@ -0,0 +1,83 @@
+# i18n-ai
+
+AI-powered internationalization (i18n) translation and synchronization library. This tool automates the translation of your JSON message files using AI, keeping them synchronized with your base locale.
+
+## Features
+
+- 🤖 **AI-Powered**: Uses Google Gemini (via OpenRouter) to generate context-aware translations.
+- 🔄 **Smart Synchronization**: Detects new, modified, and obsolete keys.
+- 🔒 **Lock File System**: Prevents unnecessary re-translations of already translated content.
+- 🧩 **Framework Agnostic**: Works with any i18n library that uses JSON files (next-intl, react-i18next, etc.).
+
+## Installation
+
+```bash
+bun add @ccgp/i18n-ai
+# or
+npm install @ccgp/i18n-ai
+```
+
+## Usage
+
+### CLI
+
+The easiest way to use `i18n-ai` is via the CLI.
+
+Add a script to your `package.json`:
+
+```json
+{
+  "scripts": {
+    "i18n:sync": "i18n-ai sync"
+  }
+}
+```
+
+Or run it directly:
+
+```bash
+bun x i18n-ai sync
+```
+
+#### Configuration
+
+The CLI attempts to auto-detect your configuration from `i18n/routing.ts` if you are using `next-intl`. Otherwise, you can specify options:
+
+```bash
+i18n-ai sync --locales en,es,fr --default en --dir messages
+```
+
+### Environment Variables
+
+You need to provide an API key for the AI provider.
+
+Create a `.env` file:
+
+```env
+OPENROUTER_API_KEY=your_api_key
+# or
+AI_API_KEY=your_api_key
+```
+
+## Programmatic Usage
+
+You can also use the library programmatically:
+
+```typescript
+import { TranslationService } from 'i18n-ai';
+import { resolve } from 'path';
+
+const service = new TranslationService({
+  locales: ['en', 'es', 'fr'],
+  defaultLocale: 'en',
+  messagesDir: resolve(process.cwd(), 'messages'),
+  lockFilePath: resolve(process.cwd(), 'translation-lock.json'),
+  apiKey: process.env.AI_API_KEY
+});
+
+await service.sync();
+```
+
+## License
+
+ISC

package/dist/chunk-QBRFUS6N.mjs

@@ -0,0 +1,292 @@
+// src/core/translator.ts
+import { createOpenRouter } from "@openrouter/ai-sdk-provider";
+import { generateText, Output } from "ai";
+import z from "zod";
+var translate = async ({ text, lang, targetLang, apiKey, model }) => {
+  const token = apiKey || process.env.OPENROUTER_API_KEY || process.env.AI_API_KEY;
+  if (!token) {
+    throw new Error("Missing API Key. Please provide apiKey or set OPENROUTER_API_KEY / AI_API_KEY environment variable.");
+  }
+  const openrouter = createOpenRouter({
+    apiKey: token
+  });
+  const { output } = await generateText({
+    model: openrouter.languageModel(model || "google/gemini-2.5-flash"),
+    prompt: `Translate the following text from ${lang} to ${targetLang}. Return ONLY the translated text, no explanations or additional text.
+
+Text to translate: ${text}`,
+    output: Output.object({
+      schema: z.object({
+        translatedText: z.string()
+      })
+    })
+  });
+  return output.translatedText;
+};
+
+// src/core/lock-manager.ts
+import { createHash } from "crypto";
+import { readFile, writeFile } from "fs/promises";
+function generateHash(text) {
+  return createHash("sha256").update(text).digest("hex").substring(0, 16);
+}
+async function loadLock(lockPath) {
+  try {
+    const content = await readFile(lockPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    return {
+      version: "1.0.0",
+      lastSync: (/* @__PURE__ */ new Date()).toISOString(),
+      locales: {}
+    };
+  }
+}
+async function saveLock(lockPath, lock) {
+  lock.lastSync = (/* @__PURE__ */ new Date()).toISOString();
+  const content = JSON.stringify(lock, null, 2);
+  await writeFile(lockPath, content + "\n", "utf-8");
+}
+function detectChange(key, locale, sourceText, currentTranslation, lock) {
+  const localeData = lock.locales[locale];
+  const lockEntry = localeData?.[key];
+  if (!lockEntry) {
+    return {
+      key,
+      status: "new",
+      sourceText,
+      currentTranslation
+    };
+  }
+  const currentHash = generateHash(sourceText);
+  if (currentHash !== lockEntry.sourceHash) {
+    return {
+      key,
+      status: "modified",
+      sourceText,
+      currentTranslation,
+      previousSourceText: lockEntry.sourceText
+    };
+  }
+  return {
+    key,
+    status: "unchanged",
+    sourceText,
+    currentTranslation: lockEntry.translation
+  };
+}
+function updateLockEntry(lock, locale, key, sourceText, translation) {
+  if (!lock.locales[locale]) {
+    lock.locales[locale] = {};
+  }
+  lock.locales[locale][key] = {
+    sourceHash: generateHash(sourceText),
+    sourceText,
+    translation,
+    translatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function analyzeChanges(baseFlat, targetFlat, locale, lock) {
+  const result = {
+    new: [],
+    modified: [],
+    unchanged: []
+  };
+  for (const [key, sourceText] of baseFlat.entries()) {
+    const currentTranslation = targetFlat.get(key);
+    const change = detectChange(key, locale, sourceText, currentTranslation, lock);
+    result[change.status].push(change);
+  }
+  return result;
+}
+function cleanupLock(lock, locale, validKeys) {
+  if (!lock.locales[locale]) {
+    return 0;
+  }
+  const currentKeys = Object.keys(lock.locales[locale]);
+  let removedCount = 0;
+  for (const key of currentKeys) {
+    if (!validKeys.has(key)) {
+      delete lock.locales[locale][key];
+      removedCount++;
+    }
+  }
+  return removedCount;
+}
+
+// src/core/sync.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { join } from "path";
+import chalk from "chalk";
+function flattenObject(obj, prefix = "") {
+  const result = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(obj)) {
+    const fullPath = prefix ? `${prefix}.${key}` : key;
+    if (typeof value === "string") {
+      result.set(fullPath, value);
+    } else if (typeof value === "object" && value !== null) {
+      const nested = flattenObject(value, fullPath);
+      nested.forEach((val, path) => result.set(path, val));
+    }
+  }
+  return result;
+}
+function unflattenObject(flatMap) {
+  const result = {};
+  for (const [path, value] of flatMap.entries()) {
+    const keys = path.split(".");
+    let current = result;
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      if (!current[key]) {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+    current[keys[keys.length - 1]] = value;
+  }
+  return result;
+}
+var TranslationService = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async sync() {
+    console.log(chalk.bold("\u{1F30D} AI Translation Synchronization System"));
+    console.log(chalk.dim("\u2550".repeat(50)));
+    console.log("");
+    try {
+      console.log(`\u2713 Locales found: ${chalk.green(this.config.locales.join(", "))}`);
+      console.log(`\u2713 Base locale: ${chalk.cyan(this.config.defaultLocale)}`);
+      const basePath = join(this.config.messagesDir, `${this.config.defaultLocale}.json`);
+      let baseContent;
+      try {
+        baseContent = await readFile2(basePath, "utf-8");
+      } catch (e) {
+        throw new Error(`Could not read base locale file at ${basePath}`);
+      }
+      const baseObj = JSON.parse(baseContent);
+      const baseFlat = flattenObject(baseObj);
+      console.log(`\u{1F4D6} Loading ${this.config.defaultLocale}.json (${baseFlat.size} keys total)`);
+      console.log("\u{1F510} Loading lock file...");
+      const lock = await loadLock(this.config.lockFilePath);
+      const targetLocales = this.config.locales.filter((l) => l !== this.config.defaultLocale);
+      for (const targetLocale of targetLocales) {
+        await this.syncLocale(targetLocale, baseFlat, lock);
+      }
+      await saveLock(this.config.lockFilePath, lock);
+      console.log(`
+\u{1F510} Lock file updated at ${this.config.lockFilePath}`);
+      console.log(chalk.dim("\n\u2550".repeat(50)));
+      console.log(chalk.green("\u2705 Synchronization complete!\n"));
+    } catch (error) {
+      console.error(chalk.red("\n\u274C Error during synchronization:"), error);
+      throw error;
+    }
+  }
+  async syncLocale(targetLocale, baseFlat, lock) {
+    console.log(`
+\u{1F50E} Synchronizing: ${chalk.yellow(targetLocale)}`);
+    console.log(chalk.dim("\u2500".repeat(50)));
+    const targetPath = join(this.config.messagesDir, `${targetLocale}.json`);
+    let targetObj = {};
+    try {
+      const targetContent = await readFile2(targetPath, "utf-8");
+      targetObj = JSON.parse(targetContent);
+    } catch {
+      console.log(chalk.yellow(`\u26A0\uFE0F  File ${targetLocale}.json does not exist, creating new one
+`));
+    }
+    const targetFlat = flattenObject(targetObj);
+    const changes = analyzeChanges(baseFlat, targetFlat, targetLocale, lock);
+    const validKeys = new Set(baseFlat.keys());
+    const obsoleteKeys = [];
+    for (const key of targetFlat.keys()) {
+      if (!validKeys.has(key)) {
+        obsoleteKeys.push(key);
+      }
+    }
+    console.log("\n\u{1F4CA} Change analysis:");
+    console.log(`  \u{1F4DD} ${changes.new.length} new key(s)`);
+    console.log(`  \u{1F504} ${changes.modified.length} modified key(s)`);
+    console.log(`  \u2705 ${changes.unchanged.length} unchanged key(s)`);
+    console.log(`  \u{1F5D1}\uFE0F  ${obsoleteKeys.length} obsolete key(s)`);
+    const toTranslate = [...changes.new, ...changes.modified];
+    if (toTranslate.length === 0 && obsoleteKeys.length === 0) {
+      console.log(chalk.green(`
+\u2705 ${targetLocale}.json is already fully synchronized`));
+      return;
+    }
+    if (changes.new.length > 0) {
+      console.log("\n\u{1F4DD} New keys:");
+      changes.new.forEach(({ key }) => console.log(chalk.green(`  + ${key}`)));
+    }
+    if (changes.modified.length > 0) {
+      console.log("\n\u{1F504} Modified keys:");
+      changes.modified.forEach(({ key, previousSourceText, sourceText }) => {
+        console.log(chalk.yellow(`  ~ ${key}`));
+        console.log(chalk.dim(`    Old: "${previousSourceText}"`));
+        console.log(chalk.dim(`    New: "${sourceText}"`));
+      });
+    }
+    if (toTranslate.length > 0) {
+      console.log(chalk.blue(`
+\u{1F916} Translating ${toTranslate.length} keys with AI...`));
+      console.log(chalk.dim("\u2500".repeat(50)));
+    }
+    let translatedCount = 0;
+    if (toTranslate.length > 0) {
+      for (const change of toTranslate) {
+        try {
+          const translatedValue = await translate({
+            text: change.sourceText,
+            lang: this.config.defaultLocale,
+            targetLang: targetLocale,
+            apiKey: this.config.apiKey,
+            model: this.config.model
+          });
+          targetFlat.set(change.key, translatedValue);
+          updateLockEntry(lock, targetLocale, change.key, change.sourceText, translatedValue);
+          translatedCount++;
+          const icon = change.status === "new" ? "\u2795" : "\u{1F504}";
+          console.log(`  ${icon} ${change.key}`);
+          console.log(chalk.dim(`     "${change.sourceText}"`));
+          console.log(chalk.cyan(`     \u2192 "${translatedValue}"`));
+        } catch (error) {
+          console.error(chalk.red(`  \u274C Error translating ${change.key}:`), error);
+          if (change.currentTranslation) {
+            targetFlat.set(change.key, change.currentTranslation);
+          }
+        }
+      }
+    }
+    for (const change of changes.unchanged) {
+      if (change.currentTranslation) {
+        targetFlat.set(change.key, change.currentTranslation);
+      }
+    }
+    for (const key of obsoleteKeys) {
+      targetFlat.delete(key);
+    }
+    cleanupLock(lock, targetLocale, validKeys);
+    const updatedObj = unflattenObject(targetFlat);
+    const updatedContent = JSON.stringify(updatedObj, null, 2);
+    await writeFile2(targetPath, updatedContent + "\n", "utf-8");
+    console.log(chalk.green(`
+\u{1F4BE} ${targetPath} updated`));
+  }
+};
+
+export {
+  translate,
+  generateHash,
+  loadLock,
+  saveLock,
+  detectChange,
+  updateLockEntry,
+  analyzeChanges,
+  cleanupLock,
+  flattenObject,
+  unflattenObject,
+  TranslationService
+};

package/dist/cli.d.mts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node