bctranslate 1.0.0

package/src/bridges/python.js

@@ -0,0 +1,183 @@
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PYTHON_SCRIPT = join(__dirname, '..', '..', 'python', 'translator.py');
+
+let cachedPythonCmd = null;
+
+/**
+ * Find the correct python command on this system.
+ */
+async function findPython() {
+  if (cachedPythonCmd) return cachedPythonCmd;
+
+  for (const cmd of ['python3', 'python']) {
+    try {
+      const result = await execSimple(cmd, ['--version']);
+      if (result.includes('Python 3')) {
+        cachedPythonCmd = cmd;
+        return cmd;
+      }
+    } catch { /* try next */ }
+  }
+  throw new Error(
+    'Python 3 not found. Install Python 3.8+ and ensure it is on your PATH.\n' +
+    '  Also install argostranslate: pip install argostranslate'
+  );
+}
+
+function execSimple(cmd, args) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(cmd, args, { stdio: ['pipe', 'pipe', 'pipe'] });
+    let out = '';
+    let err = '';
+    proc.stdout.on('data', (d) => (out += d.toString()));
+    proc.stderr.on('data', (d) => (err += d.toString()));
+    proc.on('close', (code) => {
+      if (code === 0) resolve(out.trim());
+      else reject(new Error(err || `Process exited with code ${code}`));
+    });
+    proc.on('error', reject);
+  });
+}
+
+/**
+ * Check that Python and argostranslate are available,
+ * and that the required language pair is installed.
+ */
+export async function checkPythonBridge(from, to) {
+  const py = await findPython();
+
+  // Check argostranslate is installed and language pair available
+  const checkScript = `
+import sys, json
+try:
+    import argostranslate.package
+    import argostranslate.translate
+except ImportError:
+    print(json.dumps({"error": "argostranslate not installed. Run: pip install argostranslate"}))
+    sys.exit(0)
+
+from_code = "${from}"
+to_code = "${to}"
+
+installed = argostranslate.translate.get_installed_languages()
+from_lang = None
+to_lang = None
+for lang in installed:
+    if lang.code == from_code:
+        from_lang = lang
+    if lang.code == to_code:
+        to_lang = lang
+
+if not from_lang or not to_lang:
+    available_codes = [l.code for l in installed]
+    # Try to auto-download
+    try:
+        argostranslate.package.update_package_index()
+        available_packages = argostranslate.package.get_available_packages()
+        pkg = next((p for p in available_packages if p.from_code == from_code and p.to_code == to_code), None)
+        if pkg:
+            print(json.dumps({"status": "downloading", "pair": f"{from_code}->{to_code}"}))
+            argostranslate.package.install_from_path(pkg.download())
+            print(json.dumps({"status": "ready"}))
+        else:
+            print(json.dumps({"error": f"Language pair {from_code}->{to_code} not available. Installed: {available_codes}"}))
+    except Exception as e:
+        print(json.dumps({"error": f"Failed to download language pair: {str(e)}. Installed: {available_codes}"}))
+else:
+    print(json.dumps({"status": "ready"}))
+`;
+
+  const result = await execSimple(py, ['-c', checkScript]);
+
+  // Parse last JSON line (might have multiple from downloading)
+  const lines = result.split('\n').filter(l => l.trim());
+  for (const line of lines.reverse()) {
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed.error) throw new Error(parsed.error);
+      if (parsed.status === 'ready') return true;
+    } catch (e) {
+      if (e.message && !e.message.includes('Unexpected')) throw e;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Translate a batch of strings using argostranslate via Python.
+ * Sends all strings at once for efficiency (model loads once).
+ *
+ * @param {Array<{key: string, text: string}>} batch - Strings to translate
+ * @param {string} from - Source language code
+ * @param {string} to - Target language code
+ * @returns {Promise<Object<string, string>>} Map of key -> translated text
+ */
+export async function translateBatch(batch, from, to) {
+  if (batch.length === 0) return {};
+
+  const py = await findPython();
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn(py, [PYTHON_SCRIPT, from, to], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, PYTHONIOENCODING: 'utf-8' },
+    });
+
+    const input = JSON.stringify(batch);
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', (d) => (stdout += d.toString()));
+    proc.stderr.on('data', (d) => (stderr += d.toString()));
+
+    proc.on('close', (code) => {
+      if (code !== 0) {
+        return reject(new Error(`Python translator failed (code ${code}): ${stderr}`));
+      }
+
+      try {
+        // Find the JSON output line (ignore any debug/warning output)
+        const lines = stdout.split('\n');
+        let result = null;
+        for (let i = lines.length - 1; i >= 0; i--) {
+          const line = lines[i].trim();
+          if (line.startsWith('{') || line.startsWith('[')) {
+            try {
+              result = JSON.parse(line);
+              break;
+            } catch { /* try previous line */ }
+          }
+        }
+
+        if (!result) {
+          return reject(new Error(`No valid JSON in Python output: ${stdout.slice(0, 500)}`));
+        }
+
+        // Convert array to map
+        const map = {};
+        if (Array.isArray(result)) {
+          for (const item of result) {
+            map[item.key] = item.text;
+          }
+        } else {
+          Object.assign(map, result);
+        }
+
+        resolve(map);
+      } catch (err) {
+        reject(new Error(`Failed to parse Python output: ${err.message}\nOutput: ${stdout.slice(0, 500)}`));
+      }
+    });
+
+    proc.on('error', (err) => reject(new Error(`Failed to spawn Python: ${err.message}`)));
+
+    proc.stdin.write(input);
+    proc.stdin.end();
+  });
+}

