translatronx 1.0.0

package/dist/cli.js

@@ -0,0 +1,1599 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk4 from 'chalk';
+import { z } from 'zod';
+import { cosmiconfig } from 'cosmiconfig';
+import { pathToFileURL } from 'url';
+import Database from 'better-sqlite3';
+import { writeFileSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync } from 'fs';
+import { dirname, join } from 'path';
+import fg from 'fast-glob';
+import { createHash } from 'crypto';
+import OpenAI from 'openai';
+import Anthropic from '@anthropic-ai/sdk';
+import { Groq } from 'groq-sdk';
+import ora from 'ora';
+
+var ProviderTypeSchema = z.enum([
+  "openai",
+  "anthropic",
+  "groq",
+  "local",
+  "azure-openai",
+  "openrouter"
+]);
+var ProviderConfigSchema = z.object({
+  name: z.string().min(1, "Provider name is required"),
+  type: ProviderTypeSchema,
+  apiKey: z.string().optional(),
+  baseUrl: z.string().url().optional(),
+  model: z.string().min(1, "Model name is required"),
+  temperature: z.number().min(0).max(2).default(0.3),
+  maxRetries: z.number().int().min(0).default(3),
+  fallback: z.string().optional()
+});
+var ExtractorConfigSchema = z.object({
+  type: z.enum(["json", "typescript", "custom"]),
+  pattern: z.string().or(z.array(z.string())),
+  keyPrefix: z.string().optional(),
+  exclude: z.array(z.string()).optional()
+});
+var PromptConfigSchema = z.object({
+  /** @deprecated Use customContext instead. This field will be removed in v2.0 */
+  systemPrompt: z.string().optional(),
+  /** User-configurable prompt content (array for better readability, will be joined with newlines) */
+  userPrompt: z.array(z.string()).optional(),
+  customContext: z.string().optional(),
+  formatting: z.enum(["formal", "casual", "technical"]).optional(),
+  glossary: z.record(z.string(), z.string()).optional(),
+  brandVoice: z.string().optional()
+}).optional();
+var ValidationConfigSchema = z.object({
+  preservePlaceholders: z.boolean().default(true),
+  maxLengthRatio: z.number().min(0).default(3),
+  preventSourceLeakage: z.boolean().default(true),
+  brandNames: z.array(z.string()).optional(),
+  customRules: z.array(z.any()).optional()
+});
+var OutputConfigSchema = z.object({
+  dir: z.string().default("./locales"),
+  format: z.enum(["json", "yaml", "typescript"]).default("json"),
+  flat: z.boolean().default(false),
+  indent: z.number().int().min(0).max(8).default(2),
+  // File naming pattern: {shortCode}.json, {language}.translation.json, or custom
+  fileNaming: z.string().default("{shortCode}.json"),
+  // Allow source and target files in same directory
+  allowSameFolder: z.boolean().default(false)
+});
+var AdvancedConfigSchema = z.object({
+  batchSize: z.number().int().min(1).default(20),
+  concurrency: z.number().int().min(1).max(10).default(3),
+  cacheDir: z.string().default("./.translatronx"),
+  ledgerPath: z.string().default("./.translatronx/ledger.sqlite"),
+  verbose: z.boolean().default(false)
+}).optional();
+var TargetLanguageSchema = z.object({
+  language: z.string().min(1, "Language name is required"),
+  shortCode: z.string().min(2, "Language short code is required")
+});
+var translatronxConfigSchema = z.object({
+  sourceLanguage: z.string().min(2, "Source language code is required"),
+  targetLanguages: z.array(TargetLanguageSchema).min(1, "At least one target language is required"),
+  extractors: z.array(ExtractorConfigSchema).min(1, "At least one extractor is required"),
+  providers: z.array(ProviderConfigSchema).min(1, "At least one provider is required"),
+  validation: ValidationConfigSchema.default({}),
+  output: OutputConfigSchema.default({}),
+  prompts: PromptConfigSchema,
+  advanced: AdvancedConfigSchema
+});
+function validateConfig(config) {
+  return translatronxConfigSchema.parse(config);
+}
+var MODULE_NAME = "translatronx";
+async function loadConfig(searchFrom) {
+  const explorer = cosmiconfig(MODULE_NAME, {
+    searchPlaces: [
+      "translatronx.config.ts",
+      "translatronx.config.js",
+      "translatronx.config.json",
+      `.${MODULE_NAME}rc`,
+      `.${MODULE_NAME}rc.json`,
+      `.${MODULE_NAME}rc.ts`,
+      `.${MODULE_NAME}rc.js`
+    ],
+    loaders: {
+      ".ts": async (filepath) => {
+        try {
+          const fileUrl = pathToFileURL(filepath).href;
+          const module = await import(fileUrl);
+          return module.default || module;
+        } catch (error) {
+          throw new Error(`Failed to load TypeScript config from ${filepath}: ${error}`);
+        }
+      }
+    }
+  });
+  try {
+    const result = await explorer.search(searchFrom);
+    if (!result || !result.config) {
+      throw new Error(
+        `No ${MODULE_NAME} configuration found. Run 'translatronx init' to create one.`
+      );
+    }
+    try {
+      const config = validateConfig(result.config);
+      return config;
+    } catch (error) {
+      console.error(chalk4.red("\u274C Configuration validation failed:"));
+      if (error.errors) {
+        error.errors.forEach((err) => {
+          console.error(chalk4.yellow(`  - ${err.path.join(".")}: ${err.message}`));
+        });
+      } else {
+        console.error(chalk4.yellow(`  ${error.message}`));
+      }
+      throw new Error("Invalid configuration");
+    }
+  } catch (error) {
+    if (error.message.includes("No translatronx configuration found")) {
+      throw error;
+    }
+    console.error(chalk4.red("\u274C Failed to load configuration:"));
+    console.error(chalk4.yellow(`  ${error.message}`));
+    throw error;
+  }
+}
+function getDefaultConfig() {
+  return {
+    sourceLanguage: "en",
+    targetLanguages: [
+      { language: "Spanish", shortCode: "es" },
+      { language: "French", shortCode: "fr" },
+      { language: "German", shortCode: "de" }
+    ],
+    extractors: [
+      {
+        type: "json",
+        pattern: "src/locales/en/**/*.json"
+      }
+    ],
+    providers: [
+      {
+        name: "primary",
+        type: "openai",
+        model: "gpt-4-turbo-preview",
+        temperature: 0.3,
+        maxRetries: 3
+      }
+    ],
+    validation: {
+      preservePlaceholders: true,
+      maxLengthRatio: 3,
+      preventSourceLeakage: true
+    },
+    output: {
+      dir: "./locales",
+      format: "json",
+      flat: false,
+      indent: 2,
+      fileNaming: "{shortCode}.json",
+      allowSameFolder: false
+    },
+    // Optional: Customize translation prompts
+    // prompts: {
+    //   userPrompt: [
+    //     'Please translate the following strings.',
+    //     'Maintain a professional and friendly tone.',
+    //     'Use gender-neutral language where possible.',
+    //   ],
+    //   customContext: 'This is a mobile banking application.',
+    //   formatting: 'formal',
+    //   brandVoice: 'Professional, trustworthy, and approachable',
+    //   glossary: {
+    //     'Account': 'Cuenta',
+    //     'Balance': 'Saldo',
+    //   },
+    // },
+    advanced: {
+      batchSize: 20,
+      concurrency: 3,
+      cacheDir: "./.translatronx",
+      ledgerPath: "./.translatronx/ledger.sqlite",
+      verbose: false
+    }
+  };
+}
+var translatronxLedger = class {
+  db;
+  constructor(ledgerPath) {
+    const dir = dirname(ledgerPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    this.db = new Database(ledgerPath);
+    this.initializeSchema();
+  }
+  /**
+   * Initialize database schema
+   */
+  initializeSchema() {
+    this.db.exec(`
+      -- Source hashes table for change detection
+      CREATE TABLE IF NOT EXISTS source_hashes (
+        key_path TEXT PRIMARY KEY,
+        value_hash TEXT NOT NULL,
+        context_sig TEXT,
+        last_seen_run TEXT,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_hash_lookup 
+        ON source_hashes(value_hash, context_sig);
+
+      -- Sync status table for tracking translation state
+      CREATE TABLE IF NOT EXISTS sync_status (
+        key_path TEXT,
+        lang_code TEXT,
+        target_hash TEXT,
+        status TEXT CHECK(status IN ('CLEAN','DIRTY','FAILED','MANUAL','SKIPPED')),
+        model_fingerprint TEXT,
+        prompt_version INTEGER,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY (key_path, lang_code)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_status_lookup 
+        ON sync_status(status, lang_code);
+
+      -- Run history table for audit trail
+      CREATE TABLE IF NOT EXISTS run_history (
+        run_id TEXT PRIMARY KEY,
+        started_at TIMESTAMP,
+        finished_at TIMESTAMP,
+        model_used TEXT,
+        tokens_in INTEGER,
+        tokens_out INTEGER,
+        cost_estimate_usd REAL,
+        config_hash TEXT
+      );
+    `);
+  }
+  /**
+   * Get source hash for a key path
+   */
+  getSourceHash(keyPath) {
+    const stmt = this.db.prepare(`
+      SELECT value_hash FROM source_hashes WHERE key_path = ?
+    `);
+    const row = stmt.get(keyPath);
+    return row?.value_hash || null;
+  }
+  /**
+   * Update source hash for a key path
+   */
+  updateSourceHash(keyPath, valueHash, contextSig, runId) {
+    const stmt = this.db.prepare(`
+      INSERT INTO source_hashes (key_path, value_hash, context_sig, last_seen_run)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(key_path) DO UPDATE SET
+        value_hash = excluded.value_hash,
+        context_sig = excluded.context_sig,
+        last_seen_run = excluded.last_seen_run,
+        updated_at = CURRENT_TIMESTAMP
+    `);
+    stmt.run(keyPath, valueHash, contextSig || null, runId || null);
+  }
+  /**
+   * Get sync status for a key-language pair
+   */
+  getSyncStatus(keyPath, langCode) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM sync_status WHERE key_path = ? AND lang_code = ?
+    `);
+    const row = stmt.get(keyPath, langCode);
+    return row || null;
+  }
+  /**
+   * Update sync status for a key-language pair
+   */
+  updateSyncStatus(keyPath, langCode, targetHash, status, modelFingerprint, promptVersion) {
+    const stmt = this.db.prepare(`
+      INSERT INTO sync_status (key_path, lang_code, target_hash, status, model_fingerprint, prompt_version)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(key_path, lang_code) DO UPDATE SET
+        target_hash = excluded.target_hash,
+        status = excluded.status,
+        model_fingerprint = excluded.model_fingerprint,
+        prompt_version = excluded.prompt_version,
+        updated_at = CURRENT_TIMESTAMP
+    `);
+    stmt.run(keyPath, langCode, targetHash, status, modelFingerprint || null, promptVersion || null);
+  }
+  /**
+   * Begin a new run and return run ID
+   */
+  startRun(modelUsed, configHash) {
+    const runId = `run_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const stmt = this.db.prepare(`
+      INSERT INTO run_history (run_id, started_at, model_used, config_hash)
+      VALUES (?, CURRENT_TIMESTAMP, ?, ?)
+    `);
+    stmt.run(runId, modelUsed, configHash);
+    return runId;
+  }
+  /**
+   * Complete a run with stats
+   */
+  completeRun(runId, tokensIn, tokensOut, costEstimate) {
+    const stmt = this.db.prepare(`
+      UPDATE run_history
+      SET finished_at = CURRENT_TIMESTAMP,
+          tokens_in = ?,
+          tokens_out = ?,
+          cost_estimate_usd = ?
+      WHERE run_id = ?
+    `);
+    stmt.run(tokensIn, tokensOut, costEstimate, runId);
+  }
+  /**
+   * Get all dirty/new translations for a language
+   */
+  getDirtyKeys(langCode) {
+    const stmt = this.db.prepare(`
+      SELECT key_path FROM sync_status 
+      WHERE lang_code = ? AND status IN ('DIRTY', 'FAILED')
+    `);
+    const rows = stmt.all(langCode);
+    return rows.map((r) => r.key_path);
+  }
+  /**
+   * Clean up old run history (keep last N runs)
+   */
+  cleanupHistory(keepLast = 100) {
+    this.db.exec(`
+      DELETE FROM run_history 
+      WHERE run_id NOT IN (
+        SELECT run_id FROM run_history 
+        ORDER BY started_at DESC 
+        LIMIT ${keepLast}
+      )
+    `);
+  }
+  /**
+   * Get the most recent run record
+   */
+  getLatestRun() {
+    const stmt = this.db.prepare(`
+      SELECT * FROM run_history ORDER BY started_at DESC LIMIT 1
+    `);
+    return stmt.get() || null;
+  }
+  /**
+   * Get aggregate statistics for the project
+   */
+  getProjectStats() {
+    const totalKeys = this.db.prepare(`SELECT COUNT(DISTINCT key_path) as count FROM source_hashes`).get();
+    const manualCount = this.db.prepare(`SELECT COUNT(*) as count FROM sync_status WHERE status = 'MANUAL'`).get();
+    return {
+      total_keys: totalKeys.count,
+      manual_count: manualCount.count
+    };
+  }
+  /**
+   * Get status counts per language
+   */
+  getLanguageStats(langCode) {
+    const translated = this.db.prepare(`
+      SELECT COUNT(*) as count FROM sync_status 
+      WHERE lang_code = ? AND status = 'CLEAN'
+    `).get(langCode);
+    const failed = this.db.prepare(`
+      SELECT COUNT(*) as count FROM sync_status 
+      WHERE lang_code = ? AND status IN ('FAILED', 'DIRTY')
+    `).get(langCode);
+    return {
+      translated: translated.count,
+      failed: failed.count
+    };
+  }
+  /**
+   * Get failed translation items for retry
+   */
+  getFailedItems(langCode, _batchId) {
+    let query = `
+      SELECT ss.*, sh.value_hash 
+      FROM sync_status ss 
+      LEFT JOIN source_hashes sh ON ss.key_path = sh.key_path
+      WHERE ss.status = 'FAILED'
+    `;
+    const params = [];
+    if (langCode) {
+      query += ` AND ss.lang_code = ?`;
+      params.push(langCode);
+    }
+    const stmt = this.db.prepare(query);
+    return stmt.all(...params);
+  }
+  /**
+   * Close database connection
+   */
+  close() {
+    this.db.close();
+  }
+  /**
+   * Execute a transaction
+   */
+  transaction(fn) {
+    return this.db.transaction(fn)();
+  }
+};
+function computeHash(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+function extractPlaceholders(text) {
+  const patterns = [
+    /\{([^}]+)\}/g,
+    // {var}
+    /\{\{([^}]+)\}\}/g,
+    // {{var}}
+    /%[sdif]/g,
+    // %s, %d, %i, %f
+    /\$\{([^}]+)\}/g,
+    // ${var}
+    /\$\d+/g
+    // $1, $2, etc.
+  ];
+  const placeholders = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    const matches = text.matchAll(pattern);
+    for (const match of matches) {
+      placeholders.add(match[0]);
+    }
+  }
+  return Array.from(placeholders).sort();
+}
+function generateUnitId(keyPath, sourceFile) {
+  const combined = `${sourceFile}:${keyPath}`;
+  return computeHash(combined).substring(0, 16);
+}
+
+// src/extractors/json-extractor.ts
+var JsonExtractor = class {
+  schemaVersion = 1;
+  /**
+   * Extract translatable strings from JSON files
+   */
+  async extract(_sourceFiles, config) {
+    const units = [];
+    const patterns = Array.isArray(config.pattern) ? config.pattern : [config.pattern];
+    const files = await fg(patterns, {
+      ignore: config.exclude || ["**/node_modules/**", "**/dist/**"],
+      absolute: true
+    });
+    for (const filePath of files) {
+      try {
+        const content = readFileSync(filePath, "utf-8");
+        const data = JSON.parse(content);
+        const fileUnits = this.extractFromObject(data, [], filePath, config.keyPrefix);
+        units.push(...fileUnits);
+      } catch (error) {
+        console.error(`Failed to extract from ${filePath}:`, error);
+      }
+    }
+    return units;
+  }
+  /**
+   * Recursively extract strings from a JSON object
+   */
+  extractFromObject(obj, keyPath, sourceFile, keyPrefix) {
+    const units = [];
+    if (typeof obj === "string") {
+      const fullKeyPath = keyPrefix ? `${keyPrefix}.${keyPath.join(".")}` : keyPath.join(".");
+      units.push(this.createSourceUnit(fullKeyPath, obj, sourceFile));
+    } else if (Array.isArray(obj)) {
+      obj.forEach((item, index) => {
+        units.push(...this.extractFromObject(item, [...keyPath, index.toString()], sourceFile, keyPrefix));
+      });
+    } else if (obj && typeof obj === "object") {
+      for (const [key, value] of Object.entries(obj)) {
+        units.push(...this.extractFromObject(value, [...keyPath, key], sourceFile, keyPrefix));
+      }
+    }
+    return units;
+  }
+  /**
+   * Create a source unit from extracted string
+   */
+  createSourceUnit(keyPath, sourceText, sourceFile) {
+    const placeholders = extractPlaceholders(sourceText);
+    const sourceHash = computeHash(sourceText);
+    const unitId = generateUnitId(keyPath, sourceFile);
+    return {
+      unitId,
+      keyPath,
+      sourceText,
+      sourceHash,
+      placeholders,
+      sourceFile,
+      schemaVersion: this.schemaVersion
+    };
+  }
+};
+
+// src/planner/index.ts
+var IncrementalTranslationPlanner = class {
+  constructor(ledger) {
+    this.ledger = ledger;
+  }
+  /**
+   * Create a translation plan based on change detection
+   */
+  async createPlan(sourceUnits, targetLanguages) {
+    const batches = [];
+    let totalUnits = 0;
+    for (const lang of targetLanguages) {
+      const unitsNeedingTranslation = this.detectChanges(sourceUnits, lang.shortCode);
+      if (unitsNeedingTranslation.length === 0) {
+        continue;
+      }
+      const langBatches = this.createBatches(unitsNeedingTranslation, lang.shortCode);
+      batches.push(...langBatches);
+      totalUnits += unitsNeedingTranslation.length;
+    }
+    const estimatedCost = this.estimateCost(totalUnits);
+    return {
+      batches,
+      totalUnits,
+      estimatedCost
+    };
+  }
+  /**
+   * Detect which source units have changed and need translation
+   */
+  detectChanges(sourceUnits, targetLang) {
+    const needsTranslation = [];
+    for (const unit of sourceUnits) {
+      const storedHash = this.ledger.getSourceHash(unit.keyPath);
+      const sourceChanged = storedHash !== unit.sourceHash;
+      const syncStatus = this.ledger.getSyncStatus(unit.keyPath, targetLang);
+      if (!syncStatus) {
+        needsTranslation.push(unit);
+      } else if (syncStatus.status === "MANUAL") {
+        continue;
+      } else if (sourceChanged) {
+        needsTranslation.push(unit);
+      } else if (syncStatus.status === "FAILED" || syncStatus.status === "DIRTY") {
+        needsTranslation.push(unit);
+      }
+    }
+    return needsTranslation;
+  }
+  /**
+   * Create batches from units for efficient LLM processing
+   */
+  createBatches(units, targetLang, batchSize = 20) {
+    const batches = [];
+    for (let i = 0; i < units.length; i += batchSize) {
+      const batchUnits = units.slice(i, i + batchSize);
+      const batchId = `batch_${targetLang}_${Date.now()}_${i}`;
+      const contentHash = computeHash(
+        batchUnits.map((u) => u.sourceHash).join("_")
+      );
+      batches.push({
+        batchId,
+        sourceUnits: batchUnits,
+        targetLanguage: targetLang,
+        deduplicationKey: contentHash
+      });
+    }
+    return batches;
+  }
+  /**
+   * Estimate cost for translation
+   * Rough estimate: 50 input tokens + 50 output tokens per unit
+   * OpenAI pricing: ~$0.01 per 1K tokens
+   */
+  estimateCost(totalUnits) {
+    const tokensPerUnit = 100;
+    const totalTokens = totalUnits * tokensPerUnit;
+    const costPer1kTokens = 0.01;
+    return totalTokens / 1e3 * costPer1kTokens;
+  }
+};
+
+// src/providers/base-provider.ts
+var BaseLLMProvider = class {
+  constructor(config) {
+    this.config = config;
+    this.maxRetries = config.maxRetries ?? 3;
+    this.temperature = config.temperature ?? 0.3;
+  }
+  maxRetries;
+  temperature;
+  /**
+   * Retry logic with exponential backoff
+   */
+  async retryWithBackoff(fn, attempt = 0) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (attempt >= this.maxRetries) {
+        throw error;
+      }
+      const delay = Math.pow(2, attempt) * 1e3;
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      return this.retryWithBackoff(fn, attempt + 1);
+    }
+  }
+  /**
+   * Build prompt for translation batch
+   */
+  buildTranslationPrompt(batch) {
+    const items = batch.sourceUnits.map((unit, idx) => {
+      return `${idx + 1}. [${unit.keyPath}]: "${unit.sourceText}"`;
+    }).join("\n");
+    return `Translate the following strings to ${batch.targetLanguage}. Preserve all placeholders exactly as they appear. Return a JSON array with the same order.
+
+${items}`;
+  }
+  /**
+   * Clean LLM output to extract just the JSON part
+   * Handles <think> tags, markdown, and extra text
+   */
+  cleanJsonOutput(text) {
+    let clean = text.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+    const codeBlockMatch = clean.match(/```(?:json)?\s*(\[[\s\S]*?\])\s*```/);
+    if (codeBlockMatch) {
+      return codeBlockMatch[1];
+    }
+    const start = clean.indexOf("[");
+    const end = clean.lastIndexOf("]");
+    if (start !== -1 && end !== -1 && end > start) {
+      return clean.substring(start, end + 1);
+    }
+    return clean;
+  }
+  /**
+   * Parse translation response into results
+   */
+  parseTranslationResponse(batch, responseText) {
+    try {
+      const jsonString = this.cleanJsonOutput(responseText);
+      const translations = JSON.parse(jsonString);
+      if (!Array.isArray(translations)) {
+        throw new Error("Response is not an array");
+      }
+      return batch.sourceUnits.map((unit, idx) => ({
+        unitId: unit.unitId,
+        translatedText: translations[idx] || "",
+        confidence: 1
+      }));
+    } catch (error) {
+      console.error("Failed to parse response as JSON array:", error);
+      console.debug("Raw response:", responseText);
+      throw new Error("Invalid translation response format");
+    }
+  }
+};
+
+// src/providers/openai-provider.ts
+var OpenAIProvider = class extends BaseLLMProvider {
+  client;
+  constructor(config) {
+    super(config);
+    this.client = new OpenAI({
+      apiKey: config.apiKey,
+      baseURL: config.baseUrl
+    });
+  }
+  async translate(batch, prompt) {
+    return this.retryWithBackoff(async () => {
+      const userPrompt = this.buildTranslationPrompt(batch);
+      const response = await this.client.chat.completions.create({
+        model: this.config.model,
+        temperature: this.temperature,
+        messages: [
+          { role: "system", content: prompt.system },
+          { role: "user", content: userPrompt }
+        ],
+        response_format: { type: "json_object" }
+      });
+      const content = response.choices[0]?.message?.content || "[]";
+      const jsonMatch = content.match(/\[[\s\S]*\]/);
+      const jsonString = jsonMatch ? jsonMatch[0] : content;
+      return this.parseTranslationResponse(batch, jsonString);
+    });
+  }
+  getModelFingerprint() {
+    return `openai:${this.config.model}`;
+  }
+  estimateCost(batch) {
+    const avgCharsPerUnit = batch.sourceUnits.reduce((sum, u) => sum + u.sourceText.length, 0) / batch.sourceUnits.length;
+    const estimatedInputTokens = batch.sourceUnits.length * (avgCharsPerUnit / 4);
+    const estimatedOutputTokens = estimatedInputTokens;
+    const inputCost = estimatedInputTokens / 1e3 * 0.03;
+    const outputCost = estimatedOutputTokens / 1e3 * 0.06;
+    return inputCost + outputCost;
+  }
+};
+var AnthropicProvider = class extends BaseLLMProvider {
+  client;
+  constructor(config) {
+    super(config);
+    this.client = new Anthropic({
+      apiKey: config.apiKey
+    });
+  }
+  async translate(batch, prompt) {
+    return this.retryWithBackoff(async () => {
+      const userPrompt = this.buildTranslationPrompt(batch);
+      const response = await this.client.messages.create({
+        model: this.config.model,
+        max_tokens: prompt.maxTokens || 4096,
+        temperature: this.temperature,
+        system: prompt.system,
+        messages: [
+          { role: "user", content: userPrompt }
+        ]
+      });
+      const content = response.content[0];
+      if (content.type !== "text") {
+        throw new Error("Expected text response from Anthropic");
+      }
+      const jsonMatch = content.text.match(/\[[\s\S]*\]/);
+      const jsonString = jsonMatch ? jsonMatch[0] : content.text;
+      return this.parseTranslationResponse(batch, jsonString);
+    });
+  }
+  getModelFingerprint() {
+    return `anthropic:${this.config.model}`;
+  }
+  estimateCost(batch) {
+    const avgCharsPerUnit = batch.sourceUnits.reduce((sum, u) => sum + u.sourceText.length, 0) / batch.sourceUnits.length;
+    const estimatedInputTokens = batch.sourceUnits.length * (avgCharsPerUnit / 4);
+    const estimatedOutputTokens = estimatedInputTokens;
+    const inputCost = estimatedInputTokens / 1e3 * 0.015;
+    const outputCost = estimatedOutputTokens / 1e3 * 0.075;
+    return inputCost + outputCost;
+  }
+};
+var GroqProvider = class extends BaseLLMProvider {
+  client;
+  constructor(config) {
+    super(config);
+    this.client = new Groq({
+      apiKey: config.apiKey
+    });
+  }
+  async translate(batch, prompt) {
+    return this.retryWithBackoff(async () => {
+      const userPrompt = this.buildTranslationPrompt(batch);
+      const response = await this.client.chat.completions.create({
+        model: this.config.model,
+        temperature: this.temperature,
+        messages: [
+          { role: "system", content: prompt.system },
+          { role: "user", content: userPrompt }
+        ],
+        response_format: { type: "json_object" }
+      });
+      const content = response.choices[0]?.message?.content || "[]";
+      const jsonMatch = content.match(/\[[\s\S]*\]/);
+      const jsonString = jsonMatch ? jsonMatch[0] : content;
+      return this.parseTranslationResponse(batch, jsonString);
+    });
+  }
+  getModelFingerprint() {
+    return `groq:${this.config.model}`;
+  }
+  estimateCost(batch) {
+    const avgCharsPerUnit = batch.sourceUnits.reduce((sum, u) => sum + u.sourceText.length, 0) / batch.sourceUnits.length;
+    const estimatedInputTokens = batch.sourceUnits.length * (avgCharsPerUnit / 4);
+    const estimatedOutputTokens = estimatedInputTokens;
+    const inputCost = estimatedInputTokens / 1e3 * 1e-4;
+    const outputCost = estimatedOutputTokens / 1e3 * 2e-4;
+    return inputCost + outputCost;
+  }
+};
+
+// src/providers/index.ts
+var ProviderFactory = class {
+  /**
+   * Create an LLM provider from configuration
+   */
+  static createProvider(config) {
+    switch (config.type) {
+      case "openai":
+        if (!config.apiKey) {
+          throw new Error("OpenAI API key is required");
+        }
+        return new OpenAIProvider({
+          apiKey: config.apiKey,
+          model: config.model,
+          temperature: config.temperature,
+          maxRetries: config.maxRetries,
+          baseUrl: config.baseUrl
+        });
+      case "anthropic":
+        if (!config.apiKey) {
+          throw new Error("Anthropic API key is required");
+        }
+        return new AnthropicProvider({
+          apiKey: config.apiKey,
+          model: config.model,
+          temperature: config.temperature,
+          maxRetries: config.maxRetries
+        });
+      case "groq":
+        if (!config.apiKey) {
+          throw new Error("Groq API key is required");
+        }
+        return new GroqProvider({
+          apiKey: config.apiKey,
+          model: config.model,
+          temperature: config.temperature,
+          maxRetries: config.maxRetries
+        });
+      case "local":
+        return new OpenAIProvider({
+          apiKey: config.apiKey || "not-needed",
+          model: config.model,
+          temperature: config.temperature,
+          maxRetries: config.maxRetries,
+          baseUrl: config.baseUrl || "http://localhost:11434/v1"
+        });
+      case "azure-openai":
+        if (!config.apiKey) {
+          throw new Error("Azure OpenAI API key is required");
+        }
+        return new OpenAIProvider({
+          apiKey: config.apiKey,
+          model: config.model,
+          temperature: config.temperature,
+          maxRetries: config.maxRetries,
+          baseUrl: config.baseUrl
+          // Azure endpoint
+        });
+      case "openrouter":
+        if (!config.apiKey) {
+          throw new Error("OpenRouter API key is required");
+        }
+        return new OpenAIProvider({
+          apiKey: config.apiKey,
+          model: config.model,
+          temperature: config.temperature,
+          maxRetries: config.maxRetries,
+          baseUrl: config.baseUrl || "https://openrouter.ai/api/v1"
+        });
+      default:
+        throw new Error(`Unknown provider type: ${config.type}`);
+    }
+  }
+};
+
+// src/validation/index.ts
+var TranslationValidationPipeline = class {
+  constructor(config = {}) {
+    this.config = config;
+  }
+  async validate(result, sourceUnit) {
+    const errors = [];
+    const warnings = [];
+    let confidence = 1;
+    if (!result.translatedText || result.translatedText.trim().length === 0) {
+      errors.push({
+        type: "EMPTY_TRANSLATION",
+        message: "Translation is empty"
+      });
+      return { isValid: false, errors, warnings, confidence: 0 };
+    }
+    if (this.config.preservePlaceholders !== false) {
+      const placeholderErrors = this.validatePlaceholders(sourceUnit, result);
+      errors.push(...placeholderErrors);
+      if (placeholderErrors.length > 0) {
+        confidence *= 0.5;
+      }
+    }
+    const semanticWarnings = this.validateSemantics(sourceUnit, result);
+    warnings.push(...semanticWarnings);
+    if (semanticWarnings.length > 0) {
+      confidence *= 0.8;
+    }
+    if (this.config.preventSourceLeakage !== false) {
+      const leakageDetected = this.detectSourceLeakage(sourceUnit, result);
+      if (leakageDetected) {
+        errors.push({
+          type: "SOURCE_LEAKAGE",
+          message: "Translation appears to be in source language"
+        });
+        confidence *= 0.3;
+      }
+    }
+    if (this.config.brandNames && this.config.brandNames.length > 0) {
+      const brandWarnings = this.validateBrandNames(sourceUnit, result);
+      warnings.push(...brandWarnings);
+    }
+    const isValid = errors.length === 0;
+    return { isValid, errors, warnings, confidence };
+  }
+  /**
+   * Validate that all placeholders are preserved
+   */
+  validatePlaceholders(sourceUnit, result) {
+    const errors = [];
+    const sourcePlaceholders = new Set(sourceUnit.placeholders);
+    const translatedPlaceholders = new Set(extractPlaceholders(result.translatedText));
+    for (const placeholder of sourcePlaceholders) {
+      if (!translatedPlaceholders.has(placeholder)) {
+        errors.push({
+          type: "MISSING_PLACEHOLDER",
+          message: `Missing placeholder: ${placeholder}`,
+          field: placeholder
+        });
+      }
+    }
+    for (const placeholder of translatedPlaceholders) {
+      if (!sourcePlaceholders.has(placeholder)) {
+        errors.push({
+          type: "EXTRA_PLACEHOLDER",
+          message: `Unexpected placeholder: ${placeholder}`,
+          field: placeholder
+        });
+      }
+    }
+    return errors;
+  }
+  /**
+   * Validate semantic properties like length ratio
+   */
+  validateSemantics(sourceUnit, result) {
+    const warnings = [];
+    const maxLengthRatio = this.config.maxLengthRatio || 3;
+    const sourceLength = sourceUnit.sourceText.length;
+    const translatedLength = result.translatedText.length;
+    const ratio = translatedLength / sourceLength;
+    if (ratio > maxLengthRatio) {
+      warnings.push({
+        type: "LENGTH_RATIO_EXCEEDED",
+        message: `Translation is ${ratio.toFixed(1)}x longer than source (max: ${maxLengthRatio}x)`
+      });
+    }
+    return warnings;
+  }
+  /**
+   * Detect if translation leaked source language
+   */
+  detectSourceLeakage(sourceUnit, result) {
+    const normalizedSource = sourceUnit.sourceText.toLowerCase().trim();
+    const normalizedTranslation = result.translatedText.toLowerCase().trim();
+    if (normalizedSource === normalizedTranslation) {
+      return true;
+    }
+    const sourceWords = new Set(normalizedSource.split(/\s+/));
+    const translationWords = new Set(normalizedTranslation.split(/\s+/));
+    let matchCount = 0;
+    for (const word of sourceWords) {
+      if (translationWords.has(word)) {
+        matchCount++;
+      }
+    }
+    const similarity = matchCount / sourceWords.size;
+    return similarity > 0.8;
+  }
+  /**
+   * Validate that brand names are preserved
+   */
+  validateBrandNames(sourceUnit, result) {
+    const warnings = [];
+    const brandNames = this.config.brandNames || [];
+    for (const brandName of brandNames) {
+      const sourceHasBrand = sourceUnit.sourceText.includes(brandName);
+      const translationHasBrand = result.translatedText.includes(brandName);
+      if (sourceHasBrand && !translationHasBrand) {
+        warnings.push({
+          type: "MISSING_BRAND_NAME",
+          message: `Brand name "${brandName}" not preserved in translation`,
+          field: brandName
+        });
+      }
+    }
+    return warnings;
+  }
+};
+var AtomicFileWriter = class {
+  /**
+   * Get output file path based on configuration
+   */
+  static getOutputPath(targetLanguage, outputConfig) {
+    const pattern = outputConfig.fileNaming || "{shortCode}.json";
+    const filename = pattern.replace(/\{shortCode\}/g, targetLanguage.shortCode).replace(/\{language\}/g, targetLanguage.language);
+    return join(outputConfig.dir, filename);
+  }
+  /**
+   * Write translations to a file atomically
+   */
+  async writeTranslations(filePath, translations) {
+    const dir = dirname(filePath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    let existing = {};
+    if (existsSync(filePath)) {
+      try {
+        const content = readFileSync(filePath, "utf-8");
+        existing = JSON.parse(content);
+      } catch (error) {
+        console.warn(`Failed to read existing file ${filePath}, starting fresh:`, error);
+      }
+    }
+    const merged = this.deepMerge(existing, translations);
+    const tempPath = `${filePath}.tmp`;
+    try {
+      writeFileSync(tempPath, JSON.stringify(merged, null, 2), "utf-8");
+      renameSync(tempPath, filePath);
+    } catch (error) {
+      if (existsSync(tempPath)) {
+        unlinkSync(tempPath);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Deep merge two objects, preserving existing values not being updated
+   */
+  deepMerge(target, source) {
+    if (!source || typeof source !== "object") {
+      return source;
+    }
+    if (Array.isArray(source)) {
+      return source;
+    }
+    const result = { ...target };
+    for (const [key, value] of Object.entries(source)) {
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        result[key] = this.deepMerge(result[key] || {}, value);
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  /**
+   * Convert flat key-value pairs to nested object structure
+   */
+  static flatToNested(flat) {
+    const result = {};
+    for (const [keyPath, value] of Object.entries(flat)) {
+      const keys = keyPath.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;
+  }
+};
+
+// src/prompts/index.ts
+var PromptManager = class {
+  config;
+  constructor(config) {
+    this.config = config || {};
+  }
+  /**
+   * Get the system prompt for translation
+   * Always returns the core SDK system prompt with optional customizations
+   */
+  getSystemPrompt(context) {
+    let prompt = this.getCoreSystemPrompt(context);
+    if (this.config.formatting) {
+      prompt += `
+
+${this.getFormattingInstructions(this.config.formatting)}`;
+    }
+    if (this.config.glossary && Object.keys(this.config.glossary).length > 0) {
+      prompt += `
+
+${this.getGlossaryInstructions(this.config.glossary)}`;
+    }
+    if (this.config.brandVoice) {
+      prompt += `
+
+Brand voice: ${this.config.brandVoice}`;
+    }
+    if (this.config.customContext) {
+      prompt += `
+
+${this.config.customContext}`;
+    }
+    if (this.config.systemPrompt) {
+      prompt += `
+
+${this.config.systemPrompt}`;
+    }
+    return prompt;
+  }
+  /**
+   * Get core SDK system prompt (always used as base)
+   */
+  getCoreSystemPrompt(context) {
+    return `You are a professional translator specializing in software localization.
+
+Your task is to translate the provided strings accurately into ${context.targetLanguage} (${context.targetCode}).
+
+CRITICAL RULES:
+1. **Preserve all placeholders exactly as they appear** - This includes {variable}, {{variable}}, $variable, %s, %d, and any other template syntax
+2. **Maintain the same structure** - Return translations in the exact same JSON array format and order
+3. **Context awareness** - Consider the context of UI strings, messages, and technical terms
+4. **Natural language** - Produce natural, idiomatic translations that native speakers would use
+5. **Consistency** - Maintain consistent terminology throughout all translations
+6. **No additions or omissions** - Translate only what is provided, nothing more, nothing less
+
+OUTPUT FORMAT:
+Return ONLY a valid JSON array of translated strings in the same order as the input.
+Do not include any explanations, comments, or markdown formatting.`;
+  }
+  /**
+   * Get formatting instructions based on style
+   */
+  getFormattingInstructions(formatting) {
+    const styles = {
+      formal: "Use formal language and respectful address. Suitable for professional, business, or official contexts.",
+      casual: "Use casual, friendly language. Suitable for consumer apps and informal communication.",
+      technical: "Use precise technical terminology. Prioritize accuracy over naturalness. Keep technical terms in English when appropriate."
+    };
+    return `Tone and style: ${styles[formatting]}`;
+  }
+  /**
+   * Get glossary instructions
+   */
+  getGlossaryInstructions(glossary) {
+    const terms = Object.entries(glossary).map(([source, target]) => `- "${source}" \u2192 "${target}"`).join("\n");
+    return `GLOSSARY - Use these exact translations for the following terms:
+${terms}`;
+  }
+  /**
+   * Get the current prompt version for tracking
+   */
+  getPromptVersion() {
+    return this.config.userPrompt || this.config.customContext ? 2 : 1;
+  }
+  /**
+   * Build user prompt from source units
+   * Uses custom userPrompt if provided, otherwise defaults to JSON array of source texts
+   */
+  getUserPrompt(sourceTexts) {
+    if (this.config.userPrompt && this.config.userPrompt.length > 0) {
+      const customPrompt = this.config.userPrompt.join("\n");
+      return `${customPrompt}
+
+${JSON.stringify(sourceTexts, null, 0)}`;
+    }
+    return JSON.stringify(sourceTexts, null, 0);
+  }
+};
+var TranslationCompiler = class {
+  constructor(config) {
+    this.config = config;
+    const ledgerPath = config.advanced?.ledgerPath || "./.translatronx/ledger.sqlite";
+    this.ledger = new translatronxLedger(ledgerPath);
+    this.planner = new IncrementalTranslationPlanner(this.ledger);
+    this.writer = new AtomicFileWriter();
+    this.promptManager = new PromptManager(this.config.prompts);
+  }
+  ledger;
+  planner;
+  writer;
+  promptManager;
+  /**
+   * Synchronize translations (main compilation step)
+   */
+  async sync(_options = {}) {
+    const startTime = /* @__PURE__ */ new Date();
+    const spinner = ora("Extracting source strings...").start();
+    try {
+      const extractor = new JsonExtractor();
+      const extractorConfig = this.config.extractors[0];
+      const sourceUnits = await extractor.extract([], extractorConfig);
+      spinner.succeed(`Extracted ${sourceUnits.length} translatable strings`);
+      spinner.start("Updating source hashes...");
+      const configHash = computeHash(JSON.stringify(this.config));
+      const runId = this.ledger.startRun(this.config.providers[0].model, configHash);
+      for (const unit of sourceUnits) {
+        this.ledger.updateSourceHash(unit.keyPath, unit.sourceHash, void 0, runId);
+      }
+      spinner.succeed("Source hashes updated");
+      spinner.start("Creating translation plan...");
+      const plan = await this.planner.createPlan(sourceUnits, this.config.targetLanguages);
+      if (plan.batches.length === 0) {
+        spinner.succeed(chalk4.green("\u2713 All translations are up to date!"));
+        this.ledger.completeRun(runId, 0, 0, 0);
+        return {
+          runId,
+          startedAt: startTime,
+          finishedAt: /* @__PURE__ */ new Date(),
+          totalUnits: sourceUnits.length,
+          translatedUnits: 0,
+          failedUnits: 0,
+          skippedUnits: sourceUnits.length,
+          tokensIn: 0,
+          tokensOut: 0,
+          costEstimateUsd: 0,
+          model: this.config.providers[0].model
+        };
+      }
+      spinner.succeed(`Created plan: ${plan.batches.length} batches, ~$${plan.estimatedCost.toFixed(4)} estimated cost`);
+      const provider = ProviderFactory.createProvider(this.config.providers[0]);
+      const validator = new TranslationValidationPipeline(this.config.validation);
+      let translatedUnits = 0;
+      let failedUnits = 0;
+      let totalTokensIn = 0;
+      let totalTokensOut = 0;
+      spinner.start(`Translating ${plan.totalUnits} strings...`);
+      for (const batch of plan.batches) {
+        try {
+          const targetLangObj = this.config.targetLanguages.find((l) => l.shortCode === batch.targetLanguage);
+          if (!targetLangObj) continue;
+          const langName = targetLangObj.language;
+          const systemPrompt = this.promptManager.getSystemPrompt({
+            targetLanguage: langName,
+            targetCode: batch.targetLanguage,
+            sourceUnits: batch.sourceUnits
+          });
+          const sourceTexts = batch.sourceUnits.map((unit) => unit.sourceText);
+          const userPrompt = this.promptManager.getUserPrompt(sourceTexts);
+          const results = await provider.translate(batch, {
+            system: systemPrompt,
+            user: userPrompt,
+            temperature: this.config.providers[0].temperature
+          });
+          for (let i = 0; i < results.length; i++) {
+            const result = results[i];
+            const sourceUnit = batch.sourceUnits[i];
+            const validation = await validator.validate(result, sourceUnit);
+            if (!validation.isValid) {
+              console.error(chalk4.red(`\u2717 Validation failed for ${sourceUnit.keyPath}:`), validation.errors);
+              failedUnits++;
+              this.ledger.updateSyncStatus(sourceUnit.keyPath, batch.targetLanguage, "", "FAILED");
+              continue;
+            }
+            const outputFile = AtomicFileWriter.getOutputPath(targetLangObj, this.config.output);
+            const translations = AtomicFileWriter.flatToNested({ [sourceUnit.keyPath]: result.translatedText });
+            await this.writer.writeTranslations(outputFile, translations);
+            const targetHash = computeHash(result.translatedText);
+            this.ledger.updateSyncStatus(
+              sourceUnit.keyPath,
+              batch.targetLanguage,
+              targetHash,
+              "CLEAN",
+              provider.getModelFingerprint(),
+              this.promptManager.getPromptVersion()
+            );
+            translatedUnits++;
+          }
+          totalTokensIn += batch.sourceUnits.length * 50;
+          totalTokensOut += batch.sourceUnits.length * 50;
+        } catch (error) {
+          console.error(chalk4.red(`\u2717 Failed to translate batch ${batch.batchId}:`), error);
+          failedUnits += batch.sourceUnits.length;
+        }
+      }
+      spinner.succeed(chalk4.green(`\u2713 Translated ${translatedUnits} strings, ${failedUnits} failed`));
+      const actualCost = provider.estimateCost({ ...plan.batches[0], sourceUnits: sourceUnits.slice(0, translatedUnits) });
+      this.ledger.completeRun(runId, totalTokensIn, totalTokensOut, actualCost);
+      return {
+        runId,
+        startedAt: startTime,
+        finishedAt: /* @__PURE__ */ new Date(),
+        totalUnits: sourceUnits.length,
+        translatedUnits,
+        failedUnits,
+        skippedUnits: sourceUnits.length - translatedUnits - failedUnits,
+        tokensIn: totalTokensIn,
+        tokensOut: totalTokensOut,
+        costEstimateUsd: actualCost,
+        model: this.config.providers[0].model
+      };
+    } catch (error) {
+      spinner.fail("Translation failed");
+      throw error;
+    }
+  }
+  /**
+   * Close ledger connection
+   */
+  close() {
+    this.ledger.close();
+  }
+  /**
+   * Retry failed translation batches
+   */
+  async retryFailed(options) {
+    const spinner = ora("Identifying failed translations...").start();
+    try {
+      const failedItems = this.ledger.getFailedItems(options.lang, options.batch);
+      if (failedItems.length === 0) {
+        spinner.succeed(chalk4.green("\u2713 No failed translations found"));
+        return {
+          recoveredUnits: 0,
+          remainingFailed: 0,
+          tokensIn: 0,
+          tokensOut: 0
+        };
+      }
+      spinner.succeed(`Found ${failedItems.length} failed translations to retry`);
+      if (options.dryRun) {
+        console.log(chalk4.blue("\nDry-run mode - showing what would be retried:"));
+        failedItems.forEach((item) => {
+          console.log(chalk4.gray(`  - ${item.key_path} (${item.lang_code})`));
+        });
+        return {
+          recoveredUnits: 0,
+          remainingFailed: failedItems.length,
+          tokensIn: 0,
+          tokensOut: 0
+        };
+      }
+      const byLanguage = /* @__PURE__ */ new Map();
+      failedItems.forEach((item) => {
+        if (!byLanguage.has(item.lang_code)) {
+          byLanguage.set(item.lang_code, []);
+        }
+        byLanguage.get(item.lang_code)?.push(item);
+      });
+      let recoveredUnits = 0;
+      let remainingFailed = failedItems.length;
+      let totalTokensIn = 0;
+      let totalTokensOut = 0;
+      for (const [langCode, items] of byLanguage) {
+        const targetLangObj = this.config.targetLanguages.find((l) => l.shortCode === langCode);
+        const langName = targetLangObj?.language || langCode;
+        spinner.start(`Retrying ${items.length} strings for ${langName}...`);
+        const batch = {
+          batchId: `retry_${Date.now()}`,
+          sourceUnits: items.map((item) => ({
+            unitId: item.key_path,
+            keyPath: item.key_path,
+            sourceText: "",
+            // Would need to load from source
+            sourceHash: item.value_hash,
+            placeholders: [],
+            sourceFile: "",
+            schemaVersion: 1
+          })),
+          targetLanguage: langCode,
+          deduplicationKey: ""
+        };
+        try {
+          const provider = ProviderFactory.createProvider(this.config.providers[0]);
+          const validator = new TranslationValidationPipeline(this.config.validation);
+          const targetLangObj2 = this.config.targetLanguages.find((l) => l.shortCode === langCode);
+          if (!targetLangObj2) continue;
+          const systemPrompt = this.promptManager.getSystemPrompt({
+            targetLanguage: langName,
+            targetCode: langCode,
+            sourceUnits: batch.sourceUnits
+          });
+          const sourceTexts = batch.sourceUnits.map((unit) => unit.sourceText);
+          const userPrompt = this.promptManager.getUserPrompt(sourceTexts);
+          const results = await provider.translate(batch, {
+            system: systemPrompt,
+            user: userPrompt,
+            temperature: this.config.providers[0].temperature
+          });
+          for (let i = 0; i < results.length; i++) {
+            const translationResult = results[i];
+            const sourceUnit = batch.sourceUnits[i];
+            const validation = await validator.validate(translationResult, sourceUnit);
+            if (validation.isValid) {
+              const outputFile = AtomicFileWriter.getOutputPath(targetLangObj2, this.config.output);
+              const translations = AtomicFileWriter.flatToNested({ [sourceUnit.keyPath]: translationResult.translatedText });
+              await this.writer.writeTranslations(outputFile, translations);
+              const targetHash = computeHash(translationResult.translatedText);
+              this.ledger.updateSyncStatus(
+                sourceUnit.keyPath,
+                langCode,
+                targetHash,
+                "CLEAN",
+                provider.getModelFingerprint(),
+                this.promptManager.getPromptVersion()
+              );
+              recoveredUnits++;
+              remainingFailed--;
+            }
+          }
+          totalTokensIn += batch.sourceUnits.length * 50;
+          totalTokensOut += batch.sourceUnits.length * 50;
+          spinner.succeed(chalk4.green(`\u2713 Retried ${recoveredUnits} strings for ${langName}`));
+        } catch (error) {
+          console.error(chalk4.red(`\u2717 Failed to retry batch for ${langName}:`), error);
+        }
+      }
+      return {
+        recoveredUnits,
+        remainingFailed,
+        tokensIn: totalTokensIn,
+        tokensOut: totalTokensOut
+      };
+    } catch (error) {
+      spinner.fail("Retry operation failed");
+      throw error;
+    }
+  }
+};
+var ReportingSystem = class {
+  constructor(ledger) {
+    this.ledger = ledger;
+  }
+  /**
+   * Get a summary of the latest run
+   */
+  async getLatestRunSummary() {
+    const run = this.ledger.getLatestRun();
+    if (!run) return null;
+    return {
+      runId: run.run_id,
+      startedAt: run.started_at,
+      finishedAt: run.finished_at,
+      modelUsed: run.model_used,
+      tokensIn: run.tokens_in || 0,
+      tokensOut: run.tokens_out || 0,
+      costEstimateUsd: run.cost_estimate_usd || 0,
+      configHash: run.config_hash
+    };
+  }
+  /**
+   * Get overall statistics for the project
+   */
+  async getProjectStats(targetLanguages) {
+    const baseStats = this.ledger.getProjectStats();
+    const coverage = {};
+    let translatedCount = 0;
+    let failedTotal = 0;
+    for (const lang of targetLanguages) {
+      const langStats = this.ledger.getLanguageStats(lang.shortCode);
+      const label = `${lang.language} (${lang.shortCode})`;
+      coverage[label] = langStats.translated;
+      translatedCount += langStats.translated;
+      failedTotal += langStats.failed;
+    }
+    return {
+      totalStrings: baseStats.total_keys,
+      translatedStrings: translatedCount,
+      failedStrings: failedTotal,
+      manualOverrides: baseStats.manual_count,
+      languageCoverage: coverage
+    };
+  }
+  /**
+   * Format a report as a string for CLI output
+   */
+  formatReport(stats) {
+    let output = chalk4.bold("\n\u{1F4CA} Project Translation Status\n");
+    output += chalk4.gray("-----------------------------------\n");
+    output += `Total unique keys: ${stats.totalStrings}
+`;
+    output += `Translated:       ${chalk4.green(stats.translatedStrings)}
+`;
+    output += `Failed/Dirty:     ${chalk4.red(stats.failedStrings)}
+`;
+    output += `Manual Overrides: ${chalk4.yellow(stats.manualOverrides)}
+
+`;
+    output += chalk4.bold("Language Coverage:\n");
+    for (const [lang, count] of Object.entries(stats.languageCoverage)) {
+      const percentage = stats.totalStrings > 0 ? (count / stats.totalStrings * 100).toFixed(1) : "0.0";
+      const color = count === stats.totalStrings ? chalk4.green : chalk4.yellow;
+      output += `  ${lang.padEnd(5)}: ${color(`${count}/${stats.totalStrings}`)} (${percentage}%)
+`;
+    }
+    return output;
+  }
+};
+var program = new Command();
+program.name("translatronx").description("Deterministic, incremental, build-time translation compiler using LLMs");
+program.command("sync").description("Synchronize translations (incremental processing)").option("-f, --force", "Force regeneration of manual overrides").option("-v, --verbose", "Enable verbose output with streaming").action(async (options) => {
+  try {
+    console.log(chalk4.blue("\u{1F504} Syncing translations...\n"));
+    const config = await loadConfig();
+    const compiler = new TranslationCompiler(config);
+    const stats = await compiler.sync(options);
+    compiler.close();
+    console.log(chalk4.green("\n\u2705 Translation sync complete!\n"));
+    console.log(chalk4.white("Statistics:"));
+    console.log(chalk4.gray(`  Total strings: ${stats.totalUnits}`));
+    console.log(chalk4.green(`  Translated: ${stats.translatedUnits}`));
+    console.log(chalk4.red(`  Failed: ${stats.failedUnits}`));
+    console.log(chalk4.yellow(`  Skipped: ${stats.skippedUnits}`));
+    console.log(chalk4.gray(`  Tokens used: ${stats.tokensIn} (input) + ${stats.tokensOut} (output)`));
+    console.log(chalk4.gray(`  Duration: ${((stats.finishedAt.getTime() - stats.startedAt.getTime()) / 1e3).toFixed(2)}s
+`));
+    process.exit(0);
+  } catch (error) {
+    console.error(chalk4.red("\u274C Sync failed:"), error.message);
+    process.exit(1);
+  }
+});
+program.command("init").description("Initialize translatronx configuration").action(async () => {
+  try {
+    console.log(chalk4.blue("\u{1F680} Initializing translatronx...\n"));
+    const config = getDefaultConfig();
+    const configContent = `import { defineConfig } from 'translatronx';
+
+export default defineConfig(${JSON.stringify(config, null, 2)});
+`;
+    writeFileSync("translatronx.config.ts", configContent, "utf-8");
+    console.log(chalk4.green("\u2705 Created translatronx.config.ts"));
+    console.log(chalk4.gray("\nNext steps:"));
+    console.log(chalk4.gray("  1. Edit translatronx.config.ts to configure your project"));
+    console.log(chalk4.gray("  2. Set API key: export OPENAI_API_KEY=your-key"));
+    console.log(chalk4.gray("  3. Run: translatronx sync\n"));
+    process.exit(0);
+  } catch (error) {
+    console.error(chalk4.red("\u274C Init failed:"), error.message);
+    process.exit(1);
+  }
+});
+program.command("status").description("Display coverage statistics and system state").action(async () => {
+  try {
+    console.log(chalk4.blue("\u{1F4CA} Checking status...\n"));
+    const config = await loadConfig();
+    const ledgerPath = config.advanced?.ledgerPath || "./.translatronx/ledger.sqlite";
+    const ledger = new translatronxLedger(ledgerPath);
+    const reporting = new ReportingSystem(ledger);
+    const stats = await reporting.getProjectStats(config.targetLanguages);
+    const latestRun = await reporting.getLatestRunSummary();
+    console.log(reporting.formatReport(stats));
+    if (latestRun) {
+      console.log(chalk4.bold("Latest Run:"));
+      console.log(chalk4.gray(`  Run ID:    ${latestRun.runId}`));
+      console.log(chalk4.gray(`  Model:     ${latestRun.modelUsed}`));
+      console.log(chalk4.gray(`  Cost:      $${latestRun.costEstimateUsd.toFixed(4)}`));
+      console.log(chalk4.gray(`  Duration:  ${latestRun.finishedAt ? "Completed" : "Interrupted"}
+`));
+    }
+    ledger.close();
+    process.exit(0);
+  } catch (error) {
+    console.error(chalk4.red("\u274C Status check failed:"), error.message);
+    process.exit(1);
+  }
+});
+program.command("check").description("Validate target files without making changes").action(async () => {
+  try {
+    console.log(chalk4.blue("\u2713 Checking translations...\n"));
+    console.log(chalk4.yellow("\u26A0\uFE0F  Check command not fully implemented yet"));
+    console.log(chalk4.gray("  This would validate all target files without making changes\n"));
+    process.exit(0);
+  } catch (error) {
+    console.error(chalk4.red("\u274C Check failed:"), error.message);
+    process.exit(1);
+  }
+});
+program.command("retry").description("Retry failed translation batches").option("--batch <id>", "Specific batch ID to retry").option("--lang <code>", "Specific language to retry").option("--dry-run", "Show what would be retried without making changes").action(async (options) => {
+  try {
+    console.log(chalk4.blue("\u{1F504} Retrying failed translations...\n"));
+    const config = await loadConfig();
+    const compiler = new TranslationCompiler(config);
+    const stats = await compiler.retryFailed(options);
+    compiler.close();
+    console.log(chalk4.green("\n\u2705 Retry operation complete!\n"));
+    console.log(chalk4.white("Retry Statistics:"));
+    console.log(chalk4.green(`  Successfully retried: ${stats.recoveredUnits}`));
+    console.log(chalk4.red(`  Still failed: ${stats.remainingFailed}`));
+    console.log(chalk4.gray(`  Tokens used: ${stats.tokensIn} (input) + ${stats.tokensOut} (output)
+`));
+    process.exit(0);
+  } catch (error) {
+    console.error(chalk4.red("\u274C Retry failed:"), error.message);
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map