@babelize/engine 0.0.0-stage → 0.1.2

package/dist/local/translate-core.js

@@ -0,0 +1,499 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalTranslateError = exports.BETA_LOCAL_FRAMEWORKS = exports.SUPPORTED_LOCAL_FRAMEWORKS = exports.LOCAL_LOCKFILE = exports.LOCAL_PROJECT_ID = void 0;
+exports.configRulesStore = configRulesStore;
+exports.parseLocales = parseLocales;
+exports.validateLocales = validateLocales;
+exports.sentence = sentence;
+exports.isEngineLogNoise = isEngineLogNoise;
+exports.buildLocaleReports = buildLocaleReports;
+exports.runLocalTranslate = runLocalTranslate;
+const node_child_process_1 = require("node:child_process");
+const promises_1 = require("node:fs/promises");
+const path = __importStar(require("node:path"));
+const node_util_1 = require("node:util");
+const language_codes_1 = require("../modules/translator/language-codes");
+const locale_names_1 = require("../django/locale-names");
+const lockfile_1 = require("../modules/lockfile");
+const orchestrator_1 = require("../orchestrator");
+const logger_1 = require("../utils/logger");
+const workspace_1 = require("../modules/workspace");
+const check_project_1 = require("../qa/check-project");
+/** A rules store serving a `.babelize/config.json` glossary (no brand voice locally). */
+function configRulesStore(glossary) {
+    const rules = [
+        ...(glossary.neverTranslate ?? []).map((term) => ({ term, type: 'never_translate', translations: null })),
+        ...(glossary.alwaysTranslateAs ?? []).map((e) => ({ term: e.term, type: 'always_translate_as', translations: e.translations })),
+    ];
+    return {
+        getGlossary: async () => rules,
+        getBrandVoice: async () => null,
+    };
+}
+const types_1 = require("@babelize/types");
+const git_1 = require("./git");
+const formatter_1 = require("./formatter");
+const report_1 = require("./report");
+const workspace_copy_1 = require("./workspace-copy");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+/** Lockfile scope for local runs: `.babelize/local/babelize-lock.json` in the project root. */
+exports.LOCAL_PROJECT_ID = 'local';
+exports.LOCAL_LOCKFILE = `.babelize/${exports.LOCAL_PROJECT_ID}/babelize-lock.json`;
+exports.SUPPORTED_LOCAL_FRAMEWORKS = ['react', 'nextjs', 'django'];
+exports.BETA_LOCAL_FRAMEWORKS = ['vue', 'static'];
+class LocalTranslateError extends Error {
+    constructor(message, code, 
+    /** Files left changed in the project (only for a failed, un-rolled-back apply). */
+    changedFiles = []) {
+        super(message);
+        this.code = code;
+        this.changedFiles = changedFiles;
+        this.name = 'LocalTranslateError';
+    }
+}
+exports.LocalTranslateError = LocalTranslateError;
+/** Normalise `--to fr,de , ja` into a deduped list without the source locale. */
+function parseLocales(raw, sourceLocale) {
+    const parts = (Array.isArray(raw) ? raw : (raw ?? '').split(','))
+        .flatMap((p) => p.split(','))
+        .map((p) => p.trim())
+        .filter(Boolean);
+    return [...new Set(parts)].filter((l) => l !== sourceLocale);
+}
+function validateLocales(sourceLocale, targetLocales) {
+    const bad = [sourceLocale, ...targetLocales].filter((l) => !(0, language_codes_1.isSupported)(l));
+    if (bad.length > 0) {
+        throw new LocalTranslateError(`Unsupported locale code${bad.length > 1 ? 's' : ''}: ${bad.join(', ')}. Use ISO codes like fr, de, ja, pt-BR, zh-CN.`, 'invalid_locale');
+    }
+    if (targetLocales.length === 0) {
+        throw new LocalTranslateError('No target locales given. Pass --to, e.g. --to fr,de.', 'invalid_locale');
+    }
+}
+/** Tracked + untracked-but-not-ignored files under `dir`, relative to it. */
+async function listProjectFiles(dir) {
+    const { stdout } = await execFileAsync('git', ['ls-files', '-z', '--cached', '--others', '--exclude-standard', '--', '.'], { cwd: dir, maxBuffer: 256 * 1024 * 1024 });
+    return stdout.split('\0').filter(Boolean);
+}
+/** Locales this project was already translated into: locale files plus lockfile entries. */
+async function existingTargetLocales(workspaceDir, publicDir, localeFormat, sourceLocale) {
+    const found = new Set();
+    if (localeFormat === 'po') {
+        // Django: <locale dir>/<pt_BR>/LC_MESSAGES/django.po
+        for (const entry of await (0, promises_1.readdir)(path.join(workspaceDir, publicDir)).catch(() => [])) {
+            const po = path.join(workspaceDir, publicDir, entry, 'LC_MESSAGES', 'django.po');
+            if (await (0, promises_1.readFile)(po, 'utf8').then(() => true, () => false))
+                found.add((0, locale_names_1.localeFromDjangoName)(entry));
+        }
+    }
+    else {
+        const ext = localeFormat === 'arb' ? '.arb' : '.json';
+        for (const entry of await (0, promises_1.readdir)(path.join(workspaceDir, publicDir, 'locales')).catch(() => [])) {
+            if (entry.endsWith(ext))
+                found.add(entry.slice(0, -ext.length));
+        }
+    }
+    try {
+        const lock = JSON.parse(await (0, promises_1.readFile)(path.join(workspaceDir, exports.LOCAL_LOCKFILE), 'utf8'));
+        for (const entry of Object.values(lock.keys ?? {})) {
+            for (const locale of Object.keys(entry.languages ?? {}))
+                found.add(locale);
+        }
+    }
+    catch {
+        // No lockfile yet.
+    }
+    found.delete(sourceLocale);
+    return [...found].filter((l) => (0, language_codes_1.isSupported)(l)).sort();
+}
+/**
+ * Engine log lines that are wrong or redundant for a local run: the
+ * TRANSLATOR_URL check doesn't know about BYOK/injected providers, and the
+ * "run your install" hint is already a finalization note in the summary.
+ */
+/** `msg` as one sentence: trailing dots/spaces trimmed, exactly one period added. */
+function sentence(msg) {
+    const trimmed = msg.trim().replace(/[.\s]+$/, '');
+    return /[!?]$/.test(trimmed) ? trimmed : `${trimmed}.`;
+}
+const ENGINE_LOG_NOISE = [
+    /TRANSLATOR_URL environment variable is not set/,
+    /TRANSLATOR_URL not configured/,
+    /^New dependencies added\. Please run your package manager install/,
+    // Reported in full in the summary (failures / not-wired strings).
+    /^Some strings could not be translated/,
+    /^Extracted strings not wired into code/,
+];
+function isEngineLogNoise(message) {
+    return ENGINE_LOG_NOISE.some((re) => re.test(message));
+}
+async function readJsonIfExists(file) {
+    try {
+        return JSON.parse(await (0, promises_1.readFile)(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function flattenData(data, prefix = '', out = {}) {
+    if (data && typeof data === 'object') {
+        for (const [k, v] of Object.entries(data)) {
+            const key = prefix ? `${prefix}.${k}` : k;
+            if (v && typeof v === 'object')
+                flattenData(v, key, out);
+            else if (typeof v === 'string')
+                out[key] = v;
+        }
+    }
+    return out;
+}
+function sortKeysDeep(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return value;
+    return Object.fromEntries(Object.keys(value)
+        .sort()
+        .map((k) => [k, sortKeysDeep(value[k])]));
+}
+function frameworkStatusOf(framework) {
+    if (exports.SUPPORTED_LOCAL_FRAMEWORKS.includes(framework))
+        return 'supported';
+    if (exports.BETA_LOCAL_FRAMEWORKS.includes(framework))
+        return 'beta';
+    return null;
+}
+function stripMeta(flat) {
+    const out = {};
+    for (const [k, v] of Object.entries(flat ?? {})) {
+        if (k === '_meta' || k.startsWith('_meta.'))
+            continue;
+        out[k] = v;
+    }
+    return out;
+}
+/** Text that is only digits, symbols or whitespace is legitimately identical in every locale. */
+function hasLetters(text) {
+    return /\p{L}/u.test(text);
+}
+function buildLocaleReports(targetLocales, source, targets, failures = [], metadata = {}) {
+    const src = stripMeta(source);
+    const keys = Object.keys(src);
+    return targetLocales.map((locale) => {
+        const target = stripMeta(targets[locale]);
+        const missing = [];
+        const sameAsSource = [];
+        let translated = 0;
+        for (const key of keys) {
+            const value = target[key];
+            if (value === undefined || value === '') {
+                missing.push(key);
+                continue;
+            }
+            translated++;
+            if (value === src[key] && hasLetters(src[key]))
+                sameAsSource.push(key);
+        }
+        const failed = failures
+            .filter((f) => f.locale === locale)
+            .map((f) => ({ key: f.key, reason: f.reason, message: f.message, retryable: f.retryable }));
+        const qa = [];
+        for (const [key, meta] of Object.entries(metadata[locale] ?? {})) {
+            const warnings = meta?.qa;
+            if (Array.isArray(warnings) && warnings.length > 0)
+                qa.push({ key, warnings: warnings.map(String) });
+        }
+        return { locale, total: keys.length, translated, missing, failed, qa, sameAsSource };
+    });
+}
+function describeEngineFailure(error, byok) {
+    if (byok && /translator service (is )?(unavailable|not responding)/i.test(error)) {
+        const name = types_1.PROVIDER_DEFINITIONS[byok.provider].name;
+        return new LocalTranslateError(`Could not reach ${name} with your API key (invalid key, no access, or network error). Nothing was changed.`, 'translator_unreachable');
+    }
+    return new LocalTranslateError(`Translation failed: ${sentence(error)} Nothing was changed.`, 'engine_failed');
+}
+function hostedFailure(err) {
+    return new LocalTranslateError(`${sentence(err.message)} Nothing was changed.`, err.code === 'hosted_credits' ? 'hosted_credits' : 'hosted_auth');
+}
+/**
+ * Run the Babelize engine on a temp copy of `projectDir` and, unless
+ * `dryRun`, apply the result back to the working tree. The project is never
+ * touched until the engine has finished successfully and every target locale
+ * has translations.
+ */
+async function runLocalTranslate(opts, deps = {}) {
+    // Engine logs go to this run only (not the process-wide logger), so
+    // concurrent runs in one process (the MCP server) keep separate logs.
+    const engineLog = [];
+    const state = { collecting: false };
+    const log = (level) => (message) => {
+        if (state.collecting && !isEngineLogNoise(message))
+            engineLog.push({ level, message });
+    };
+    const logger = { debug: () => { }, info: () => { }, warn: log('warn'), error: log('error') };
+    return (0, logger_1.runWithEngineLogger)(logger, () => runScoped(opts, deps, engineLog, state));
+}
+async function runScoped(opts, deps, engineLog, state) {
+    const startedAt = Date.now();
+    const projectDir = path.resolve(opts.projectDir);
+    try {
+        await (0, git_1.assertGitRepo)(projectDir);
+        // A dry run writes nothing, so it is safe on a dirty tree.
+        if (!opts.dryRun)
+            await (0, git_1.assertCleanTree)(projectDir, opts.force);
+    }
+    catch (err) {
+        if (err instanceof git_1.GitError)
+            throw new LocalTranslateError(err.message, err.code);
+        throw err;
+    }
+    validateLocales(opts.sourceLocale, opts.targetLocales);
+    const translator = deps.hosted ?? deps.translator;
+    if (!opts.byok && !translator) {
+        throw new LocalTranslateError('No translation provider configured.', 'no_translator');
+    }
+    const files = await listProjectFiles(projectDir);
+    const temp = await (0, workspace_copy_1.createTempCopy)(projectDir, { files, tmpRoot: deps.tmpRoot });
+    try {
+        // Framework detection runs on the copy (it creates .babelize/ as a side effect).
+        let framework;
+        let publicDir = 'public';
+        let localeFormat = 'json';
+        try {
+            const { workspace } = await (0, workspace_1.validateWorkspace)({
+                workspacePath: temp.dir,
+                inputType: 'zip',
+                sourceLocale: opts.sourceLocale,
+                targetLocales: opts.targetLocales,
+                confidenceThreshold: 80,
+                dryRun: true,
+            });
+            framework = workspace.framework;
+            publicDir = workspace.publicDir;
+            localeFormat = workspace.localeFormat;
+        }
+        catch (err) {
+            throw new LocalTranslateError(err.message, 'unsupported_framework');
+        }
+        const frameworkStatus = frameworkStatusOf(framework);
+        if (!frameworkStatus) {
+            throw new LocalTranslateError(`Detected framework "${framework}", which \`babelize translate\` does not support. Supported: React, Next.js and Django (Vue and static HTML in beta).`, 'unsupported_framework');
+        }
+        deps.onFramework?.(framework, frameworkStatus);
+        // The engine deletes locale files that aren't in its target list, so
+        // `--to ja` after `--to fr,de` would silently drop fr and de. Unless the
+        // user asked to replace the set, earlier locales stay in it; their
+        // translations come from the lockfile, so only new strings cost tokens.
+        const earlier = await existingTargetLocales(temp.dir, publicDir, localeFormat, opts.sourceLocale);
+        const keptLocales = opts.replace ? [] : earlier.filter((l) => !opts.targetLocales.includes(l));
+        const droppedLocales = opts.replace ? earlier.filter((l) => !opts.targetLocales.includes(l)) : [];
+        const targetLocales = [...opts.targetLocales, ...keptLocales];
+        const before = await (0, workspace_copy_1.snapshot)(temp.dir);
+        state.collecting = true;
+        // The project's glossary from .babelize/config.json — the same file and
+        // schema `babelize check` reads — applied like a cloud project's.
+        const { glossary } = await (0, check_project_1.readProjectLocaleConfig)(projectDir);
+        const rules = glossary ? configRulesStore(glossary) : undefined;
+        const runEngine = deps.runEngine ?? orchestrator_1.runEngineV2;
+        const result = await runEngine({
+            workspacePath: temp.dir,
+            inputType: 'zip',
+            framework: framework,
+            sourceLocale: opts.sourceLocale,
+            targetLocales: [...targetLocales],
+            confidenceThreshold: 80,
+            dryRun: false,
+            projectId: exports.LOCAL_PROJECT_ID,
+            // The lockfile lives at <dataDir>/.babelize/local/. Pointing it at the
+            // copy means the project's committed lockfile is read (it was copied)
+            // and the updated one comes back with the other changes — only on success.
+            dataDir: temp.dir,
+            byok: translator ? undefined : opts.byok,
+            providers: translator || rules ? { ...(translator ? { translator } : {}), ...(rules ? { rules } : {}) } : undefined,
+            installDependencies: false,
+            onProgress: (message, step, status) => deps.onProgress?.(message, step, status),
+        });
+        const hostedFatal = deps.hosted?.fatalError;
+        if (!result.success) {
+            if (hostedFatal)
+                throw hostedFailure(hostedFatal);
+            throw describeEngineFailure(result.error ?? 'unknown engine error', translator ? undefined : opts.byok);
+        }
+        // --replace: forget dropped locales in the lockfile too, or a later run
+        // would rebuild their files from it.
+        for (const locale of droppedLocales)
+            await (0, lockfile_1.removeLocaleFromLockfile)(exports.LOCAL_PROJECT_ID, locale, temp.dir);
+        const source = stripMeta(result.results?.source);
+        const targets = result.results?.targets ?? {};
+        const translationFailures = result.translationFailures ?? [];
+        const metadata = (result.results?.metadata ?? {});
+        const locales = buildLocaleReports(targetLocales, source, targets, translationFailures, metadata);
+        // A locale with source keys but zero translations (nothing, or only copies
+        // of the source text) is a failed run, not a partial one: refuse to write
+        // it rather than ship an untranslated language as if it were done.
+        const empty = locales.filter((l) => l.total > 0 && l.translated - l.sameAsSource.length === 0);
+        if (empty.length > 0) {
+            if (hostedFatal)
+                throw hostedFailure(hostedFatal);
+            throw new LocalTranslateError(`No translations were produced for ${empty.map((l) => l.locale).join(', ')}. Nothing was changed.`, 'incomplete_translation');
+        }
+        // The engine's result carries each target locale's complete data (fresh
+        // translations merged with lockfile-cached ones); its on-disk files can
+        // hold only this run's new keys. Write the complete data, exactly as the
+        // cloud backend stages locale files for a PR.
+        const lost = [];
+        for (const locale of result.locales) {
+            if (locale.locale === opts.sourceLocale || locale.noFile)
+                continue;
+            const rel = locale.path.split(path.sep).join('/');
+            if (locale.content !== undefined) {
+                // A merged catalogue (Django .po): written exactly as the engine
+                // produced it. The merge never drops existing translations.
+                for (const f of [{ path: rel, content: locale.content, encoding: 'utf8' }, ...(locale.extraFiles ?? [])]) {
+                    const abs = path.resolve(temp.dir, f.path.split(path.sep).join('/'));
+                    if (path.relative(temp.dir, abs).startsWith('..'))
+                        continue;
+                    await (0, promises_1.mkdir)(path.dirname(abs), { recursive: true });
+                    await (0, promises_1.writeFile)(abs, f.encoding === 'base64' ? Buffer.from(f.content, 'base64') : f.content);
+                }
+                continue;
+            }
+            const previous = await readJsonIfExists(path.join(projectDir, rel));
+            const next = flattenData(locale.data);
+            const failedHere = new Set(translationFailures.filter((f) => f.locale === locale.locale).map((f) => f.key));
+            for (const [key, value] of Object.entries(flattenData(previous ?? {}))) {
+                // A key whose re-translation failed is reported as a failure instead.
+                if (key.startsWith('_meta') || !value || failedHere.has(key))
+                    continue;
+                if (!next[key])
+                    lost.push(`${locale.locale}: ${key}`);
+            }
+            const abs = path.resolve(temp.dir, rel);
+            if (path.relative(temp.dir, abs).startsWith('..'))
+                continue;
+            await (0, promises_1.mkdir)(path.dirname(abs), { recursive: true });
+            await (0, promises_1.writeFile)(abs, `${JSON.stringify(sortKeysDeep(locale.data), null, 2)}\n`);
+        }
+        // The QA report (.babelize/local/report.json) stays out of git; the
+        // lockfile next to it is committed. Shipped with the run's other changes.
+        await (0, report_1.ensureReportGitignored)(temp.dir);
+        // Never ship a run that would delete translations the project already has.
+        if (lost.length > 0) {
+            throw new LocalTranslateError(`This run would remove ${lost.length} existing translation(s) (${lost.slice(0, 5).join(', ')}${lost.length > 5 ? ', …' : ''}). Nothing was changed.`, 'incomplete_translation');
+        }
+        let changes = (0, workspace_copy_1.diffSnapshots)(before, await (0, workspace_copy_1.snapshot)(temp.dir));
+        const formatter = (await (0, formatter_1.formatChangedFiles)(projectDir, temp.dir, [...changes.added, ...changes.modified])) ?? undefined;
+        if (formatter?.ok)
+            changes = (0, workspace_copy_1.diffSnapshots)(before, await (0, workspace_copy_1.snapshot)(temp.dir));
+        const diff = opts.dryRun ? await (0, workspace_copy_1.renderUnifiedDiff)(changes, projectDir, temp.dir) : undefined;
+        // Before apply: the project still holds the old content.
+        const diffStat = await (0, workspace_copy_1.diffStats)(changes, projectDir, temp.dir);
+        if (!opts.dryRun && (0, workspace_copy_1.changeCount)(changes) > 0) {
+            const conflicts = await (0, workspace_copy_1.findConflicts)(changes, before, projectDir);
+            if (conflicts.length > 0) {
+                throw new LocalTranslateError(`These files changed in your project while translate was running (or exist but weren't part of the copy), so nothing was applied:\n` +
+                    conflicts.map((f) => `  ${f}`).join('\n') +
+                    '\nCommit or discard those edits, then run translate again.', 'project_changed');
+            }
+            try {
+                await (0, workspace_copy_1.applyChanges)(changes, temp.dir, projectDir, deps.applyIo);
+            }
+            catch (err) {
+                if (!(err instanceof workspace_copy_1.ApplyError))
+                    throw err;
+                if (err.rolledBack) {
+                    throw new LocalTranslateError(`${sentence(err.message)} Nothing was changed.`, 'apply_failed');
+                }
+                throw new LocalTranslateError(`${err.message} These files are still changed:\n` +
+                    err.changedFiles.map((f) => `  ${f}`).join('\n') +
+                    `\nRestore them with: git checkout -- ${err.changedFiles.join(' ')} (and delete any of them that are new).`, 'apply_failed', err.changedFiles);
+            }
+        }
+        // Partial run cut short by the key or the balance: keep what was
+        // translated (it was paid for) and say why the rest is missing.
+        if (hostedFatal)
+            engineLog.unshift({ level: 'error', message: hostedFatal.message });
+        const s = result.stats;
+        const provider = deps.hosted
+            ? { provider: 'babelize', name: 'Babelize hosted', model: deps.hosted.model }
+            : !translator && opts.byok
+                ? {
+                    provider: opts.byok.provider,
+                    name: types_1.PROVIDER_DEFINITIONS[opts.byok.provider].name,
+                    model: opts.byok.model ?? types_1.PROVIDER_DEFINITIONS[opts.byok.provider].defaultModel,
+                }
+                : deps.translatorInfo;
+        return {
+            framework,
+            frameworkStatus,
+            provider,
+            sourceLocale: opts.sourceLocale,
+            targetLocales,
+            keptLocales,
+            droppedLocales,
+            unusedKeys: result.keyUsage?.unused ?? [],
+            notInjected: result.notInjected ?? [],
+            dynamicKeyFiles: result.keyUsage?.dynamicFiles ?? [],
+            dryRun: opts.dryRun,
+            applied: !opts.dryRun && (0, workspace_copy_1.changeCount)(changes) > 0,
+            changes,
+            diff,
+            diffStat,
+            stats: {
+                filesScanned: s.filesScanned,
+                stringsExtracted: s.stringsExtracted,
+                keysExtracted: s.keysGenerated,
+                injectionsApplied: s.injectionsApplied,
+                keysFromLockfile: s.translationsFromLockfile ?? 0,
+                keysSentToTranslator: s.lockfileKeysTranslated ?? 0,
+                translatedThisRun: s.translatedThisRun,
+            },
+            locales,
+            translationFailures,
+            warnings: result.warnings.map((w) => ({ type: w.type, file: w.file, line: w.line, message: w.message })),
+            notes: result.notes ?? [],
+            formatter,
+            engineLog,
+            lockfile: exports.LOCAL_LOCKFILE,
+            lockfileIgnored: await (0, git_1.isGitIgnored)(projectDir, exports.LOCAL_LOCKFILE),
+            metadata,
+            results: { source, targets: Object.fromEntries(Object.entries(targets).map(([l, t]) => [l, stripMeta(t)])) },
+            startedAt,
+            durationMs: Date.now() - startedAt,
+        };
+    }
+    finally {
+        await temp.cleanup();
+    }
+}

package/dist/local/translate-messages.d.ts

@@ -0,0 +1,49 @@
+import type { ByokProvider } from '@babelize/types';
+import type { TranslationFailure, TranslationProvider } from '../providers/types';
+/**
+ * Translate a flat key → text map with the engine's translate phase, without
+ * a project: the same placeholder protection, ICU/plural handling, glossary,
+ * validation and repair pass as `babelize translate`, but no extraction or
+ * injection and nothing written anywhere. Used by the golden-set quality run.
+ */
+export interface TranslateMessagesOptions {
+    sourceLocale: string;
+    targetLocales: string[];
+    /** Flat key → source text. Keys must not contain dots. */
+    messages: Record<string, string>;
+    /** The user's LLM key. Required unless `translator` is given. */
+    byok?: {
+        provider: ByokProvider;
+        apiKey: string;
+        model?: string;
+    };
+    translator?: TranslationProvider;
+    glossary?: {
+        neverTranslate?: string[];
+        alwaysTranslateAs?: Array<{
+            term: string;
+            translations: Record<string, string>;
+        }>;
+    };
+    /**
+     * The app's runtime formats ICU (next-intl, i18next-icu): count
+     * placeholders may become plurals. Default true.
+     */
+    targetPlurals?: boolean;
+    onProgress?: (message: string) => void;
+    /** Engine warnings/errors (silent by default). */
+    onLog?: (level: 'warn' | 'error', message: string) => void;
+}
+export interface TranslateMessagesResult {
+    /** locale → key → translation (keys that failed are absent). */
+    targets: Record<string, Record<string, string>>;
+    /** locale → key → engine metadata (`qa` warnings, confidence, …). */
+    metadata: Record<string, Record<string, unknown>>;
+    failures: TranslationFailure[];
+    /** Locales that failed as a whole. */
+    errors: Array<{
+        locale: string;
+        error: string;
+    }>;
+}
+export declare function translateMessages(opts: TranslateMessagesOptions): Promise<TranslateMessagesResult>;

package/dist/local/translate-messages.js

@@ -0,0 +1,89 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateMessages = translateMessages;
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const path = __importStar(require("node:path"));
+const keygen_1 = require("../modules/keygen");
+const translate_1 = require("../modules/translator/translate");
+const glossary_1 = require("../modules/glossary");
+const logger_1 = require("../utils/logger");
+async function translateMessages(opts) {
+    const logger = {
+        debug: () => { },
+        info: () => { },
+        warn: (message) => opts.onLog?.('warn', message),
+        error: (message) => opts.onLog?.('error', message),
+    };
+    return (0, logger_1.runWithEngineLogger)(logger, () => run(opts));
+}
+async function run(opts) {
+    if (!opts.byok && !opts.translator)
+        throw new Error('translateMessages needs a byok key or a translator.');
+    const dir = await (0, promises_1.mkdtemp)(path.join((0, node_os_1.tmpdir)(), 'babelize-messages-'));
+    try {
+        // The glossary goes in as already-loaded rules, normalized like a project's.
+        const glossary = (0, glossary_1.normalizeGlossary)([
+            ...(opts.glossary?.neverTranslate ?? []).map((term) => ({ term, type: 'never_translate' })),
+            ...(opts.glossary?.alwaysTranslateAs ?? []).map((e) => ({ term: e.term, type: 'always_translate_as', translations: e.translations })),
+        ]);
+        const workspace = {
+            path: dir,
+            framework: 'react',
+            sourceDirs: [],
+            hasLocalesDir: false,
+            existingLocales: [],
+            publicDir: 'public',
+            localeFormat: 'json',
+        };
+        const result = await (0, translate_1.translateLocales)(workspace, { locale: opts.sourceLocale, path: '', data: { ...opts.messages }, isNew: false }, opts.targetLocales, false, true, // dry run: nothing written
+        undefined, opts.onProgress, undefined, undefined, opts.translator ? undefined : opts.byok, undefined, undefined, opts.translator ? { translator: opts.translator } : {}, { targetPlurals: opts.targetPlurals ?? true, rules: { glossary, brandVoice: null, complete: true } });
+        const targets = {};
+        for (const file of result.translation.locales) {
+            const flat = (0, keygen_1.flattenLocaleData)(file.data);
+            targets[file.locale] = Object.fromEntries(Object.entries(flat).filter(([k]) => k !== '_meta' && !k.startsWith('_meta.')));
+        }
+        return {
+            targets,
+            metadata: result.metadata,
+            failures: result.translation.failures,
+            errors: result.translation.errors,
+        };
+    }
+    finally {
+        await (0, promises_1.rm)(dir, { recursive: true, force: true });
+    }
+}