@babelize/engine 0.0.0-stage → 0.1.2

package/dist/utils/translator-caller.js

@@ -0,0 +1,217 @@
+"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.callTranslator = callTranslator;
+exports.checkTranslatorHealth = checkTranslatorHealth;
+exports.warmupTranslator = warmupTranslator;
+const logger_1 = require("./logger");
+const translation_quality_1 = require("./translation-quality");
+const byok_provider_1 = require("../modules/translator/client/byok.provider");
+/**
+ * Translate a batch. Returns translations only for entries the translator
+ * actually produced — never the source text in their place. Entries missing
+ * from the result are reported as failed keys by the caller.
+ */
+async function callTranslator(entries, sourceLang, targetLang, byokConfig, brandVoice, llmOptions = {}) {
+    if (byokConfig) {
+        return callByokTranslator(entries, sourceLang, targetLang, byokConfig, brandVoice, llmOptions);
+    }
+    const outerSignal = llmOptions.signal;
+    const { translatorLoadBalancer } = await Promise.resolve().then(() => __importStar(require('./translator-load-balancer')));
+    let rustResult = null;
+    try {
+        rustResult = await translatorLoadBalancer.executeWithFailover(async (translatorUrl) => {
+            const response = await fetch(`${translatorUrl}/translate`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ sourceLang, targetLang, entries }),
+                signal: outerSignal ? AbortSignal.any([AbortSignal.timeout(300000), outerSignal]) : AbortSignal.timeout(300000),
+            });
+            if (!response.ok) {
+                throw new Error(`Translation API error: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            if (data.metadata) {
+                logger_1.engineLogger.info('Translation metadata', {
+                    dictVersion: data.metadata.dictVersion,
+                    processingTimeMs: data.metadata.processingTimeMs,
+                    dictionaryHits: data.metadata.dictionaryHits,
+                    modelTranslations: data.metadata.modelTranslations,
+                });
+            }
+            return { translations: data.translations || [], metadata: data.metadata };
+        });
+    }
+    catch (err) {
+        logger_1.engineLogger.warn('Rust translator unavailable, will try HF Inference API fallback', {
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+    const needsFallback = rustResult === null || (rustResult.translations.length > 0 &&
+        rustResult.translations.every((t) => {
+            const orig = entries.find((e) => e.key === t.key)?.value || '';
+            if (orig.length <= 4)
+                return false;
+            const val = t.value || '';
+            if (orig.toLowerCase() === val.toLowerCase())
+                return true;
+            return /^\s*(?:[a-z]{3}_[A-Za-z]{4})\s+/.test(val);
+        }));
+    if (needsFallback) {
+        logger_1.engineLogger.warn('Rust translator returned untargeted translations or unavailable, falling back to HF Inference API');
+        try {
+            const hfResults = await callHuggingFaceNLLB(entries, sourceLang, targetLang);
+            if (hfResults.translations.length > 0) {
+                return { translations: hfResults.translations, metadata: { ...rustResult?.metadata, fallback: 'hf-inference-api' } };
+            }
+        }
+        catch (hfErr) {
+            logger_1.engineLogger.error('HF Inference API fallback also failed', { error: hfErr });
+        }
+    }
+    if (rustResult !== null && rustResult.translations.length > 0) {
+        return rustResult;
+    }
+    // Never pass the source text off as a translation: an empty result makes
+    // every key a reported failure, and the next run retries them.
+    logger_1.engineLogger.error(`Translator unavailable for ${sourceLang} → ${targetLang}; no translations produced`);
+    return { translations: [], metadata: { translatorUnavailable: true } };
+}
+async function callByokTranslator(entries, sourceLang, targetLang, byokConfig, brandVoice, llmOptions = {}) {
+    const client = new byok_provider_1.BYOKTranslatorClient(byokConfig);
+    const { signal, ...promptOptions } = llmOptions;
+    const hfRequest = {
+        entries: entries.map((e) => ({ key: e.key, value: e.value, context: e.parentContext, extractionContext: e.extractionContext })),
+        sourceLang,
+        targetLang,
+        brandVoice,
+        ...promptOptions,
+    };
+    const result = await client.translate(hfRequest, signal);
+    const byKey = new Map(result.translations.map((t) => [t.key, t]));
+    const translations = [];
+    for (const entry of entries) {
+        const t = byKey.get(entry.key);
+        if (!t)
+            continue;
+        const quality = (0, translation_quality_1.validateTranslationQuality)(entry.value, t.value);
+        translations.push({
+            key: entry.key,
+            value: t.value,
+            confidence: quality.isValid ? Math.max(0.5, quality.score / 100) : 0.3,
+            engine: byokConfig.provider,
+            warnings: quality.issues?.map((i) => `${i.type}:${i.severity}`) || [],
+        });
+    }
+    return { translations, metadata: result.metadata };
+}
+async function callHuggingFaceNLLB(entries, sourceLang, targetLang) {
+    const hfToken = process.env.HF_TOKEN || process.env.HF_API_TOKEN;
+    const model = 'facebook/nllb-200-distilled-600M';
+    const baseUrl = `https://api-inference.huggingface.co/models/${model}`;
+    const translations = [];
+    for (const entry of entries) {
+        const response = await fetch(baseUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...(hfToken ? { Authorization: `Bearer ${hfToken}` } : {}),
+            },
+            body: JSON.stringify({
+                inputs: entry.value,
+                parameters: { src_lang: sourceLang, tgt_lang: targetLang },
+            }),
+            signal: AbortSignal.timeout(60000),
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => '');
+            throw new Error(`HF Inference API error: ${response.status} — ${body.slice(0, 200)}`);
+        }
+        const data = await response.json();
+        const translatedText = data?.[0]?.translation_text;
+        if (!translatedText)
+            continue;
+        translations.push({
+            key: entry.key,
+            value: translatedText,
+            confidence: 0.9,
+            engine: 'hf-nllb-200',
+        });
+    }
+    return { translations };
+}
+async function checkTranslatorHealth(byokConfig) {
+    try {
+        if (byokConfig) {
+            const client = new byok_provider_1.BYOKTranslatorClient(byokConfig);
+            return await client.health();
+        }
+        const { DirectTranslatorClient } = await Promise.resolve().then(() => __importStar(require('../modules/translator/client/direct-translator.client')));
+        const client = new DirectTranslatorClient();
+        return await client.health();
+    }
+    catch {
+        return false;
+    }
+}
+async function warmupTranslator() {
+    logger_1.engineLogger.info('[Translator] Starting warmup...');
+    const MAX_ATTEMPTS = 3;
+    const RETRY_DELAY_MS = 15000;
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+        try {
+            logger_1.engineLogger.info(`[Translator] Warmup attempt ${attempt}/${MAX_ATTEMPTS}...`);
+            const { DirectTranslatorClient } = await Promise.resolve().then(() => __importStar(require('../modules/translator/client/direct-translator.client')));
+            const client = new DirectTranslatorClient();
+            const ok = await client.warmup();
+            if (ok) {
+                logger_1.engineLogger.info('[Translator] Warmup successful');
+                return true;
+            }
+            logger_1.engineLogger.warn(`[Translator] Warmup attempt ${attempt} failed`);
+        }
+        catch (err) {
+            logger_1.engineLogger.warn(`[Translator] Warmup attempt ${attempt} failed:`, {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        if (attempt < MAX_ATTEMPTS) {
+            logger_1.engineLogger.info(`[Translator] Retrying warmup in ${RETRY_DELAY_MS / 1000}s...`);
+            await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
+        }
+    }
+    logger_1.engineLogger.warn('[Translator] All warmup attempts failed — running cold');
+    return false;
+}

package/dist/utils/translator-load-balancer.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Translator Load Balancer
+ *
+ * Manages multiple translator endpoints with:
+ * - Health checking
+ * - Round-robin load balancing
+ * - Automatic failover on errors
+ * - Circuit breaker per endpoint
+ */
+export interface TranslatorEndpoint {
+    url: string;
+    name: string;
+    priority: number;
+    isHealthy: boolean;
+    lastHealthCheck: Date | null;
+    consecutiveFailures: number;
+}
+declare class TranslatorLoadBalancer {
+    private config;
+    private circuitBreakers;
+    private healthCheckInterval;
+    private currentEndpointIndex;
+    constructor();
+    /**
+     * Initialize endpoints from environment variable
+     * Format: url1|name1,url2|name2 or just url1,url2
+     */
+    private initializeEndpoints;
+    /**
+     * Get the next healthy endpoint using weighted round-robin
+     */
+    getNextEndpoint(): TranslatorEndpoint | null;
+    /**
+     * Mark an endpoint as failed
+     */
+    markEndpointFailed(endpoint: TranslatorEndpoint): void;
+    /**
+     * Mark an endpoint as successful
+     */
+    markEndpointSuccess(endpoint: TranslatorEndpoint): void;
+    /**
+     * Execute a translation request with automatic failover and exponential backoff
+     */
+    executeWithFailover<T>(requestFn: (url: string) => Promise<T>): Promise<T>;
+    /**
+     * Sleep utility
+     */
+    private sleep;
+    /**
+     * Perform health check on all endpoints
+     */
+    healthCheck(): Promise<Record<string, boolean>>;
+    /**
+     * Start periodic health checks
+     */
+    startHealthChecks(): void;
+    /**
+     * Stop periodic health checks
+     */
+    stopHealthChecks(): void;
+    /**
+     * Get current status of all endpoints
+     */
+    getStatus(): Array<{
+        name: string;
+        url: string;
+        isHealthy: boolean;
+        failures: number;
+    }>;
+}
+export declare function getTranslatorLoadBalancer(): TranslatorLoadBalancer;
+export declare const translatorLoadBalancer: TranslatorLoadBalancer;
+export {};

package/dist/utils/translator-load-balancer.js

@@ -0,0 +1,297 @@
+"use strict";
+/**
+ * Translator Load Balancer
+ *
+ * Manages multiple translator endpoints with:
+ * - Health checking
+ * - Round-robin load balancing
+ * - Automatic failover on errors
+ * - Circuit breaker per endpoint
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translatorLoadBalancer = void 0;
+exports.getTranslatorLoadBalancer = getTranslatorLoadBalancer;
+const circuit_breaker_1 = require("./circuit-breaker");
+const logger_1 = require("./logger");
+const DEFAULT_CONFIG = {
+    endpoints: [],
+    healthCheckInterval: 60000, // 1 minute
+    healthCheckTimeout: 10000, // 10 seconds
+    maxConsecutiveFailures: 3,
+};
+class TranslatorLoadBalancer {
+    constructor() {
+        this.circuitBreakers = new Map();
+        this.healthCheckInterval = null;
+        this.currentEndpointIndex = 0;
+        this.config = { ...DEFAULT_CONFIG };
+        this.initializeEndpoints();
+        if (this.config.endpoints.length > 0) {
+            setTimeout(() => this.startHealthChecks(), 0).unref?.();
+        }
+    }
+    /**
+     * Initialize endpoints from environment variable
+     * Format: url1|name1,url2|name2 or just url1,url2
+     */
+    initializeEndpoints() {
+        const translatorUrl = process.env.TRANSLATOR_URL;
+        const backupUrl = process.env.TRANSLATOR_BACKUP_URL;
+        const endpoints = [];
+        // Primary endpoint
+        if (translatorUrl) {
+            endpoints.push({
+                url: translatorUrl,
+                name: 'primary',
+                priority: 1,
+                isHealthy: true,
+                lastHealthCheck: null,
+                consecutiveFailures: 0,
+            });
+        }
+        // Backup endpoint
+        if (backupUrl) {
+            endpoints.push({
+                url: backupUrl,
+                name: 'backup',
+                priority: 2,
+                isHealthy: true,
+                lastHealthCheck: null,
+                consecutiveFailures: 0,
+            });
+        }
+        // Parse additional endpoints from TRANSLATOR_ENDPOINTS env var
+        // Format: url1|name1,url2|name2
+        const additionalEndpoints = process.env.TRANSLATOR_ENDPOINTS;
+        if (additionalEndpoints) {
+            additionalEndpoints.split(',').forEach((entry, index) => {
+                const [url, name] = entry.trim().split('|');
+                if (url) {
+                    endpoints.push({
+                        url: url.trim(),
+                        name: name?.trim() || `endpoint-${index + 3}`,
+                        priority: index + 3,
+                        isHealthy: true,
+                        lastHealthCheck: null,
+                        consecutiveFailures: 0,
+                    });
+                }
+            });
+        }
+        this.config.endpoints = endpoints;
+        // Create circuit breaker for each endpoint
+        endpoints.forEach(endpoint => {
+            this.circuitBreakers.set(endpoint.name, (0, circuit_breaker_1.getCircuitBreaker)(`translator-${endpoint.name}`, {
+                failureThreshold: 5,
+                resetTimeout: 30000,
+                halfOpenMaxCalls: 3,
+            }));
+        });
+        logger_1.engineLogger.info('Translator load balancer initialized', {
+            endpointCount: endpoints.length,
+            endpoints: endpoints.map(e => ({ name: e.name, url: e.url.substring(0, 50) })),
+        });
+    }
+    /**
+     * Get the next healthy endpoint using weighted round-robin
+     */
+    getNextEndpoint() {
+        const healthyEndpoints = this.config.endpoints
+            .filter(e => e.isHealthy)
+            .sort((a, b) => a.priority - b.priority);
+        if (healthyEndpoints.length === 0) {
+            // All endpoints unhealthy, try primary anyway
+            if (this.config.endpoints.length > 0) {
+                logger_1.engineLogger.warn('All translator endpoints unhealthy, attempting primary');
+                return this.config.endpoints[0];
+            }
+            return null;
+        }
+        // Round-robin among healthy endpoints
+        const endpoint = healthyEndpoints[this.currentEndpointIndex % healthyEndpoints.length];
+        this.currentEndpointIndex++;
+        return endpoint;
+    }
+    /**
+     * Mark an endpoint as failed
+     */
+    markEndpointFailed(endpoint) {
+        endpoint.consecutiveFailures++;
+        if (endpoint.consecutiveFailures >= this.config.maxConsecutiveFailures) {
+            endpoint.isHealthy = false;
+            logger_1.engineLogger.warn('Translator endpoint marked unhealthy', {
+                name: endpoint.name,
+                failures: endpoint.consecutiveFailures,
+            });
+        }
+    }
+    /**
+     * Mark an endpoint as successful
+     */
+    markEndpointSuccess(endpoint) {
+        if (!endpoint.isHealthy || endpoint.consecutiveFailures > 0) {
+            logger_1.engineLogger.info('Translator endpoint recovered', { name: endpoint.name });
+        }
+        endpoint.consecutiveFailures = 0;
+        endpoint.isHealthy = true;
+    }
+    /**
+     * Execute a translation request with automatic failover and exponential backoff
+     */
+    async executeWithFailover(requestFn) {
+        const maxAttempts = parseInt(process.env.TRANSLATOR_RETRY_ATTEMPTS || '2');
+        const triedEndpoints = [];
+        let lastError = null;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            const endpoint = this.getNextEndpoint();
+            if (!endpoint) {
+                // No endpoints available
+                break;
+            }
+            if (triedEndpoints.includes(endpoint.name)) {
+                // If we've already tried this endpoint, allow retry only when
+                // it's the only endpoint available (otherwise cycle to next)
+                const healthyEndpoints = this.config.endpoints.filter(e => e.isHealthy);
+                if (healthyEndpoints.length > 1) {
+                    continue; // Skip to next round-robin pick
+                }
+                // Single endpoint — retrying it is our only option
+            }
+            if (!triedEndpoints.includes(endpoint.name)) {
+                triedEndpoints.push(endpoint.name);
+            }
+            const circuitBreaker = this.circuitBreakers.get(endpoint.name);
+            try {
+                const result = await (circuitBreaker
+                    ? circuitBreaker.execute(() => requestFn(endpoint.url))
+                    : requestFn(endpoint.url));
+                this.markEndpointSuccess(endpoint);
+                return result;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                this.markEndpointFailed(endpoint);
+                logger_1.engineLogger.warn('Translator endpoint failed, trying fallback', {
+                    endpoint: endpoint.name,
+                    error: lastError.message,
+                    attempt: attempt + 1,
+                    maxAttempts,
+                });
+                // Exponential backoff with jitter before next attempt
+                // Only delay if we have more attempts remaining
+                if (attempt < maxAttempts - 1) {
+                    const baseDelay = Math.min(200 * Math.pow(2, attempt), 3000); // Max 3s
+                    const jitter = Math.random() * 200; // 0-200ms jitter
+                    const delay = baseDelay + jitter;
+                    logger_1.engineLogger.info('Waiting before retry', {
+                        delayMs: Math.round(delay),
+                        nextAttempt: attempt + 2
+                    });
+                    await this.sleep(delay);
+                }
+            }
+        }
+        const endpointsTried = triedEndpoints.length > 0
+            ? `tried endpoints: [${triedEndpoints.join(', ')}]`
+            : 'no endpoints available';
+        throw lastError
+            ? new Error(`Translator request failed after ${maxAttempts} attempts (${endpointsTried}): ${lastError.message}`)
+            : new Error(`All translator endpoints failed (${endpointsTried})`);
+    }
+    /**
+     * Sleep utility
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Perform health check on all endpoints
+     */
+    async healthCheck() {
+        const results = {};
+        for (const endpoint of this.config.endpoints) {
+            let timeout;
+            try {
+                const controller = new AbortController();
+                timeout = setTimeout(() => controller.abort(), this.config.healthCheckTimeout);
+                timeout.unref?.();
+                const response = await fetch(`${endpoint.url}/health`, {
+                    method: 'GET',
+                    signal: controller.signal,
+                });
+                const isHealthy = response.ok;
+                endpoint.isHealthy = isHealthy;
+                endpoint.lastHealthCheck = new Date();
+                if (isHealthy) {
+                    endpoint.consecutiveFailures = 0;
+                    // Reset the circuit breaker so subsequent calls don't fail immediately
+                    const cb = this.circuitBreakers.get(endpoint.name);
+                    if (cb) {
+                        cb.reset();
+                        logger_1.engineLogger.info('Circuit breaker reset after healthy health check', { endpoint: endpoint.name });
+                    }
+                }
+                results[endpoint.name] = isHealthy;
+            }
+            catch {
+                endpoint.isHealthy = false;
+                endpoint.lastHealthCheck = new Date();
+                results[endpoint.name] = false;
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+        }
+        return results;
+    }
+    /**
+     * Start periodic health checks
+     */
+    startHealthChecks() {
+        if (this.healthCheckInterval)
+            return;
+        this.healthCheckInterval = setInterval(() => this.healthCheck(), this.config.healthCheckInterval);
+        // Background monitoring must not keep the process alive: short-lived
+        // hosts (scripts, the local runner) would otherwise never exit.
+        this.healthCheckInterval.unref?.();
+        // Initial health check
+        this.healthCheck();
+    }
+    /**
+     * Stop periodic health checks
+     */
+    stopHealthChecks() {
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+            this.healthCheckInterval = null;
+        }
+    }
+    /**
+     * Get current status of all endpoints
+     */
+    getStatus() {
+        return this.config.endpoints.map(e => ({
+            name: e.name,
+            url: e.url.substring(0, 50) + (e.url.length > 50 ? '...' : ''),
+            isHealthy: e.isHealthy,
+            failures: e.consecutiveFailures,
+        }));
+    }
+}
+// Singleton instance
+// Created on first use, not at import: the constructor reads TRANSLATOR_*
+// env vars and starts health checks, and importing @babelize/engine must not
+// do either — a host may load its env (dotenv, test setup) after the import.
+let instance = null;
+function getTranslatorLoadBalancer() {
+    if (!instance)
+        instance = new TranslatorLoadBalancer();
+    return instance;
+}
+exports.translatorLoadBalancer = new Proxy({}, {
+    get(_target, prop) {
+        const lb = getTranslatorLoadBalancer();
+        const value = Reflect.get(lb, prop, lb);
+        return typeof value === 'function' ? value.bind(lb) : value;
+    },
+});

