bctranslate 1.0.0-beta.1

package/src/bridges/python.js

@@ -0,0 +1,189 @@
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { shieldInterpolations, unshieldInterpolations } from '../utils.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PYTHON_SCRIPT = join(__dirname, '..', '..', 'python', 'translator.py');
+
+let cachedPythonCmd = null;
+
+async function findPython() {
+  if (cachedPythonCmd) return cachedPythonCmd;
+  for (const cmd of ['python3', 'python']) {
+    try {
+      const out = await execSimple(cmd, ['--version']);
+      if (out.includes('Python 3')) {
+        cachedPythonCmd = cmd;
+        return cmd;
+      }
+    } catch { /* try next */ }
+  }
+  throw new Error(
+    'Python 3 not found. Install Python 3.8+ and add it to your PATH.\n' +
+    '  Then run: 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);
+  });
+}
+
+/**
+ * Install argostranslate via pip.
+ * Called from `init` and from checkPythonBridge when the package is missing.
+ */
+export async function installArgostranslate() {
+  const py = await findPython();
+  return execSimple(py, ['-m', 'pip', 'install', '--quiet', 'argostranslate']);
+}
+
+/**
+ * Check Python + argostranslate availability and download the language pair
+ * model if not already installed.
+ */
+export async function checkPythonBridge(from, to) {
+  const py = await findPython();
+
+  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 = next((l for l in installed if l.code == from_code), None)
+to_lang   = next((l for l in installed if l.code == to_code),   None)
+
+if from_lang and to_lang and from_lang.get_translation(to_lang):
+    print(json.dumps({"status": "ready"}))
+else:
+    try:
+        argostranslate.package.update_package_index()
+        available = argostranslate.package.get_available_packages()
+        pkg = next((p for p in available 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:
+            available_codes = [l.code for l in installed]
+            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)}"}))
+`;
+
+  const result = await execSimple(py, ['-c', checkScript]);
+
+  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.
+ *
+ * Interpolation variables like {{ name }}, {count}, ${val} are shielded
+ * before sending and restored after — Argos never sees them.
+ *
+ * @param {Array<{key: string, text: string}>} batch
+ * @param {string} from  Source language code
+ * @param {string} to    Target language code
+ * @returns {Promise<Record<string, string>>}  key → translated text
+ */
+export async function translateBatch(batch, from, to) {
+  if (batch.length === 0) return {};
+
+  const py = await findPython();
+
+  // ── Shield interpolations so Argos never mangles {name} / {{ expr }} ────────
+  const shielded = batch.map((item) => {
+    const { shielded: text, tokens } = shieldInterpolations(item.text);
+    return { key: item.key, text, tokens };
+  });
+
+  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(shielded.map(({ key, text }) => ({ key, text })));
+    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 (skip debug/warning lines)
+        const lines = stdout.split('\n');
+        let raw = null;
+        for (let i = lines.length - 1; i >= 0; i--) {
+          const line = lines[i].trim();
+          if (line.startsWith('[') || line.startsWith('{')) {
+            try { raw = JSON.parse(line); break; } catch { /* try previous */ }
+          }
+        }
+
+        if (!raw) {
+          return reject(new Error(`No valid JSON in Python output: ${stdout.slice(0, 500)}`));
+        }
+
+        // Convert array → map, then unshield interpolations
+        const rawMap = {};
+        if (Array.isArray(raw)) {
+          for (const item of raw) rawMap[item.key] = item.text;
+        } else {
+          Object.assign(rawMap, raw);
+        }
+
+        const result = {};
+        for (const { key, tokens } of shielded) {
+          const translated = rawMap[key] ?? batch.find((b) => b.key === key)?.text ?? '';
+          result[key] = unshieldInterpolations(translated, tokens);
+        }
+
+        resolve(result);
+      } 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,105 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } 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, 'src', 'i18n'),
+    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');
+}
+
+/**
+ * Flatten a nested JSON object to dot-notation keys.
+ * { home: { notes: 'Notes' } } → { 'home.notes': 'Notes' }
+ */
+function flattenKeys(obj, prefix = '') {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+      Object.assign(result, flattenKeys(value, fullKey));
+    } else {
+      result[fullKey] = value;
+    }
+  }
+  return result;
+}
+
+/**
+ * Unflatten dot-notation keys to a nested JSON object.
+ * { 'home.notes': 'Notes' } → { home: { notes: 'Notes' } }
+ */
+function unflattenKeys(flat) {
+  const result = {};
+  for (const [dotKey, value] of Object.entries(flat)) {
+    const parts = dotKey.split('.');
+    let obj = result;
+    for (let i = 0; i < parts.length - 1; i++) {
+      if (typeof obj[parts[i]] !== 'object' || obj[parts[i]] === null) {
+        obj[parts[i]] = {};
+      }
+      obj = obj[parts[i]];
+    }
+    obj[parts[parts.length - 1]] = value;
+  }
+  return result;
+}
+
+/**
+ * Load an existing locale file and return flat dot-notation keys.
+ * Handles both nested JSON (vue-i18n standard) and legacy flat format.
+ */
+export function loadLocale(localeDir, langCode) {
+  const filePath = join(localeDir, `${langCode}.json`);
+  if (existsSync(filePath)) {
+    try {
+      const raw = JSON.parse(readFileSync(filePath, 'utf-8'));
+      // Flatten nested objects to dot-notation for internal use
+      return flattenKeys(raw);
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+
+/**
+ * Save a locale file, merging with existing keys.
+ * Writes nested JSON (standard for vue-i18n and react-i18next).
+ */
+export function saveLocale(localeDir, langCode, newEntries) {
+  mkdirSync(localeDir, { recursive: true });
+
+  const filePath = join(localeDir, `${langCode}.json`);
+  const existing = loadLocale(localeDir, langCode); // already flat
+
+  // Merge: don't overwrite existing translations
+  const merged = { ...existing };
+  for (const [key, value] of Object.entries(newEntries)) {
+    if (!(key in merged)) {
+      merged[key] = value;
+    }
+  }
+
+  // Write as nested JSON for i18n library compatibility
+  const nested = unflattenKeys(merged);
+  writeFileSync(filePath, JSON.stringify(nested, null, 2) + '\n', 'utf-8');
+  return filePath;
+}