package/src/config.js

@@ -0,0 +1,28 @@
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join, basename } from 'path';
+
+const CONFIG_FILE = '.bctranslaterc.json';
+
+export function getConfigPath(cwd = process.cwd()) {
+  return join(cwd, CONFIG_FILE);
+}
+
+export function loadConfig(cwd = process.cwd()) {
+  const configPath = getConfigPath(cwd);
+  if (!existsSync(configPath)) return null;
+  try {
+    return JSON.parse(readFileSync(configPath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+export function saveConfig(config, cwd = process.cwd()) {
+  const configPath = getConfigPath(cwd);
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  return configPath;
+}
+
+export function configFileName() {
+  return CONFIG_FILE;
+}

package/src/detect.js

@@ -0,0 +1,58 @@
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Detect the project type (vue, react, vanilla) based on package.json and file structure.
+ */
+export function detectProject(cwd) {
+  const pkgPath = join(cwd, 'package.json');
+  let pkg = {};
+
+  if (existsSync(pkgPath)) {
+    try {
+      pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    } catch { /* ignore */ }
+  }
+
+  const allDeps = {
+    ...(pkg.dependencies || {}),
+    ...(pkg.devDependencies || {}),
+  };
+
+  // Vue detection
+  if (allDeps['vue'] || allDeps['nuxt'] || allDeps['@vue/cli-service']) {
+    const i18nPkg = allDeps['vue-i18n'] ? 'vue-i18n' : null;
+    return {
+      type: 'vue',
+      i18nPackage: i18nPkg,
+      usesCompositionApi: detectVueCompositionApi(cwd, allDeps),
+      srcDir: existsSync(join(cwd, 'src')) ? 'src' : '.',
+    };
+  }
+
+  // React detection
+  if (allDeps['react'] || allDeps['next'] || allDeps['gatsby']) {
+    const i18nPkg = allDeps['react-i18next'] ? 'react-i18next'
+      : allDeps['react-intl'] ? 'react-intl' : null;
+    return {
+      type: 'react',
+      i18nPackage: i18nPkg,
+      srcDir: existsSync(join(cwd, 'src')) ? 'src' : '.',
+    };
+  }
+
+  // Vanilla
+  return {
+    type: 'vanilla',
+    i18nPackage: null,
+    srcDir: '.',
+  };
+}
+
+function detectVueCompositionApi(cwd, deps) {
+  if (deps['@vue/composition-api']) return true;
+  // Vue 3 uses composition API by default
+  const vueVer = deps['vue'] || '';
+  if (vueVer.match(/[~^]?3/)) return true;
+  return false;
+}

package/src/generators/locales.js

@@ -0,0 +1,62 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+
+/**
+ * Determine the locale directory path based on project type.
+ */
+export function getLocaleDir(cwd, project) {
+  const candidates = [
+    join(cwd, 'src', 'locales'),
+    join(cwd, 'src', 'i18n', 'locales'),
+    join(cwd, 'locales'),
+    join(cwd, 'src', 'lang'),
+    join(cwd, 'public', 'locales'),
+  ];
+
+  for (const dir of candidates) {
+    if (existsSync(dir)) return dir;
+  }
+
+  // Default: create src/locales for vue/react, locales/ for vanilla
+  if (project.type === 'vanilla') {
+    return join(cwd, 'locales');
+  }
+  return join(cwd, 'src', 'locales');
+}
+
+/**
+ * Load an existing locale file, or return empty object.
+ */
+export function loadLocale(localeDir, langCode) {
+  const filePath = join(localeDir, `${langCode}.json`);
+  if (existsSync(filePath)) {
+    try {
+      return JSON.parse(readFileSync(filePath, 'utf-8'));
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+
+/**
+ * Save a locale file, merging with existing keys.
+ */
+export function saveLocale(localeDir, langCode, newEntries) {
+  mkdirSync(localeDir, { recursive: true });
+
+  const filePath = join(localeDir, `${langCode}.json`);
+  const existing = loadLocale(localeDir, langCode);
+
+  // Merge: new entries take precedence for new keys,
+  // but don't overwrite existing translations (idempotent)
+  const merged = { ...existing };
+  for (const [key, value] of Object.entries(newEntries)) {
+    if (!(key in merged)) {
+      merged[key] = value;
+    }
+  }
+
+  writeFileSync(filePath, JSON.stringify(merged, null, 2) + '\n', 'utf-8');
+  return filePath;
+}

package/src/generators/setup.js

@@ -0,0 +1,188 @@
+import { existsSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+import { getLocaleDir } from './locales.js';
+
+/**
+ * Ensure the i18n configuration file and locale files exist.
+ * Creates them if they don't.
+ *
+ * @param {string} cwd - Project root
+ * @param {object} project - Detected project info
+ * @param {string} from - Source language code
+ * @param {string} to - Target language code
+ * @param {string} [customLocaleDir] - Optional override for locale directory
+ */
+export async function ensureI18nSetup(cwd, project, from, to, customLocaleDir) {
+  const localeDir = customLocaleDir || getLocaleDir(cwd, project);
+  mkdirSync(localeDir, { recursive: true });
+
+  // Ensure locale JSON files exist
+  for (const lang of [from, to]) {
+    const localePath = join(localeDir, `${lang}.json`);
+    if (!existsSync(localePath)) {
+      writeFileSync(localePath, '{}\n', 'utf-8');
+      console.log(chalk.green(`  ✓ Created ${localePath}`));
+    }
+  }
+
+  if (project.type === 'vue') {
+    await ensureVueI18n(cwd, project, from, to, localeDir);
+  } else if (project.type === 'react') {
+    await ensureReactI18n(cwd, project, from, to, localeDir);
+  } else {
+    await ensureVanillaI18n(cwd, from, to, localeDir);
+  }
+}
+
+async function ensureVueI18n(cwd, project, from, to, localeDir) {
+  const i18nFile = join(cwd, 'src', 'i18n.js');
+
+  if (existsSync(i18nFile)) {
+    console.log(chalk.gray('  → i18n.js already exists, skipping setup'));
+    return;
+  }
+
+  const isVue3 = project.usesCompositionApi;
+  const relLocale = localeDir.replace(cwd, '.').replace(/\\/g, '/');
+
+  let content;
+  if (isVue3) {
+    content = `import { createI18n } from 'vue-i18n';
+import ${from} from '${relLocale}/${from}.json';
+import ${to} from '${relLocale}/${to}.json';
+
+const i18n = createI18n({
+  legacy: false,
+  locale: '${from}',
+  fallbackLocale: '${from}',
+  messages: {
+    ${from},
+    ${to},
+  },
+});
+
+export default i18n;
+`;
+  } else {
+    content = `import Vue from 'vue';
+import VueI18n from 'vue-i18n';
+import ${from} from '${relLocale}/${from}.json';
+import ${to} from '${relLocale}/${to}.json';
+
+Vue.use(VueI18n);
+
+const i18n = new VueI18n({
+  locale: '${from}',
+  fallbackLocale: '${from}',
+  messages: {
+    ${from},
+    ${to},
+  },
+});
+
+export default i18n;
+`;
+  }
+
+  mkdirSync(join(cwd, 'src'), { recursive: true });
+  writeFileSync(i18nFile, content, 'utf-8');
+  console.log(chalk.green(`  ✓ Created ${i18nFile}`));
+  console.log(chalk.yellow(`  ⚠ Don't forget to install vue-i18n: npm install vue-i18n`));
+  console.log(chalk.yellow(`  ⚠ Import and use i18n in your main.js/main.ts`));
+}
+
+async function ensureReactI18n(cwd, project, from, to, localeDir) {
+  const i18nFile = join(cwd, 'src', 'i18n.js');
+
+  if (existsSync(i18nFile)) {
+    console.log(chalk.gray('  → i18n.js already exists, skipping setup'));
+    return;
+  }
+
+  const relLocale = localeDir.replace(cwd, '.').replace(/\\/g, '/');
+
+  const content = `import i18n from 'i18next';
+import { initReactI18next } from 'react-i18next';
+import ${from} from '${relLocale}/${from}.json';
+import ${to} from '${relLocale}/${to}.json';
+
+i18n.use(initReactI18next).init({
+  resources: {
+    ${from}: { translation: ${from} },
+    ${to}: { translation: ${to} },
+  },
+  lng: '${from}',
+  fallbackLng: '${from}',
+  interpolation: {
+    escapeValue: false,
+  },
+});
+
+export default i18n;
+`;
+
+  mkdirSync(join(cwd, 'src'), { recursive: true });
+  writeFileSync(i18nFile, content, 'utf-8');
+  console.log(chalk.green(`  ✓ Created ${i18nFile}`));
+  console.log(chalk.yellow(`  ⚠ Don't forget to install: npm install i18next react-i18next`));
+  console.log(chalk.yellow(`  ⚠ Import './i18n' in your index.js/App.js`));
+}
+
+async function ensureVanillaI18n(cwd, from, to, localeDir) {
+  const i18nFile = join(cwd, 'i18n.js');
+
+  if (existsSync(i18nFile)) {
+    console.log(chalk.gray('  → i18n.js already exists, skipping setup'));
+    return;
+  }
+
+  const content = `/**
+ * Simple i18n for vanilla JS — generated by bctranslate
+ */
+(function () {
+  const locales = {};
+  let currentLocale = '${from}';
+
+  async function loadLocale(lang) {
+    if (locales[lang]) return;
+    const resp = await fetch('./locales/' + lang + '.json');
+    locales[lang] = await resp.json();
+  }
+
+  function t(key, params) {
+    const msg = (locales[currentLocale] && locales[currentLocale][key]) || key;
+    if (!params) return msg;
+    return msg.replace(/\\{(\\w+)\\}/g, function (_, k) {
+      return params[k] !== undefined ? params[k] : '{' + k + '}';
+    });
+  }
+
+  async function setLocale(lang) {
+    await loadLocale(lang);
+    currentLocale = lang;
+    // Re-translate all elements with data-i18n attribute
+    document.querySelectorAll('[data-i18n]').forEach(function (el) {
+      const key = el.getAttribute('data-i18n');
+      el.textContent = t(key);
+    });
+    document.querySelectorAll('[data-i18n-placeholder]').forEach(function (el) {
+      el.placeholder = t(el.getAttribute('data-i18n-placeholder'));
+    });
+    document.querySelectorAll('[data-i18n-title]').forEach(function (el) {
+      el.title = t(el.getAttribute('data-i18n-title'));
+    });
+  }
+
+  // Auto-init
+  loadLocale('${from}');
+  loadLocale('${to}');
+
+  window.i18n = { t: t, setLocale: setLocale, loadLocale: loadLocale };
+})();
+`;
+
+  writeFileSync(i18nFile, content, 'utf-8');
+  console.log(chalk.green(`  ✓ Created ${i18nFile}`));
+  console.log(chalk.yellow(`  ⚠ Add <script src="i18n.js"></script> to your HTML`));
+}

package/src/index.js

@@ -0,0 +1,155 @@
+import { readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { extname, relative, basename, dirname, join } from 'path';
+import { parseVue } from './parsers/vue.js';
+import { parseReact } from './parsers/react.js';
+import { parseHtml } from './parsers/html.js';
+import { parseJs } from './parsers/js.js';
+import { parseJson, applyJsonTranslations } from './parsers/json.js';
+import { translateBatch } from './bridges/python.js';
+import { getLocaleDir, saveLocale, loadLocale } from './generators/locales.js';
+
+/**
+ * Process a single file: extract strings, translate only untranslated ones,
+ * write results. Smart: skips strings already present in the target locale.
+ */
+export async function translateFile(filePath, opts) {
+  const { from, to, dryRun, outdir, project, cwd, verbose, jsonMode } = opts;
+  const ext = extname(filePath).toLowerCase();
+  const source = readFileSync(filePath, 'utf-8');
+  const relativePath = relative(cwd, filePath);
+
+  // Route to appropriate parser
+  let result;
+  switch (ext) {
+    case '.vue':
+      result = parseVue(source, filePath);
+      break;
+    case '.jsx':
+    case '.tsx':
+      result = parseReact(source, filePath);
+      break;
+    case '.html':
+    case '.htm':
+      result = parseHtml(source, filePath, project);
+      break;
+    case '.js':
+    case '.ts':
+      if (source.includes('React') || source.includes('jsx') || /<\w+[\s>]/.test(source)) {
+        result = parseReact(source, filePath);
+      } else {
+        result = parseJs(source, filePath, project);
+      }
+      break;
+    case '.json':
+      result = parseJson(source, filePath, { jsonMode });
+      break;
+    default:
+      return { count: 0, skipped: 0, relativePath };
+  }
+
+  if (!result.extracted || result.extracted.length === 0) {
+    return { count: 0, skipped: 0, relativePath };
+  }
+
+  // Deduplicate by key (same text = same hash key)
+  const seen = new Set();
+  const uniqueBatch = result.extracted
+    .map((item) => ({ key: item.key, text: item.text }))
+    .filter((item) => {
+      if (seen.has(item.key)) return false;
+      seen.add(item.key);
+      return true;
+    });
+
+  // ── Smart half-translation: load existing locale, skip already-done keys ──
+  const localeDir = opts.localesDir || getLocaleDir(cwd, project);
+  const existingTarget = loadLocale(localeDir, to);
+
+  const needsTranslation = uniqueBatch.filter((item) => !(item.key in existingTarget));
+  const skippedCount = uniqueBatch.length - needsTranslation.length;
+
+  // Start with existing translations
+  let translations = { ...existingTarget };
+
+  if (needsTranslation.length > 0) {
+    try {
+      const newTranslations = await translateBatch(needsTranslation, from, to);
+      Object.assign(translations, newTranslations);
+    } catch (err) {
+      if (verbose) {
+        console.error(`    Translation error: ${err.message}`);
+      }
+      // Fallback: use original text
+      for (const item of needsTranslation) {
+        translations[item.key] = item.text;
+      }
+    }
+  }
+
+  // Build locale entries for all extracted strings
+  const fromEntries = {};
+  const toEntries = {};
+  for (const item of uniqueBatch) {
+    fromEntries[item.key] = item.text;
+    toEntries[item.key] = translations[item.key] || item.text;
+  }
+
+  if (!dryRun) {
+    // Write locale files (merge with existing — won't overwrite manual edits)
+    saveLocale(localeDir, from, fromEntries);
+    saveLocale(localeDir, to, toEntries);
+
+    if (ext === '.json') {
+      const translatedData = applyJsonTranslations(result.jsonData, translations);
+      const outName = basename(filePath, ext) + `.${to}${ext}`;
+      const outPath = outdir
+        ? join(outdir, outName)
+        : join(dirname(filePath), outName);
+
+      mkdirSync(dirname(outPath), { recursive: true });
+      writeFileSync(outPath, JSON.stringify(translatedData, null, 2) + '\n', 'utf-8');
+    } else {
+      // Only rewrite source if it actually changed
+      if (result.source !== source) {
+        const outPath = outdir ? join(outdir, basename(filePath)) : filePath;
+        if (outdir) mkdirSync(outdir, { recursive: true });
+
+        const tmpPath = outPath + '.bctmp';
+        writeFileSync(tmpPath, result.source, 'utf-8');
+        const { renameSync } = await import('fs');
+        renameSync(tmpPath, outPath);
+      }
+    }
+  }
+
+  // count = newly translated strings; skipped = already had translations
+  return {
+    count: needsTranslation.length,
+    skipped: skippedCount,
+    relativePath,
+    diff: dryRun ? generateDiff(source, result.source) : null,
+  };
+}
+
+/**
+ * Simple line-diff preview for dry-run mode.
+ */
+function generateDiff(original, modified) {
+  if (original === modified) return '';
+
+  const origLines = original.split('\n');
+  const modLines = modified.split('\n');
+  const diffs = [];
+
+  const maxLines = Math.max(origLines.length, modLines.length);
+  for (let i = 0; i < maxLines; i++) {
+    const orig = origLines[i] || '';
+    const mod = modLines[i] || '';
+    if (orig !== mod) {
+      diffs.push(`    ${i + 1}: - ${orig.trim()}`);
+      diffs.push(`    ${i + 1}: + ${mod.trim()}`);
+    }
+  }
+
+  return diffs.slice(0, 40).join('\n') + (diffs.length > 40 ? '\n    ... (truncated)' : '');
+}