package/dist/utils/ui-copy.d.ts

@@ -0,0 +1,32 @@
+import * as t from '@babel/types';
+/**
+ * UI copy vs program data in object / array / variable initializers.
+ *
+ * `const user = { name: "Ada" }` is data: translating it rewrites a user's
+ * name (`{ name: t("page.ada") }`). `[{ label: "Home", href: "/" }]` holds UI
+ * copy under `label` and data under `href`. A string in an initializer is
+ * only extracted when its key says it's copy, or (without a telling key) when
+ * it looks like copy: a sentence, a Title Case phrase or a capitalized word.
+ * Both lists match the key's last camelCase word (`buttonLabel` → label,
+ * `firstName` → name) or the whole key, case-insensitively, and can be
+ * extended by callers.
+ */
+export declare const UI_COPY_KEYS: Set<string>;
+export declare const DATA_KEYS: Set<string>;
+/** Two or more words with letters: reads like copy, not an identifier. */
+export declare function isMultiWordCopy(text: string): boolean;
+/**
+ * Copy without a key to say so: a sentence or Title Case phrase, or a single
+ * capitalized word ("Overview", "Settings"). Data looks different: lowercase
+ * tokens ("active"), kebab/snake/camelCase, ALLCAPS, or anything with digits,
+ * underscores, slashes or dots in a single token.
+ */
+export declare function looksLikeCopy(text: string): boolean;
+/** Whether a string stored under `name` (a key or a variable) is UI copy. */
+export declare function isUiCopyForName(name: string | null, text: string): boolean;
+/**
+ * For a string literal in an object property value, array element or
+ * variable/assignment initializer: is it UI copy? Other positions (JSX,
+ * returns, conditionals, …) aren't initializers and are left as they are.
+ */
+export declare function isUiCopyLiteral(node: t.Node, parent: t.Node | null | undefined, text: string): boolean;