@syedamirali/i18n-toolkit 0.1.0

package/dist/cli.js

@@ -0,0 +1,2195 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { parse } from "@babel/parser";
+import _traverse from "@babel/traverse";
+import * as t from "@babel/types";
+import fg from "fast-glob";
+import fs from "fs/promises";
+import { createWriteStream } from "fs";
+import os from "os";
+import path from "path";
+import { format as formatInspect } from "util";
+var traverse = _traverse.default ?? _traverse;
+function parseArgs(argv) {
+  const opts = {
+    src: ".",
+    out: null,
+    outputDir: "./output",
+    logDir: "./logs",
+    noLog: false,
+    lang: "en",
+    includeDynamic: true,
+    includeMissing: true,
+    failOnConflict: false,
+    pretty: true,
+    debug: false
+  };
+  const readBool = (raw, fallback) => {
+    if (raw === void 0) return true;
+    if (raw === "true" || raw === "1" || raw === "yes") return true;
+    if (raw === "false" || raw === "0" || raw === "no") return false;
+    return fallback;
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) continue;
+    const [flagRaw, eqVal] = arg.includes("=") ? arg.split(/=(.+)/) : [arg, void 0];
+    const flag = flagRaw.slice(2);
+    const peek = eqVal !== void 0 ? eqVal : argv[i + 1];
+    const consumeStr = () => {
+      if (eqVal !== void 0) return eqVal;
+      i++;
+      return argv[i];
+    };
+    switch (flag) {
+      case "src":
+        opts.src = consumeStr();
+        break;
+      case "out":
+        opts.out = consumeStr();
+        break;
+      case "output-dir":
+        opts.outputDir = consumeStr();
+        break;
+      case "log-dir":
+        opts.logDir = consumeStr();
+        break;
+      case "no-log":
+        opts.noLog = readBool(peek, true);
+        if (eqVal === void 0 && peek && (peek === "true" || peek === "false")) i++;
+        break;
+      case "lang":
+        opts.lang = consumeStr();
+        break;
+      case "include-dynamic":
+        opts.includeDynamic = readBool(peek, true);
+        if (eqVal === void 0 && peek && (peek === "true" || peek === "false")) i++;
+        break;
+      case "include-missing":
+        opts.includeMissing = readBool(peek, true);
+        if (eqVal === void 0 && peek && (peek === "true" || peek === "false")) i++;
+        break;
+      case "fail-on-conflict":
+        opts.failOnConflict = readBool(peek, false);
+        if (eqVal === void 0 && peek && (peek === "true" || peek === "false")) i++;
+        break;
+      case "pretty":
+        opts.pretty = readBool(peek, true);
+        if (eqVal === void 0 && peek && (peek === "true" || peek === "false")) i++;
+        break;
+      case "debug":
+        opts.debug = readBool(peek, true);
+        if (eqVal === void 0 && peek && (peek === "true" || peek === "false")) i++;
+        break;
+      case "help":
+      case "h":
+        printHelpAndExit();
+      default:
+        console.warn(`${ansi.yellow}[warn]${ansi.reset} unknown flag: --${flag}`);
+    }
+  }
+  return opts;
+}
+function printHelpAndExit() {
+  console.log(`translation-extractor \u2014 scan a project for translation keys
+
+Usage:
+  npx tsx src/index.ts [options]
+  yarn extract -- [options]
+
+Options:
+  --src <path>              Root directory to scan (default ".")
+  --out <path>              Output JSON file (overrides --output-dir)
+  --output-dir <path>       Directory for auto-named output (default "./output")
+  --log-dir <path>          Directory for run logs (default "./logs")
+  --no-log                  Disable writing the per-run log file
+  --lang <code>             Top-level language key (default "en")
+  --include-dynamic <bool>  Emit dynamic keys with "__dynamic__" value (default true)
+  --include-missing <bool>  Emit "__missing_default__" for keys w/o fallback (default true)
+  --fail-on-conflict <bool> Exit 1 if duplicate keys conflict (default false)
+  --pretty <bool>           Pretty-print output JSON (default true)
+  --debug <bool>            Verbose logs; parse files >1 MB (default false)
+
+Colors are auto-enabled when stdout is a TTY. To disable, set
+NO_COLOR=1 in your environment. Log files always strip color codes.
+
+When --out is omitted, output is written to:
+  <output-dir>/{timestamp}_translation_extractor.json
+Logs are always written (unless --no-log) to:
+  <log-dir>/{timestamp}_translation_extractor.log
+Timestamp format: DD_mon_HH_MM_SSam|pm  (e.g. 10_may_11_52_30pm)
+`);
+  process.exit(0);
+}
+var DYNAMIC = "__dynamic__";
+var MISSING = "__missing_default__";
+var MAX_FILE_BYTES = 1e6;
+var LOCAL_KEY_ATTR_NAMES = /* @__PURE__ */ new Set(["localKey", "localeKey"]);
+var SHORT_MONTHS = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
+var USE_COLOR = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+var ANSI_RE = /\x1b\[[0-9;]*m/g;
+var stripAnsi = (s) => s.replace(ANSI_RE, "");
+var ansi = {
+  reset: USE_COLOR ? "\x1B[0m" : "",
+  bold: USE_COLOR ? "\x1B[1m" : "",
+  dim: USE_COLOR ? "\x1B[2m" : "",
+  red: USE_COLOR ? "\x1B[31m" : "",
+  green: USE_COLOR ? "\x1B[32m" : "",
+  yellow: USE_COLOR ? "\x1B[33m" : "",
+  blue: USE_COLOR ? "\x1B[34m" : "",
+  magenta: USE_COLOR ? "\x1B[35m" : "",
+  cyan: USE_COLOR ? "\x1B[36m" : ""
+};
+var c = {
+  label: (s) => `${ansi.dim}${s}${ansi.reset}`,
+  value: (s) => `${ansi.bold}${s}${ansi.reset}`,
+  ok: (s) => `${ansi.green}${s}${ansi.reset}`,
+  warn: (s) => `${ansi.yellow}${s}${ansi.reset}`,
+  err: (s) => `${ansi.red}${s}${ansi.reset}`,
+  path: (s) => `${ansi.cyan}${s}${ansi.reset}`,
+  key: (s) => `${ansi.bold}${ansi.magenta}${s}${ansi.reset}`,
+  head: (s) => `${ansi.dim}${s}${ansi.reset}`
+};
+function formatTimestamp(d = /* @__PURE__ */ new Date()) {
+  const dd = String(d.getDate()).padStart(2, "0");
+  const mon = SHORT_MONTHS[d.getMonth()];
+  let h = d.getHours();
+  const ampm = h >= 12 ? "pm" : "am";
+  h = h % 12;
+  if (h === 0) h = 12;
+  const hh = String(h).padStart(2, "0");
+  const mm = String(d.getMinutes()).padStart(2, "0");
+  const ss = String(d.getSeconds()).padStart(2, "0");
+  return `${dd}_${mon}_${hh}_${mm}_${ss}${ampm}`;
+}
+function setupLogTee(stream) {
+  const origLog = console.log;
+  const origWarn = console.warn;
+  const origError = console.error;
+  const tee = (orig) => (...args) => {
+    orig(...args);
+    stream.write(stripAnsi(formatInspect(...args)) + "\n");
+  };
+  console.log = tee(origLog);
+  console.warn = tee(origWarn);
+  console.error = tee(origError);
+  return {
+    teardown: async () => {
+      console.log = origLog;
+      console.warn = origWarn;
+      console.error = origError;
+      await new Promise((resolve) => stream.end(resolve));
+    },
+    dual: (consoleLine, logLine) => {
+      origLog(consoleLine);
+      stream.write(logLine + "\n");
+    }
+  };
+}
+var IGNORE_DIRS = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/.next/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/coverage/**",
+  "**/public/**",
+  "**/vendor/**",
+  "**/*.generated.*"
+];
+var Registry = class {
+  map = /* @__PURE__ */ new Map();
+  conflictsList = [];
+  staticCount = 0;
+  dynamicCount = 0;
+  missingCount = 0;
+  add(key, value, location) {
+    const existing = this.map.get(key);
+    if (!existing) {
+      this.map.set(key, { value, location });
+      this.tallyAdd(value);
+      return;
+    }
+    if (existing.value === value) return;
+    this.conflictsList.push({
+      key,
+      kept: existing,
+      seen: { value, location }
+    });
+  }
+  tallyAdd(value) {
+    if (value === DYNAMIC) this.dynamicCount++;
+    else if (value === MISSING) this.missingCount++;
+    else this.staticCount++;
+  }
+  entries() {
+    return Array.from(this.map.entries()).map(([k, v]) => [k, v.value]).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  }
+  get size() {
+    return this.map.size;
+  }
+  get conflicts() {
+    return this.conflictsList;
+  }
+};
+function getStaticString(node) {
+  if (!node) return null;
+  if (t.isStringLiteral(node)) return node.value;
+  if (t.isTemplateLiteral(node) && node.expressions.length === 0) {
+    return node.quasis.map((q) => q.value.cooked ?? q.value.raw).join("");
+  }
+  return null;
+}
+function getKeyFromNode(node) {
+  if (!node) return null;
+  if (t.isStringLiteral(node)) {
+    return { key: node.value, isDynamic: false };
+  }
+  if (t.isTemplateLiteral(node)) {
+    let key = "";
+    for (let i = 0; i < node.quasis.length; i++) {
+      const q = node.quasis[i];
+      key += q.value.cooked ?? q.value.raw;
+      if (i < node.expressions.length) {
+        const expr = node.expressions[i];
+        key += `\${${reconstructExpression(expr)}}`;
+      }
+    }
+    return { key, isDynamic: node.expressions.length > 0 };
+  }
+  return null;
+}
+function reconstructExpression(node) {
+  if (t.isIdentifier(node)) return node.name;
+  if (t.isMemberExpression(node)) {
+    const serialized = serializeSimpleMember(node);
+    return serialized ?? "__expr__";
+  }
+  return "__expr__";
+}
+function serializeSimpleMember(node) {
+  if (node.computed) return null;
+  if (!t.isIdentifier(node.property)) return null;
+  if (t.isIdentifier(node.object)) {
+    return `${node.object.name}.${node.property.name}`;
+  }
+  if (t.isMemberExpression(node.object)) {
+    const inner = serializeSimpleMember(node.object);
+    return inner ? `${inner}.${node.property.name}` : null;
+  }
+  return null;
+}
+function getObjectPropertyValue(obj, propertyName) {
+  for (const prop of obj.properties) {
+    if (!t.isObjectProperty(prop)) continue;
+    if (prop.computed) continue;
+    const k = prop.key;
+    const matches = t.isIdentifier(k) && k.name === propertyName || t.isStringLiteral(k) && k.value === propertyName;
+    if (!matches) continue;
+    const staticVal = getStaticString(prop.value);
+    if (staticVal !== null) return { kind: "static", value: staticVal };
+    return { kind: "nonstatic" };
+  }
+  return null;
+}
+function normalizeWhitespace(text) {
+  return decodeEntities(text).replace(/\s+/g, " ").trim();
+}
+function decodeEntities(text) {
+  return text.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&apos;/g, "'").replace(/&nbsp;/g, " ");
+}
+function getJSXChildrenText(children) {
+  let out = "";
+  let isDynamic = false;
+  let sawAnyVisible = false;
+  for (const child of children) {
+    if (t.isJSXText(child)) {
+      const normalized = normalizeWhitespace(child.value);
+      if (normalized.length === 0) {
+        if (sawAnyVisible) out += " ";
+        continue;
+      }
+      const leftPad = /^\s/.test(child.value) && sawAnyVisible ? " " : "";
+      const rightPad = /\s$/.test(child.value) ? " " : "";
+      out += leftPad + normalized + rightPad;
+      sawAnyVisible = true;
+      continue;
+    }
+    if (t.isJSXExpressionContainer(child)) {
+      const expr = child.expression;
+      if (t.isJSXEmptyExpression(expr)) continue;
+      const staticVal = getStaticString(expr);
+      if (staticVal !== null) {
+        out += staticVal;
+        sawAnyVisible = true;
+        continue;
+      }
+      isDynamic = true;
+      continue;
+    }
+    if (t.isJSXElement(child)) {
+      const serialized = serializeJSXElement(child);
+      if (serialized.isDynamic) {
+        isDynamic = true;
+        continue;
+      }
+      out += serialized.value;
+      sawAnyVisible = true;
+      continue;
+    }
+    if (t.isJSXFragment(child)) {
+      const inner = getJSXChildrenText(child.children);
+      if (inner.isDynamic) {
+        isDynamic = true;
+        continue;
+      }
+      out += inner.value;
+      if (!inner.isEmpty) sawAnyVisible = true;
+      continue;
+    }
+    isDynamic = true;
+  }
+  out = out.replace(/\s+/g, " ").trim();
+  return { value: out, isDynamic, isEmpty: out.length === 0 };
+}
+function getJSXElementTagName(el) {
+  const name = el.openingElement.name;
+  if (t.isJSXIdentifier(name)) return name.name;
+  if (t.isJSXMemberExpression(name)) {
+    const parts = [];
+    let cur = name;
+    while (t.isJSXMemberExpression(cur)) {
+      parts.unshift(cur.property.name);
+      cur = cur.object;
+    }
+    if (t.isJSXIdentifier(cur)) parts.unshift(cur.name);
+    return parts.join(".");
+  }
+  return null;
+}
+function serializeJSXElement(el) {
+  const tag = getJSXElementTagName(el);
+  if (!tag) return { value: "", isDynamic: true };
+  let attrStr = "";
+  for (const attr of el.openingElement.attributes) {
+    if (t.isJSXSpreadAttribute(attr)) return { value: "", isDynamic: true };
+    if (!t.isJSXAttribute(attr)) return { value: "", isDynamic: true };
+    const aName = t.isJSXIdentifier(attr.name) ? attr.name.name : null;
+    if (!aName) return { value: "", isDynamic: true };
+    if (attr.value === null || attr.value === void 0) {
+      attrStr += ` ${aName}`;
+      continue;
+    }
+    if (t.isStringLiteral(attr.value)) {
+      attrStr += ` ${aName}="${escapeAttr(attr.value.value)}"`;
+      continue;
+    }
+    if (t.isJSXExpressionContainer(attr.value)) {
+      const expr = attr.value.expression;
+      if (t.isJSXEmptyExpression(expr)) continue;
+      const staticVal = getStaticString(expr);
+      if (staticVal !== null) {
+        attrStr += ` ${aName}="${escapeAttr(staticVal)}"`;
+        continue;
+      }
+      return { value: "", isDynamic: true };
+    }
+    return { value: "", isDynamic: true };
+  }
+  if (el.openingElement.selfClosing || el.children.length === 0) {
+    return { value: `<${tag}${attrStr} />`, isDynamic: false };
+  }
+  const inner = getJSXChildrenText(el.children);
+  if (inner.isDynamic) return { value: "", isDynamic: true };
+  return { value: `<${tag}${attrStr}>${inner.value}</${tag}>`, isDynamic: false };
+}
+function escapeAttr(s) {
+  return s.replace(/"/g, "&quot;");
+}
+function lineOf(node) {
+  return node.loc?.start.line ?? 0;
+}
+function extractFromFile(filePath, source, opts) {
+  let ast;
+  try {
+    ast = parse(source, {
+      sourceType: "unambiguous",
+      allowReturnOutsideFunction: true,
+      allowAwaitOutsideFunction: true,
+      errorRecovery: true,
+      plugins: [
+        "typescript",
+        "jsx",
+        "decorators-legacy",
+        "classProperties",
+        "objectRestSpread",
+        "optionalChaining",
+        "nullishCoalescingOperator",
+        "importMeta"
+      ]
+    });
+  } catch (err) {
+    if (opts.debug) console.warn(`${c.err("[parse-error]")} ${c.path(filePath)}: ${err.message}`);
+    throw err;
+  }
+  const records = [];
+  const handledCalls = /* @__PURE__ */ new WeakSet();
+  const addEntry = (key, value, isDynamicKey, node) => {
+    const effectiveValue = isDynamicKey ? DYNAMIC : value;
+    if (effectiveValue === DYNAMIC && !opts.includeDynamic) return;
+    if (effectiveValue === MISSING && !opts.includeMissing) return;
+    records.push({ key, value: effectiveValue, line: lineOf(node) });
+  };
+  function isTCall(call) {
+    if (!t.isIdentifier(call.callee) || call.callee.name !== "t") return false;
+    const first = call.arguments[0];
+    if (!first) return false;
+    return t.isStringLiteral(first) || t.isTemplateLiteral(first);
+  }
+  function handleTCall(call, externalFallback) {
+    const first = call.arguments[0];
+    const keyInfo = getKeyFromNode(first);
+    if (!keyInfo) return;
+    let value;
+    const second = call.arguments[1];
+    if (second && t.isObjectExpression(second)) {
+      const prop = getObjectPropertyValue(second, "__default__");
+      if (prop && prop.kind === "static") {
+        value = prop.value;
+      } else if (prop && prop.kind === "nonstatic") {
+        value = DYNAMIC;
+      } else if (externalFallback !== null) {
+        value = externalFallback;
+      } else {
+        value = MISSING;
+      }
+    } else if (externalFallback !== null) {
+      value = externalFallback;
+    } else {
+      value = MISSING;
+    }
+    addEntry(keyInfo.key, value, keyInfo.isDynamic, call);
+  }
+  traverse(ast, {
+    // Handle `t("k") || "fallback"` BEFORE the inner CallExpression visitor sees it.
+    LogicalExpression(path4) {
+      const node = path4.node;
+      if (node.operator !== "||") return;
+      if (!t.isCallExpression(node.left)) return;
+      if (!isTCall(node.left)) return;
+      const fallback = getStaticString(node.right);
+      if (fallback === null) return;
+      handleTCall(node.left, fallback);
+      handledCalls.add(node.left);
+    },
+    CallExpression(path4) {
+      const node = path4.node;
+      if (handledCalls.has(node)) return;
+      if (!isTCall(node)) return;
+      handleTCall(node, null);
+    },
+    JSXOpeningElement(path4) {
+      const openingEl = path4.node;
+      let localKeyAttr = null;
+      for (const attr of openingEl.attributes) {
+        if (!t.isJSXAttribute(attr)) continue;
+        if (!t.isJSXIdentifier(attr.name)) continue;
+        if (!LOCAL_KEY_ATTR_NAMES.has(attr.name.name)) continue;
+        localKeyAttr = attr;
+        break;
+      }
+      if (!localKeyAttr || !localKeyAttr.value) return;
+      let keyNode = null;
+      if (t.isStringLiteral(localKeyAttr.value)) {
+        keyNode = localKeyAttr.value;
+      } else if (t.isJSXExpressionContainer(localKeyAttr.value)) {
+        const expr = localKeyAttr.value.expression;
+        if (!t.isJSXEmptyExpression(expr)) keyNode = expr;
+      }
+      const keyInfo = getKeyFromNode(keyNode);
+      if (!keyInfo) return;
+      const parent = path4.parent;
+      const children = t.isJSXElement(parent) ? parent.children : [];
+      let value;
+      if (openingEl.selfClosing || children.length === 0) {
+        value = MISSING;
+      } else {
+        const serialized = getJSXChildrenText(children);
+        if (serialized.isEmpty) value = MISSING;
+        else if (serialized.isDynamic) value = DYNAMIC;
+        else value = serialized.value;
+      }
+      addEntry(keyInfo.key, value, keyInfo.isDynamic, openingEl);
+    }
+  });
+  return records;
+}
+async function runExtraction(opts) {
+  const srcAbs = path.resolve(opts.src);
+  const includeDynamic = opts.includeDynamic !== false;
+  const includeMissing = opts.includeMissing !== false;
+  const debug = opts.debug === true;
+  const fileOpts = {
+    includeDynamic,
+    includeMissing,
+    debug
+  };
+  const files = await fg(["**/*.{ts,tsx,js,jsx}"], {
+    cwd: srcAbs,
+    absolute: true,
+    ignore: IGNORE_DIRS,
+    dot: false,
+    followSymbolicLinks: false
+  });
+  files.sort();
+  const registry = new Registry();
+  let skippedFiles = 0;
+  let parsedFiles = 0;
+  let parseErrorFiles = 0;
+  const perFileRecords = new Array(files.length).fill(null);
+  const concurrency = Math.max(1, os.cpus().length);
+  let cursor = 0;
+  const worker = async () => {
+    while (true) {
+      const i = cursor++;
+      if (i >= files.length) return;
+      const file = files[i];
+      let size;
+      try {
+        const st = await fs.stat(file);
+        size = st.size;
+      } catch (err) {
+        if (debug) console.warn(`${c.warn("[stat-error]")} ${c.path(file)}: ${err.message}`);
+        skippedFiles++;
+        continue;
+      }
+      if (size > MAX_FILE_BYTES && !debug) {
+        skippedFiles++;
+        continue;
+      }
+      let source;
+      try {
+        source = await fs.readFile(file, "utf8");
+      } catch (err) {
+        if (debug) console.warn(`${c.warn("[read-error]")} ${c.path(file)}: ${err.message}`);
+        skippedFiles++;
+        continue;
+      }
+      try {
+        perFileRecords[i] = extractFromFile(file, source, fileOpts);
+        parsedFiles++;
+        if (debug) console.log(`${c.ok("[parsed]")} ${c.path(path.relative(process.cwd(), file))}`);
+      } catch {
+        parseErrorFiles++;
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: concurrency }, () => worker()));
+  for (let i = 0; i < files.length; i++) {
+    const recs = perFileRecords[i];
+    if (!recs) continue;
+    const file = files[i];
+    for (const r of recs) {
+      registry.add(r.key, r.value, { file, line: r.line });
+    }
+  }
+  return {
+    entries: registry.entries(),
+    conflicts: registry.conflicts,
+    scannedFiles: files.length,
+    parsedFiles,
+    skippedFiles,
+    parseErrorFiles,
+    keys: registry.size,
+    staticCount: registry.staticCount,
+    dynamicCount: registry.dynamicCount,
+    missingCount: registry.missingCount
+  };
+}
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  const startedAt = /* @__PURE__ */ new Date();
+  const timestamp = formatTimestamp(startedAt);
+  const srcAbs = path.resolve(opts.src);
+  let outAbs;
+  if (opts.out !== null) {
+    outAbs = path.resolve(opts.out);
+  } else {
+    const outDirAbs = path.resolve(opts.outputDir);
+    await fs.mkdir(outDirAbs, { recursive: true });
+    outAbs = path.join(outDirAbs, `${timestamp}_translation_extractor.json`);
+  }
+  let logTee = null;
+  let logAbs = null;
+  if (!opts.noLog) {
+    const logDirAbs = path.resolve(opts.logDir);
+    await fs.mkdir(logDirAbs, { recursive: true });
+    logAbs = path.join(logDirAbs, `${timestamp}_translation_extractor.log`);
+    const stream = createWriteStream(logAbs, { flags: "a" });
+    logTee = setupLogTee(stream);
+    const tag = c.head("[translation-extractor]");
+    console.log(`${tag} run started ${c.label(startedAt.toISOString())}`);
+    console.log(`${tag} src=${c.path(srcAbs)}`);
+    console.log(`${tag} out=${c.path(outAbs)}`);
+    console.log(`${tag} log=${c.path(logAbs)}`);
+    console.log("");
+  }
+  const result = await runExtraction({
+    src: srcAbs,
+    includeDynamic: opts.includeDynamic,
+    includeMissing: opts.includeMissing,
+    debug: opts.debug
+  });
+  if (result.conflicts.length > 0) {
+    const emit = (consoleLine, logLine) => {
+      if (logTee) logTee.dual(consoleLine, logLine);
+      else console.warn(consoleLine);
+    };
+    if (logTee) logTee.dual("", "");
+    else console.log("");
+    for (const conf of result.conflicts) {
+      const keptAbs = conf.kept.location.file;
+      const seenAbs = conf.seen.location.file;
+      const keptRel = path.relative(process.cwd(), keptAbs);
+      const seenRel = path.relative(process.cwd(), seenAbs);
+      const keptLine = conf.kept.location.line;
+      const seenLine = conf.seen.location.line;
+      const keptVal = JSON.stringify(conf.kept.value);
+      const seenVal = JSON.stringify(conf.seen.value);
+      emit(
+        `${c.err("CONFLICT")}  ${c.key(conf.key)}`,
+        `CONFLICT  ${conf.key}`
+      );
+      emit(
+        `  ${c.ok("kept:")}  ${keptVal}  ${c.label(`(${keptRel}:${keptLine})`)}`,
+        `  kept:  ${keptVal}  (${keptAbs}:${keptLine})`
+      );
+      emit(
+        `  ${c.warn("seen:")}  ${seenVal}  ${c.label(`(${seenRel}:${seenLine})`)}`,
+        `  seen:  ${seenVal}  (${seenAbs}:${seenLine})`
+      );
+    }
+    if (logTee) logTee.dual("", "");
+    else console.log("");
+  }
+  const langObj = {};
+  for (const [k, v] of result.entries) langObj[k] = v;
+  const output2 = { [opts.lang]: langObj };
+  const json = opts.pretty ? JSON.stringify(output2, null, 2) + "\n" : JSON.stringify(output2);
+  await fs.mkdir(path.dirname(outAbs), { recursive: true });
+  await fs.writeFile(outAbs, json, "utf8");
+  const skippedNum = result.skippedFiles > 0 ? c.warn(result.skippedFiles) : c.value(result.skippedFiles);
+  const skipNote = result.skippedFiles > 0 ? c.label(" (too large or unreadable; rerun with --debug to include)") : "";
+  const conflictsNum = result.conflicts.length > 0 ? c.warn(result.conflicts.length) : c.ok(result.conflicts.length);
+  const parseErrorsNum = c.err(result.parseErrorFiles);
+  const labels = ["Scanned", "Parsed", "Skipped", "Keys", "Conflicts", "Output"];
+  if (result.parseErrorFiles > 0) labels.push("Parse errors");
+  if (logAbs) labels.push("Log");
+  const pad = Math.max(...labels.map((l) => l.length));
+  const stat = (label, value) => `${c.label(label.padEnd(pad) + " :")} ${value}`;
+  console.log(stat("Scanned", `${c.value(result.scannedFiles)} ${c.label("files")}`));
+  console.log(stat("Parsed", c.value(result.parsedFiles)));
+  if (result.parseErrorFiles > 0) console.log(stat("Parse errors", parseErrorsNum));
+  console.log(stat("Skipped", `${skippedNum}${skipNote}`));
+  console.log(
+    stat(
+      "Keys",
+      `${c.value(result.keys)}  ${c.label("(static:")} ${c.value(result.staticCount)}${c.label(", dynamic:")} ${c.value(result.dynamicCount)}${c.label(", missing:")} ${c.value(result.missingCount)}${c.label(")")}`
+    )
+  );
+  console.log(stat("Conflicts", String(conflictsNum)));
+  console.log(stat("Output", c.path(path.relative(process.cwd(), outAbs))));
+  if (logAbs) console.log(stat("Log", c.path(path.relative(process.cwd(), logAbs))));
+  if (logTee) await logTee.teardown();
+  if (opts.failOnConflict && result.conflicts.length > 0) {
+    process.exit(1);
+  }
+}
+async function runCommand(_argv) {
+  try {
+    await main();
+  } catch (err) {
+    console.error(`${ansi.red}${ansi.bold}[fatal]${ansi.reset}`, err);
+    process.exit(1);
+  }
+}
+
+// src/diff.ts
+import { createInterface } from "readline/promises";
+import fs2 from "fs/promises";
+import { createWriteStream as createWriteStream2 } from "fs";
+import path2 from "path";
+import { stdin as input, stdout as output } from "process";
+var TARGET_LANG = "en";
+var DIFF_OUTPUT_DIR = "./diff-output";
+function parseDiffArgs(argv) {
+  const opts = { src: null, resource: null };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) continue;
+    const [flagRaw, eqVal] = arg.includes("=") ? arg.split(/=(.+)/) : [arg, void 0];
+    const flag = flagRaw.slice(2);
+    const consumeStr = () => eqVal !== void 0 ? eqVal : argv[++i];
+    switch (flag) {
+      case "src":
+        opts.src = consumeStr();
+        break;
+      case "resource":
+        opts.resource = consumeStr();
+        break;
+      default:
+        console.warn(`${ansi.yellow}[warn]${ansi.reset} unknown flag: --${flag}`);
+    }
+  }
+  return opts;
+}
+function cleanPath(raw) {
+  let s = raw.trim();
+  if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'") || s.startsWith("`") && s.endsWith("`")) {
+    s = s.slice(1, -1);
+  }
+  return s;
+}
+async function resolveSourcePath(p) {
+  if (!p) return { error: "Empty input." };
+  const abs = path2.resolve(p);
+  try {
+    const st = await fs2.stat(abs);
+    if (st.isDirectory()) return { kind: "directory", absPath: abs };
+    if (st.isFile()) {
+      if (!abs.toLowerCase().endsWith(".json")) return { error: `Not a .json file: ${abs}` };
+      return { kind: "json", absPath: abs };
+    }
+    return { error: `Not a file or directory: ${abs}` };
+  } catch (err) {
+    return { error: `Path not accessible: ${abs} \u2014 ${err.message}` };
+  }
+}
+async function resolveResourcePath(p) {
+  if (!p) return { error: "Empty input." };
+  const abs = path2.resolve(p);
+  try {
+    const st = await fs2.stat(abs);
+    if (!st.isFile()) return { error: `Not a file: ${abs}` };
+    if (!abs.toLowerCase().endsWith(".json")) return { error: `Not a .json file: ${abs}` };
+    return { absPath: abs };
+  } catch (err) {
+    return { error: `Path not accessible: ${abs} \u2014 ${err.message}` };
+  }
+}
+async function promptForSource(rl) {
+  while (true) {
+    console.log(c.head("[1/2] Webapp source"));
+    console.log(c.label("  Paste a path. Accepts either:"));
+    console.log(c.label("    - a directory  (will run the extractor live)"));
+    console.log(c.label("    - a JSON file  (will use directly, must be extractor-shaped)"));
+    const raw = await rl.question(`  ${c.value(">")} `);
+    const resolved = await resolveSourcePath(cleanPath(raw));
+    if ("error" in resolved) {
+      console.log(c.err(`  ${resolved.error}
+`));
+      continue;
+    }
+    return resolved;
+  }
+}
+async function promptForResource(rl) {
+  while (true) {
+    console.log("");
+    console.log(c.head("[2/2] Resource file"));
+    console.log(c.label("  Paste a JSON file path (flat or language-wrapped):"));
+    const raw = await rl.question(`  ${c.value(">")} `);
+    const resolved = await resolveResourcePath(cleanPath(raw));
+    if ("error" in resolved) {
+      console.log(c.err(`  ${resolved.error}
+`));
+      continue;
+    }
+    return resolved.absPath;
+  }
+}
+async function loadKeyMap(filePath, sourceLabel) {
+  const text = await fs2.readFile(filePath, "utf8");
+  const json = JSON.parse(text);
+  if (json === null || typeof json !== "object" || Array.isArray(json)) {
+    throw new Error(`${sourceLabel}: expected a JSON object at the top level`);
+  }
+  const topKeys = Object.keys(json);
+  const wasLangWrapped = topKeys.length > 0 && topKeys.every((k) => typeof json[k] === "object" && json[k] !== null);
+  let flat;
+  let pickedLang = null;
+  if (wasLangWrapped) {
+    if (!(TARGET_LANG in json)) {
+      throw new Error(
+        `${sourceLabel}: language-wrapped JSON has no "${TARGET_LANG}" entry (available: ${topKeys.join(", ")})`
+      );
+    }
+    flat = json[TARGET_LANG];
+    pickedLang = TARGET_LANG;
+  } else {
+    flat = json;
+  }
+  const raw = {};
+  const emptyValueKeys = [];
+  for (const [k, v] of Object.entries(flat)) {
+    if (typeof v !== "string") continue;
+    if (v === "") emptyValueKeys.push(k);
+    raw[k] = v;
+  }
+  return {
+    raw,
+    emptyValueKeys,
+    pickedLang,
+    wasLangWrapped,
+    availableLangs: wasLangWrapped ? topKeys : []
+  };
+}
+async function main2() {
+  const startedAt = /* @__PURE__ */ new Date();
+  const timestamp = formatTimestamp(startedAt);
+  const runDir = path2.resolve(DIFF_OUTPUT_DIR, timestamp);
+  await fs2.mkdir(runDir, { recursive: true });
+  const logAbs = path2.join(runDir, `${timestamp}_translation_diff.log`);
+  const missingInResourcePath = path2.join(runDir, "missing_in_resource.json");
+  const missingInExtractorPath = path2.join(runDir, "missing_in_extractor.json");
+  const stream = createWriteStream2(logAbs, { flags: "a" });
+  const logTee = setupLogTee(stream);
+  const tag = c.head("[translation-diff]");
+  console.log(`${tag} run started ${c.label(startedAt.toISOString())}`);
+  console.log(`${tag} output ${c.path(runDir)}`);
+  console.log("");
+  const cli = parseDiffArgs(process.argv.slice(2));
+  let source;
+  let resourcePath;
+  if (cli.src && cli.resource) {
+    const srcResolved = await resolveSourcePath(cleanPath(cli.src));
+    if ("error" in srcResolved) throw new Error(`--src: ${srcResolved.error}`);
+    source = srcResolved;
+    const resResolved = await resolveResourcePath(cleanPath(cli.resource));
+    if ("error" in resResolved) throw new Error(`--resource: ${resResolved.error}`);
+    resourcePath = resResolved.absPath;
+  } else {
+    const rl = createInterface({ input, output });
+    try {
+      if (cli.src) {
+        const srcResolved = await resolveSourcePath(cleanPath(cli.src));
+        if ("error" in srcResolved) throw new Error(`--src: ${srcResolved.error}`);
+        source = srcResolved;
+      } else {
+        source = await promptForSource(rl);
+      }
+      if (cli.resource) {
+        const resResolved = await resolveResourcePath(cleanPath(cli.resource));
+        if ("error" in resResolved) throw new Error(`--resource: ${resResolved.error}`);
+        resourcePath = resResolved.absPath;
+      } else {
+        resourcePath = await promptForResource(rl);
+      }
+    } finally {
+      rl.close();
+    }
+  }
+  console.log("");
+  logTee.dual(
+    `${c.head("[translation-diff]")} source=${c.path(source.absPath)} (${source.kind})`,
+    `[translation-diff] source=${source.absPath} (${source.kind})`
+  );
+  logTee.dual(
+    `${c.head("[translation-diff]")} resource=${c.path(resourcePath)}`,
+    `[translation-diff] resource=${resourcePath}`
+  );
+  let extractorRaw;
+  let extractorConflicts = 0;
+  let extractorEmptyKeys = [];
+  if (source.kind === "json") {
+    console.log(`${c.label("Loading extractor JSON:")} ${c.path(source.absPath)}`);
+    const loaded = await loadKeyMap(source.absPath, "extractor JSON");
+    extractorRaw = loaded.raw;
+    extractorEmptyKeys = loaded.emptyValueKeys;
+    if (loaded.wasLangWrapped && loaded.pickedLang) {
+      console.log(`${c.label("  picked lang:")} ${c.value(loaded.pickedLang)}`);
+    }
+  } else {
+    console.log(`${c.label("Running extractor on:")} ${c.path(source.absPath)}`);
+    const result = await runExtraction({ src: source.absPath });
+    extractorRaw = {};
+    for (const [k, v] of result.entries) extractorRaw[k] = v;
+    extractorConflicts = result.conflicts.length;
+    console.log(
+      `  ${c.label("scanned")} ${c.value(result.scannedFiles)} ${c.label("files,")} ${c.label("parsed")} ${c.value(result.parsedFiles)}${c.label(",")} ${c.value(result.keys)} ${c.label("keys (")}${result.conflicts.length > 0 ? c.warn(result.conflicts.length) : c.ok(result.conflicts.length)} ${c.label("conflicts)")}`
+    );
+  }
+  console.log("");
+  console.log(`${c.label("Loading resource:")} ${c.path(resourcePath)}`);
+  const resource = await loadKeyMap(resourcePath, "resource file");
+  if (resource.wasLangWrapped) {
+    console.log(
+      `  ${c.label("picked lang:")} ${c.value(resource.pickedLang ?? "?")}  ${c.label("(available:")} ${resource.availableLangs.map((l) => l === resource.pickedLang ? c.value(l) : c.label(l)).join(c.label(", "))}${c.label(")")}`
+    );
+  } else {
+    console.log(`  ${c.label("flat (no language wrapper)")}`);
+  }
+  console.log(`  ${c.label("keys in resource[")}${c.value(TARGET_LANG)}${c.label("]:")} ${c.value(Object.keys(resource.raw).length)}`);
+  console.log("");
+  const extractorKeys = Object.keys(extractorRaw);
+  const dynamicKeys = extractorKeys.filter((k) => extractorRaw[k] === DYNAMIC);
+  const extractorPresent = /* @__PURE__ */ new Set();
+  for (const k of extractorKeys) {
+    const v = extractorRaw[k];
+    if (v === DYNAMIC) continue;
+    if (v === "") continue;
+    extractorPresent.add(k);
+  }
+  const resourcePresent = /* @__PURE__ */ new Set();
+  for (const [k, v] of Object.entries(resource.raw)) {
+    if (v === "") continue;
+    resourcePresent.add(k);
+  }
+  const missingInResource = {};
+  for (const k of extractorPresent) {
+    if (!resourcePresent.has(k)) missingInResource[k] = extractorRaw[k];
+  }
+  const missingInExtractor = {};
+  for (const k of resourcePresent) {
+    if (!extractorPresent.has(k)) missingInExtractor[k] = resource.raw[k];
+  }
+  if (resource.emptyValueKeys.length > 0) {
+    console.log(
+      `${c.warn("Empty-value keys in resource")} ${c.label("(treated as missing):")} ${c.value(resource.emptyValueKeys.length)}`
+    );
+    for (const k of resource.emptyValueKeys.sort()) {
+      console.log(`  ${c.label("-")} ${k}`);
+    }
+    console.log("");
+  }
+  if (extractorEmptyKeys.length > 0) {
+    console.log(
+      `${c.warn("Empty-value keys in extractor JSON")} ${c.label("(treated as missing):")} ${c.value(extractorEmptyKeys.length)}`
+    );
+    for (const k of extractorEmptyKeys.sort()) {
+      console.log(`  ${c.label("-")} ${k}`);
+    }
+    console.log("");
+  }
+  if (dynamicKeys.length > 0) {
+    console.log(
+      `${c.label("Skipped from comparison \u2014")} ${c.warn("__dynamic__")} ${c.label("keys in extractor:")} ${c.value(dynamicKeys.length)}`
+    );
+  }
+  const sortedObject = (m) => {
+    const out = {};
+    for (const k of Object.keys(m).sort()) out[k] = m[k];
+    return out;
+  };
+  const wrap2 = (m) => ({ [TARGET_LANG]: sortedObject(m) });
+  await fs2.writeFile(missingInResourcePath, JSON.stringify(wrap2(missingInResource), null, 2) + "\n", "utf8");
+  await fs2.writeFile(missingInExtractorPath, JSON.stringify(wrap2(missingInExtractor), null, 2) + "\n", "utf8");
+  const labels = ["Extractor keys", "Resource keys", "Dynamic skipped", "Missing in resource", "Missing in extractor", "Output dir"];
+  const pad = Math.max(...labels.map((l) => l.length));
+  const stat = (label, value) => `${c.label(label.padEnd(pad) + " :")} ${value}`;
+  console.log("");
+  console.log(stat("Extractor keys", c.value(extractorKeys.length)));
+  console.log(stat("Resource keys", c.value(Object.keys(resource.raw).length)));
+  if (extractorConflicts > 0) {
+    console.log(stat("Extractor conflicts", c.warn(extractorConflicts)));
+  }
+  console.log(stat("Dynamic skipped", c.value(dynamicKeys.length)));
+  console.log(
+    stat(
+      "Missing in resource",
+      `${Object.keys(missingInResource).length > 0 ? c.warn(Object.keys(missingInResource).length) : c.ok(0)}  ${c.label("(in extractor, not in resource)")}`
+    )
+  );
+  console.log(
+    stat(
+      "Missing in extractor",
+      `${Object.keys(missingInExtractor).length > 0 ? c.warn(Object.keys(missingInExtractor).length) : c.ok(0)}  ${c.label("(in resource, not in extractor)")}`
+    )
+  );
+  console.log(stat("Output dir", c.path(path2.relative(process.cwd(), runDir))));
+  console.log(`  ${c.label("\u251C\u2500")} ${c.path("missing_in_resource.json")}`);
+  console.log(`  ${c.label("\u251C\u2500")} ${c.path("missing_in_extractor.json")}`);
+  console.log(`  ${c.label("\u2514\u2500")} ${c.path(path2.basename(logAbs))}`);
+  await logTee.teardown();
+}
+async function runCommand2(_argv) {
+  try {
+    await main2();
+  } catch (err) {
+    console.error(`${ansi.red}${ansi.bold}[fatal]${ansi.reset}`, err);
+    process.exit(1);
+  }
+}
+
+// src/translate.ts
+import fs3 from "fs/promises";
+import { createWriteStream as createWriteStream3 } from "fs";
+import path3 from "path";
+import { fileURLToPath } from "url";
+import { checkbox, select, input as inquirerInput, Separator } from "@inquirer/prompts";
+
+// src/lib/ui.ts
+for (const stream of [process.stdout, process.stderr]) {
+  const handle = stream._handle;
+  if (handle && typeof handle.setBlocking === "function") {
+    handle.setBlocking(true);
+  }
+}
+var NO_COLOR = Boolean(process.env.NO_COLOR) || !process.stdout.isTTY;
+var wrap = (code) => (s) => NO_COLOR ? String(s) : `\x1B[${code}m${s}\x1B[0m`;
+var C = {
+  bold: wrap("1"),
+  dim: wrap("2"),
+  red: wrap("31"),
+  green: wrap("32"),
+  yellow: wrap("33"),
+  blue: wrap("34"),
+  magenta: wrap("35"),
+  cyan: wrap("36"),
+  gray: wrap("90"),
+  cyanBold: wrap("1;36"),
+  greenBold: wrap("1;32"),
+  yellowBold: wrap("1;33"),
+  redBold: wrap("1;31")
+};
+var CLR_LINE = "\r\x1B[2K";
+function rule(width = 56) {
+  return C.gray("\u2500".repeat(width));
+}
+function fmtMs(ms) {
+  if (ms === void 0) return C.dim("\u2014");
+  if (ms < 1e3) return `${ms.toFixed(0)}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  const m = Math.floor(ms / 6e4);
+  const s = Math.floor(ms % 6e4 / 1e3);
+  return `${m}m${s.toString().padStart(2, "0")}s`;
+}
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var Spinner = class {
+  timer = null;
+  frameI = 0;
+  t0 = 0;
+  text = "";
+  running = false;
+  start(text) {
+    this.stop();
+    this.text = text;
+    this.t0 = Date.now();
+    this.frameI = 0;
+    this.running = true;
+    this.render();
+    this.timer = setInterval(() => this.render(), 80);
+  }
+  update(text) {
+    this.text = text;
+    if (this.running) this.render();
+  }
+  render() {
+    const elapsed = ((Date.now() - this.t0) / 1e3).toFixed(1);
+    const frame = SPINNER_FRAMES[this.frameI] ?? "\xB7";
+    this.frameI = (this.frameI + 1) % SPINNER_FRAMES.length;
+    process.stdout.write(`${CLR_LINE}${C.cyan(frame)} ${this.text} ${C.dim(`(${elapsed}s)`)}`);
+  }
+  succeed(text) {
+    const elapsedMs = Date.now() - this.t0;
+    const elapsed = (elapsedMs / 1e3).toFixed(1);
+    this.stop();
+    process.stdout.write(`${CLR_LINE}${C.green("\u2713")} ${text} ${C.dim(`(${elapsed}s)`)}
+`);
+    return elapsedMs;
+  }
+  fail(text) {
+    const elapsed = ((Date.now() - this.t0) / 1e3).toFixed(1);
+    this.stop();
+    process.stdout.write(`${CLR_LINE}${C.red("\u2717")} ${text} ${C.dim(`(${elapsed}s)`)}
+`);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.running) {
+      process.stdout.write(CLR_LINE);
+      this.running = false;
+    }
+  }
+};
+var StatusFooter = class {
+  timer = null;
+  text = "";
+  visible = false;
+  getText = null;
+  write(text, transform) {
+    if (this.visible) {
+      process.stdout.write(CLR_LINE);
+      this.visible = false;
+    }
+    process.stdout.write(transform ? transform(text) : text);
+    if (text.endsWith("\n")) this.draw();
+  }
+  setProvider(fn) {
+    this.getText = fn;
+  }
+  startTicker(intervalMs) {
+    this.stopTicker();
+    this.timer = setInterval(() => this.tick(), intervalMs);
+  }
+  stopTicker() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  tick() {
+    if (!this.getText) return;
+    const next = this.getText();
+    if (next === this.text && this.visible) return;
+    this.text = next;
+    if (this.visible) process.stdout.write(`${CLR_LINE}${next}`);
+  }
+  draw() {
+    if (!this.getText) return;
+    this.text = this.getText();
+    process.stdout.write(this.text);
+    this.visible = true;
+  }
+  clear() {
+    if (this.visible) {
+      process.stdout.write(CLR_LINE);
+      this.visible = false;
+    }
+  }
+  dispose() {
+    this.stopTicker();
+    this.clear();
+    this.getText = null;
+    this.text = "";
+  }
+};
+var JsonPretty = class {
+  started = false;
+  depth = 0;
+  inString = false;
+  escape = false;
+  indent = "  ";
+  transform(text) {
+    let out = "";
+    for (let i = 0; i < text.length; i++) {
+      const ch = text[i];
+      if (!this.started) {
+        if (ch === "{" || ch === "[") {
+          this.started = true;
+          this.depth = 1;
+          out += ch + "\n" + this.indent.repeat(this.depth);
+        }
+        continue;
+      }
+      if (this.inString) {
+        out += ch;
+        if (this.escape) {
+          this.escape = false;
+        } else if (ch === "\\") {
+          this.escape = true;
+        } else if (ch === '"') {
+          this.inString = false;
+        }
+        continue;
+      }
+      switch (ch) {
+        case '"':
+          this.inString = true;
+          out += ch;
+          break;
+        case "{":
+        case "[":
+          this.depth++;
+          out += ch + "\n" + this.indent.repeat(this.depth);
+          break;
+        case "}":
+        case "]":
+          this.depth = Math.max(0, this.depth - 1);
+          out += "\n" + this.indent.repeat(this.depth) + ch;
+          break;
+        case ",":
+          out += ",\n" + this.indent.repeat(this.depth);
+          break;
+        case ":":
+          out += ": ";
+          break;
+        case " ":
+        case "	":
+        case "\n":
+        case "\r":
+          break;
+        default:
+          out += ch;
+      }
+    }
+    return out;
+  }
+};
+async function multilineInput(opts = {}) {
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  if (!stdin.isTTY || !stdout.isTTY) {
+    throw new Error("multilineInput requires an interactive TTY.");
+  }
+  const W = opts.width ?? 64;
+  const horiz = "\u2500".repeat(W - 2);
+  const top = `\u256D${horiz}\u256E`;
+  const bot = `\u2570${horiz}\u256F`;
+  const title = opts.title ?? "Type or paste content";
+  const hints = opts.hints ?? [
+    "Press Enter to submit \xB7 Shift+Enter for a new line",
+    "Right-click or Ctrl+Shift+V to paste (newlines preserved)",
+    "Press Ctrl+C to cancel"
+  ];
+  stdout.write(`
+  ${C.cyan(top)}
+`);
+  stdout.write(`  ${C.cyan("\u2502")} ${C.bold(title)}
+`);
+  for (const h of hints) {
+    stdout.write(`  ${C.cyan("\u2502")} ${C.dim("\u2022 " + h)}
+`);
+  }
+  stdout.write(`  ${C.cyan(bot)}
+
+`);
+  const INDENT = "  ";
+  const PREFIX_DISPLAY = C.cyan("\u258F") + " ";
+  const PREFIX_LEN = 2;
+  return new Promise((resolve, reject) => {
+    const wasRaw = stdin.isRaw === true;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    stdout.write("\x1B[>4;2m");
+    stdout.write("\x1B[?2004h");
+    let buffer = "";
+    let cursorPos = 0;
+    let pasting = false;
+    let cursorRow = 0;
+    let closed = false;
+    const cols = () => Math.max(20, stdout.columns ?? 80);
+    const dispRows = (visibleChars) => {
+      if (visibleChars === 0) return 1;
+      return Math.max(1, Math.ceil(visibleChars / cols()));
+    };
+    const cleanup = () => {
+      if (closed) return;
+      closed = true;
+      stdout.write("\x1B[?2004l");
+      stdout.write("\x1B[>4;0m");
+      try {
+        stdin.setRawMode(wasRaw);
+      } catch {
+      }
+      stdin.removeListener("data", onData);
+      stdin.pause();
+    };
+    const render = (final) => {
+      if (cursorRow > 0) stdout.write(`\x1B[${cursorRow}A`);
+      stdout.write("\r\x1B[0J");
+      const lines = buffer.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        stdout.write(`${INDENT}${PREFIX_DISPLAY}${lines[i]}`);
+        if (i < lines.length - 1) stdout.write("\n");
+      }
+      if (final) {
+        stdout.write("\n");
+        cursorRow = 0;
+        return;
+      }
+      stdout.write("\n");
+      const nLines = lines.length;
+      const nChars = buffer.length;
+      const statsRaw = `${nLines} line${nLines === 1 ? "" : "s"} \xB7 ${nChars} char${nChars === 1 ? "" : "s"}  \xB7 Enter=submit \xB7 Shift+Enter=newline \xB7 Ctrl+C=cancel`;
+      const maxStats = Math.max(20, cols() - INDENT.length - 1);
+      const statsVisible = statsRaw.length > maxStats ? statsRaw.slice(0, maxStats - 1) + "\u2026" : statsRaw;
+      stdout.write(`${INDENT}${C.dim(statsVisible)}`);
+      let totalRows = 0;
+      for (const ln of lines) totalRows += dispRows(INDENT.length + PREFIX_LEN + ln.length);
+      const statsRows = dispRows(INDENT.length + statsVisible.length);
+      totalRows += statsRows;
+      let pos = 0;
+      let targetLine = 0;
+      let targetCol = 0;
+      let found = false;
+      for (let i = 0; i < lines.length; i++) {
+        const len = lines[i].length;
+        if (cursorPos <= pos + len) {
+          targetLine = i;
+          targetCol = cursorPos - pos;
+          found = true;
+          break;
+        }
+        pos += len + 1;
+      }
+      if (!found) {
+        targetLine = lines.length - 1;
+        targetCol = lines[targetLine].length;
+      }
+      let rowsAbove = 0;
+      for (let i = 0; i < targetLine; i++) {
+        rowsAbove += dispRows(INDENT.length + PREFIX_LEN + lines[i].length);
+      }
+      const absInLine = INDENT.length + PREFIX_LEN + targetCol;
+      const c2 = cols();
+      const wrapRow = Math.floor(absInLine / c2);
+      const wrapCol = absInLine % c2;
+      const targetRowFromTop = rowsAbove + wrapRow;
+      const currentRowFromTop = totalRows - 1;
+      const up = currentRowFromTop - targetRowFromTop;
+      if (up > 0) stdout.write(`\x1B[${up}A`);
+      else if (up < 0) stdout.write(`\x1B[${-up}B`);
+      stdout.write(`\r\x1B[${wrapCol + 1}G`);
+      cursorRow = targetRowFromTop;
+    };
+    const submit = () => {
+      render(true);
+      cleanup();
+      resolve(buffer);
+    };
+    const cancel = () => {
+      render(true);
+      cleanup();
+      reject(new Error("Input cancelled."));
+    };
+    const insertText = (s) => {
+      if (!s) return;
+      buffer = buffer.slice(0, cursorPos) + s + buffer.slice(cursorPos);
+      cursorPos += s.length;
+    };
+    const normalizePasted = (s) => s.replace(/\r\n|\r/g, "\n");
+    const onData = (data) => {
+      let s = data;
+      while (s.length > 0) {
+        if (pasting) {
+          const end = s.indexOf("\x1B[201~");
+          if (end === -1) {
+            insertText(normalizePasted(s));
+            s = "";
+          } else {
+            insertText(normalizePasted(s.slice(0, end)));
+            pasting = false;
+            s = s.slice(end + 6);
+          }
+          continue;
+        }
+        if (s.startsWith("\x1B[200~")) {
+          pasting = true;
+          s = s.slice(6);
+          continue;
+        }
+        if (s.startsWith("\x1B[27;2;13~")) {
+          insertText("\n");
+          s = s.slice(10);
+          continue;
+        }
+        if (s.startsWith("\x1B[13;2u")) {
+          insertText("\n");
+          s = s.slice(7);
+          continue;
+        }
+        const ch = s[0];
+        if (ch === "\r" || ch === "\n") {
+          submit();
+          return;
+        }
+        if (ch === "") {
+          cancel();
+          return;
+        }
+        if (ch === "") {
+          submit();
+          return;
+        }
+        if (ch === "\x7F" || ch === "\b") {
+          if (cursorPos > 0) {
+            buffer = buffer.slice(0, cursorPos - 1) + buffer.slice(cursorPos);
+            cursorPos--;
+          }
+          s = s.slice(1);
+          continue;
+        }
+        if (ch === "") {
+          const lineStart = buffer.lastIndexOf("\n", cursorPos - 1) + 1;
+          buffer = buffer.slice(0, lineStart) + buffer.slice(cursorPos);
+          cursorPos = lineStart;
+          s = s.slice(1);
+          continue;
+        }
+        if (ch === "\v") {
+          const lineEnd = buffer.indexOf("\n", cursorPos);
+          const e = lineEnd === -1 ? buffer.length : lineEnd;
+          buffer = buffer.slice(0, cursorPos) + buffer.slice(e);
+          s = s.slice(1);
+          continue;
+        }
+        if (s.startsWith("\x1B[D")) {
+          if (cursorPos > 0) cursorPos--;
+          s = s.slice(3);
+          continue;
+        }
+        if (s.startsWith("\x1B[C")) {
+          if (cursorPos < buffer.length) cursorPos++;
+          s = s.slice(3);
+          continue;
+        }
+        if (s.startsWith("\x1B[A")) {
+          const curStart = buffer.lastIndexOf("\n", cursorPos - 1) + 1;
+          if (curStart === 0) {
+            cursorPos = 0;
+          } else {
+            const col = cursorPos - curStart;
+            const prevNl = curStart - 1;
+            const prevStart = buffer.lastIndexOf("\n", prevNl - 1) + 1;
+            const prevLen = prevNl - prevStart;
+            cursorPos = prevStart + Math.min(col, prevLen);
+          }
+          s = s.slice(3);
+          continue;
+        }
+        if (s.startsWith("\x1B[B")) {
+          const curStart = buffer.lastIndexOf("\n", cursorPos - 1) + 1;
+          const curEnd = buffer.indexOf("\n", cursorPos);
+          if (curEnd === -1) {
+            cursorPos = buffer.length;
+          } else {
+            const col = cursorPos - curStart;
+            const nextStart = curEnd + 1;
+            const nextEnd = buffer.indexOf("\n", nextStart);
+            const nextLen = (nextEnd === -1 ? buffer.length : nextEnd) - nextStart;
+            cursorPos = nextStart + Math.min(col, nextLen);
+          }
+          s = s.slice(3);
+          continue;
+        }
+        if (s.startsWith("\x1B[H") || s.startsWith("\x1B[1~") || s.startsWith("\x1B[7~")) {
+          cursorPos = buffer.lastIndexOf("\n", cursorPos - 1) + 1;
+          s = s.slice(s.startsWith("\x1B[H") ? 3 : 4);
+          continue;
+        }
+        if (s.startsWith("\x1B[F") || s.startsWith("\x1B[4~") || s.startsWith("\x1B[8~")) {
+          const eol = buffer.indexOf("\n", cursorPos);
+          cursorPos = eol === -1 ? buffer.length : eol;
+          s = s.slice(s.startsWith("\x1B[F") ? 3 : 4);
+          continue;
+        }
+        if (ch === "\x1B") {
+          let i = 1;
+          if (s[1] === "[") {
+            i = 2;
+            while (i < s.length && /[\x30-\x3f]/.test(s[i])) i++;
+            while (i < s.length && /[\x20-\x2f]/.test(s[i])) i++;
+            if (i < s.length && /[\x40-\x7e]/.test(s[i])) i++;
+          } else if (s[1] === "O" && s.length >= 3) {
+            i = 3;
+          } else {
+            i = 2;
+          }
+          s = s.slice(i);
+          continue;
+        }
+        let n = 0;
+        while (n < s.length) {
+          const code = s.charCodeAt(n);
+          if (code < 32 && code !== 9) break;
+          if (code === 127) break;
+          if (s[n] === "\x1B") break;
+          n++;
+        }
+        if (n > 0) {
+          insertText(s.slice(0, n));
+          s = s.slice(n);
+          continue;
+        }
+        s = s.slice(1);
+      }
+      render(false);
+    };
+    stdin.on("data", onData);
+    render(false);
+  });
+}
+function formatError(e) {
+  if (!(e instanceof Error)) return String(e);
+  const parts = [`${C.red("\u2717 " + e.name)}: ${e.message}`];
+  let cause = e.cause;
+  while (cause) {
+    if (cause instanceof Error) {
+      const code = cause.code;
+      parts.push(C.dim(`  cause: ${cause.name}: ${cause.message}${code ? ` (code=${code})` : ""}`));
+      cause = cause.cause;
+    } else {
+      parts.push(C.dim(`  cause: ${String(cause)}`));
+      break;
+    }
+  }
+  return parts.join("\n");
+}
+
+// src/translate.ts
+var SCRIPT_DIR = path3.dirname(fileURLToPath(import.meta.url));
+var PROJECT_ROOT = path3.resolve(SCRIPT_DIR, "..");
+var PROMPT_PATH = path3.resolve(PROJECT_ROOT, "prompt/translation-prompt.md");
+var LANGUAGES_JSON_PATH = path3.resolve(PROJECT_ROOT, "data/languages.json");
+var DIFF_OUTPUT_DIR2 = path3.resolve(PROJECT_ROOT, "diff-output");
+var TRANSLATE_OUTPUT_DIR = path3.resolve(PROJECT_ROOT, "translate-output");
+var PLACEHOLDER_CONTENT = "PASTE CONTENT HERE";
+var PLACEHOLDER_LANGS = "LANGUAGES TO PRODUCE";
+var SOURCE_LANG = "en";
+var OLLAMA_URL = (process.env.OLLAMA_URL ?? "http://172.25.80.1:11434").replace(/\/$/, "");
+var OLLAMA_TIMEOUT_MS = Number(process.env.OLLAMA_TIMEOUT_MS ?? 30 * 6e4);
+function parseEnglishKeyMap(text, sourceLabel) {
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch (err) {
+    throw new Error(`${sourceLabel}: invalid JSON \u2014 ${err.message}`);
+  }
+  if (json === null || typeof json !== "object" || Array.isArray(json)) {
+    throw new Error(`${sourceLabel}: expected a JSON object at the top level`);
+  }
+  const topKeys = Object.keys(json);
+  const obj = json;
+  const wrapped = topKeys.length > 0 && topKeys.every((k) => typeof obj[k] === "object" && obj[k] !== null);
+  let flat;
+  if (wrapped) {
+    if (!(SOURCE_LANG in obj)) {
+      throw new Error(
+        `${sourceLabel}: language-wrapped JSON has no "${SOURCE_LANG}" entry (available: ${topKeys.join(", ")})`
+      );
+    }
+    flat = obj[SOURCE_LANG];
+  } else {
+    flat = obj;
+  }
+  const result = {};
+  for (const [k, v] of Object.entries(flat)) {
+    if (typeof v !== "string") continue;
+    result[k] = v;
+  }
+  if (Object.keys(result).length === 0) {
+    throw new Error(`${sourceLabel}: no string-valued keys found`);
+  }
+  return result;
+}
+function cleanPath2(raw) {
+  let s = raw.trim();
+  if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'") || s.startsWith("`") && s.endsWith("`")) {
+    s = s.slice(1, -1);
+  }
+  return s;
+}
+async function findRecentDiffOutputs(max = 5) {
+  let dirEntries = [];
+  try {
+    dirEntries = await fs3.readdir(DIFF_OUTPUT_DIR2);
+  } catch {
+    return [];
+  }
+  const candidates = [];
+  for (const dirName of dirEntries) {
+    const filePath = path3.join(DIFF_OUTPUT_DIR2, dirName, "missing_in_resource.json");
+    try {
+      const st = await fs3.stat(filePath);
+      if (!st.isFile()) continue;
+      const text = await fs3.readFile(filePath, "utf8");
+      const json = JSON.parse(text);
+      const enSlice = json[SOURCE_LANG] ?? json;
+      const keyCount = typeof enSlice === "object" && enSlice !== null ? Object.keys(enSlice).length : 0;
+      candidates.push({ abs: filePath, mtimeMs: st.mtimeMs, keyCount });
+    } catch {
+    }
+  }
+  candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return candidates.slice(0, max).map((it) => ({
+    absPath: it.abs,
+    relPath: path3.relative(process.cwd(), it.abs),
+    mtimeMs: it.mtimeMs,
+    keyCount: it.keyCount,
+    ageLabel: humanAge(Date.now() - it.mtimeMs)
+  }));
+}
+function humanAge(ms) {
+  const s = Math.floor(ms / 1e3);
+  if (s < 60) return `${s}s ago`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ago`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h ago`;
+  const d = Math.floor(h / 24);
+  return `${d}d ago`;
+}
+async function loadLanguages() {
+  const text = await fs3.readFile(LANGUAGES_JSON_PATH, "utf8");
+  const arr = JSON.parse(text);
+  return arr.filter((l) => l && l.active && l.code);
+}
+async function promptTargetLanguages(allLangs) {
+  const source = allLangs.find((l) => l.code === SOURCE_LANG);
+  const targets = allLangs.filter((l) => l.code !== SOURCE_LANG);
+  const ordered = source ? [source, ...targets] : targets;
+  const idxWidth = String(ordered.length).length;
+  const selected = await checkbox({
+    message: `Select target languages (${targets.length} available, ${SOURCE_LANG} is the source \u2014 space to toggle, enter to submit):`,
+    pageSize: 25,
+    loop: false,
+    required: true,
+    choices: ordered.map((l, i) => {
+      const isSource = l.code === SOURCE_LANG;
+      const native = l.nativeName && l.nativeName !== l.name ? `  (${l.nativeName})` : "";
+      const suffix = isSource ? `  ${C.dim("\u2190 source, always in output")}` : "";
+      return {
+        name: `${String(i + 1).padStart(idxWidth)}.  ${l.code.padEnd(8)} ${l.name}${native}${suffix}`,
+        value: l.code,
+        short: l.code,
+        checked: isSource,
+        disabled: isSource ? "(source \u2014 always included)" : false
+      };
+    })
+  });
+  const codeSet = new Set(selected);
+  return targets.filter((l) => codeSet.has(l.code));
+}
+async function fetchModels(spinner) {
+  spinner.start(`Fetching available models from ${C.dim(OLLAMA_URL)}`);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 15e3);
+  try {
+    const res = await fetch(`${OLLAMA_URL}/api/tags`, { signal: controller.signal });
+    if (!res.ok) {
+      spinner.fail(`Ollama returned HTTP ${res.status}`);
+      throw new Error(`Ollama /api/tags HTTP ${res.status} ${res.statusText}`);
+    }
+    const json = await res.json();
+    const names = (json.models ?? []).map((m) => m.name).filter(Boolean);
+    if (names.length === 0) {
+      spinner.fail("No models available on Ollama");
+      throw new Error(`No models found at ${OLLAMA_URL}. Pull a model first (e.g. \`ollama pull llama3.2\`).`);
+    }
+    spinner.succeed(`Found ${C.bold(String(names.length))} model(s)`);
+    return names;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function promptModel(models) {
+  return select({
+    message: "Select a model:",
+    pageSize: Math.min(15, models.length),
+    loop: false,
+    choices: models.map((name) => ({ name, value: name }))
+  });
+}
+async function promptInput(recents) {
+  const choices = [];
+  if (recents.length > 0) {
+    choices.push(new Separator(c.label("  Recent missing_in_resource.json files:")));
+    for (const r of recents) {
+      choices.push({
+        name: `${r.relPath}  ${C.dim(`(${r.keyCount} keys, ${r.ageLabel})`)}`,
+        value: { kind: "recent", value: r.absPath, file: r },
+        short: r.relPath
+      });
+    }
+    choices.push(new Separator(c.label("  Other options:")));
+  }
+  choices.push({
+    name: "Paste a JSON file path",
+    value: { kind: "mode", value: "path" },
+    short: "file path"
+  });
+  choices.push({
+    name: "Paste content inline (multi-line)",
+    value: { kind: "mode", value: "paste" },
+    short: "inline paste"
+  });
+  const pick = await select({
+    message: "Input source:",
+    pageSize: Math.min(20, choices.length),
+    loop: false,
+    choices
+  });
+  if (pick.kind === "recent") {
+    const text = await fs3.readFile(pick.file.absPath, "utf8");
+    return {
+      sourceLabel: pick.file.absPath,
+      keyMap: parseEnglishKeyMap(text, pick.file.absPath)
+    };
+  }
+  if (pick.value === "path") {
+    while (true) {
+      const raw = await inquirerInput({
+        message: "Paste a JSON file path:",
+        validate: (v) => v.trim().length > 0 ? true : "Path required"
+      });
+      const p = path3.resolve(cleanPath2(raw));
+      try {
+        const st = await fs3.stat(p);
+        if (!st.isFile() || !p.toLowerCase().endsWith(".json")) {
+          console.log(c.err(`  Not a .json file: ${p}
+`));
+          continue;
+        }
+        const text = await fs3.readFile(p, "utf8");
+        return { sourceLabel: p, keyMap: parseEnglishKeyMap(text, p) };
+      } catch (err) {
+        console.log(c.err(`  ${err.message}
+`));
+      }
+    }
+  }
+  const pasted = await multilineInput({
+    title: "Paste JSON content (extractor-shape or flat)",
+    hints: [
+      "Press Enter to submit \xB7 Shift+Enter for a new line",
+      "Right-click or Ctrl+Shift+V to paste (newlines preserved)",
+      "Press Ctrl+C to cancel"
+    ]
+  });
+  return { sourceLabel: "<inline paste>", keyMap: parseEnglishKeyMap(pasted, "inline paste") };
+}
+async function callOllama(model, prompt, spinner) {
+  const url = `${OLLAMA_URL}/api/generate`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), OLLAMA_TIMEOUT_MS);
+  spinner.start(`Connecting to Ollama ${C.dim(`(${model} @ ${OLLAMA_URL})`)}`);
+  let response = "";
+  let thinking = "";
+  let connectMs = 0;
+  let thinkingMs = 0;
+  let responseMs = 0;
+  let responseTokens = 0;
+  let thinkingTokens = 0;
+  let metrics = {};
+  const footer = new StatusFooter();
+  const pretty = new JsonPretty();
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        model,
+        prompt,
+        stream: true,
+        format: "json",
+        think: true,
+        options: { temperature: 0.2 }
+      }),
+      signal: controller.signal
+    });
+    if (!res.ok) {
+      spinner.fail(`Ollama returned HTTP ${res.status}`);
+      throw new Error(`Ollama HTTP ${res.status} ${res.statusText}: ${await res.text()}`);
+    }
+    if (!res.body) throw new Error("Ollama response has no body");
+    const decoder = new TextDecoder("utf-8");
+    let buffer = "";
+    const state = {
+      mode: "idle",
+      modeStartT: 0,
+      connected: false
+    };
+    const renderStatus = () => {
+      const elapsed = (Date.now() - state.modeStartT) / 1e3;
+      const tokens = state.mode === "thinking" ? thinkingTokens : responseTokens;
+      const chars = state.mode === "thinking" ? thinking.length : response.length;
+      const rate = elapsed > 0 ? tokens / elapsed : 0;
+      const kb = (chars / 1024).toFixed(1);
+      return `${C.cyan("\u23F1")}  ${C.bold(elapsed.toFixed(1) + "s")}  ${C.gray("\u2502")}  ${C.bold(String(tokens))} tok  ${C.gray("\u2502")}  ${C.bold(rate.toFixed(1))} tok/s  ${C.gray("\u2502")}  ${C.bold(kb + "KB")}`;
+    };
+    const ensureConnected = () => {
+      if (state.connected) return;
+      connectMs = spinner.succeed("Connected");
+      process.stdout.write("\n");
+      state.connected = true;
+    };
+    const enterMode = (next) => {
+      if (state.mode === next) return;
+      ensureConnected();
+      footer.dispose();
+      if (state.mode === "thinking") {
+        thinkingMs = Date.now() - state.modeStartT;
+        process.stdout.write(
+          C.dim(`...done thinking. (${(thinkingMs / 1e3).toFixed(1)}s, ${thinkingTokens} tok)
+
+`)
+        );
+      }
+      if (next === "thinking") {
+        process.stdout.write(C.cyanBold("Thinking...\n"));
+        process.stdout.write(C.bold("Thinking Process:\n\n"));
+      } else {
+        process.stdout.write(C.greenBold("Response:\n"));
+      }
+      state.mode = next;
+      state.modeStartT = Date.now();
+      footer.setProvider(renderStatus);
+      footer.startTicker(150);
+    };
+    let done = false;
+    for await (const chunk of res.body) {
+      if (done) break;
+      buffer += decoder.decode(chunk, { stream: true });
+      let nl;
+      while ((nl = buffer.indexOf("\n")) !== -1) {
+        const line = buffer.slice(0, nl).trim();
+        buffer = buffer.slice(nl + 1);
+        if (!line) continue;
+        let evt;
+        try {
+          evt = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (evt.error) {
+          footer.dispose();
+          spinner.stop();
+          process.stdout.write("\n");
+          throw new Error(`Ollama error: ${evt.error}`);
+        }
+        if (evt.thinking) {
+          enterMode("thinking");
+          thinking += evt.thinking;
+          thinkingTokens++;
+          footer.write(evt.thinking, C.dim);
+        }
+        if (evt.response) {
+          enterMode("response");
+          response += evt.response;
+          responseTokens++;
+          footer.write(pretty.transform(evt.response));
+        }
+        if (evt.done) {
+          metrics = {
+            promptTokens: evt.prompt_eval_count,
+            evalTokens: evt.eval_count,
+            promptEvalMs: evt.prompt_eval_duration !== void 0 ? evt.prompt_eval_duration / 1e6 : void 0,
+            evalMs: evt.eval_duration !== void 0 ? evt.eval_duration / 1e6 : void 0,
+            loadMs: evt.load_duration !== void 0 ? evt.load_duration / 1e6 : void 0,
+            totalMs: evt.total_duration !== void 0 ? evt.total_duration / 1e6 : void 0
+          };
+          done = true;
+          break;
+        }
+      }
+    }
+    footer.dispose();
+    spinner.stop();
+    if (state.mode === "thinking") {
+      thinkingMs = Date.now() - state.modeStartT;
+      process.stdout.write(
+        C.dim(`
+...done thinking. (${(thinkingMs / 1e3).toFixed(1)}s, ${thinkingTokens} tok)
+`)
+      );
+    }
+    if (state.mode === "response") {
+      responseMs = Date.now() - state.modeStartT;
+      process.stdout.write("\n");
+    }
+    return { response, thinking, connectMs, thinkingMs, responseMs, metrics, responseTokens, thinkingTokens };
+  } finally {
+    clearTimeout(timer);
+    footer.dispose();
+    spinner.stop();
+  }
+}
+function extractJSON(text) {
+  const fence = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fence && fence[1]) return fence[1].trim();
+  const first = text.indexOf("{");
+  const last = text.lastIndexOf("}");
+  if (first !== -1 && last > first) return text.slice(first, last + 1);
+  return text.trim();
+}
+function renderPrompt(template, langs, keyMap) {
+  if (!template.includes(PLACEHOLDER_CONTENT) || !template.includes(PLACEHOLDER_LANGS)) {
+    throw new Error(
+      `Prompt template at ${PROMPT_PATH} must contain both "${PLACEHOLDER_CONTENT}" and "${PLACEHOLDER_LANGS}" placeholders.`
+    );
+  }
+  const langList = [
+    `- ${SOURCE_LANG} = English (source \u2014 copy values verbatim into the "en" object)`,
+    ...langs.map((l) => {
+      const native = l.nativeName && l.nativeName !== l.name ? ` (${l.nativeName})` : "";
+      return `- ${l.code} = ${l.name}${native}`;
+    })
+  ].join("\n");
+  const sourceJson = JSON.stringify({ [SOURCE_LANG]: keyMap }, null, 2);
+  return template.replace(PLACEHOLDER_LANGS, langList).replace(PLACEHOLDER_CONTENT, sourceJson);
+}
+function validateTranslation(parsed, expectedLangs, expectedKeys) {
+  const report = {
+    allLangsPresent: true,
+    missingLangs: [],
+    perLangMissingKeys: {},
+    perLangExtraKeys: {}
+  };
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { ...report, allLangsPresent: false, missingLangs: expectedLangs };
+  }
+  const obj = parsed;
+  const keySet = new Set(expectedKeys);
+  for (const lang of expectedLangs) {
+    const langObj = obj[lang];
+    if (!langObj || typeof langObj !== "object" || Array.isArray(langObj)) {
+      report.allLangsPresent = false;
+      report.missingLangs.push(lang);
+      continue;
+    }
+    const actualKeys = new Set(Object.keys(langObj));
+    const missing = [];
+    for (const k of expectedKeys) if (!actualKeys.has(k)) missing.push(k);
+    const extra = [];
+    for (const k of actualKeys) if (!keySet.has(k)) extra.push(k);
+    if (missing.length) report.perLangMissingKeys[lang] = missing;
+    if (extra.length) report.perLangExtraKeys[lang] = extra;
+  }
+  return report;
+}
+function sortedLangBundle(parsed, expectedLangs, expectedKeys) {
+  const sortedKeys = [...expectedKeys].sort();
+  const out = {};
+  for (const lang of expectedLangs) {
+    const langObj = parsed[lang] ?? {};
+    const sortedObj = {};
+    for (const k of sortedKeys) {
+      sortedObj[k] = typeof langObj[k] === "string" ? langObj[k] : "";
+    }
+    out[lang] = sortedObj;
+  }
+  return out;
+}
+function printHeader(args) {
+  process.stdout.write("\n");
+  process.stdout.write(`  ${C.cyanBold("Translation Generator")}
+`);
+  process.stdout.write(`  ${rule()}
+`);
+  process.stdout.write(`  ${C.dim("Model    :")} ${args.model} ${C.dim("@")} ${OLLAMA_URL}
+`);
+  process.stdout.write(`  ${C.dim("Input    :")} ${args.sourceLabel}
+`);
+  process.stdout.write(`  ${C.dim("Keys     :")} ${args.keyCount}
+`);
+  const langCodes = [SOURCE_LANG, ...args.langs.map((l) => l.code)].join(", ");
+  process.stdout.write(
+    `  ${C.dim("Languages:")} ${args.langs.length + 1} ${C.dim(`(${langCodes})`)}
+`
+  );
+  process.stdout.write(`  ${C.dim("Output   :")} ${args.outputDir}
+`);
+  process.stdout.write(`  ${rule()}
+
+`);
+}
+async function main3() {
+  const startedAt = /* @__PURE__ */ new Date();
+  const timestamp = formatTimestamp(startedAt);
+  const runDir = path3.join(TRANSLATE_OUTPUT_DIR, timestamp);
+  await fs3.mkdir(runDir, { recursive: true });
+  const outputPath = path3.join(runDir, "translation.json");
+  const logAbs = path3.join(runDir, `${timestamp}_translate.log`);
+  const stream = createWriteStream3(logAbs, { flags: "a" });
+  const logTee = setupLogTee(stream);
+  const tag = c.head("[translation-translate]");
+  console.log(`${tag} run started ${c.label(startedAt.toISOString())}`);
+  console.log(`${tag} output ${c.path(runDir)}`);
+  console.log("");
+  console.log(c.head("[Step 1/3] Input"));
+  const recents = await findRecentDiffOutputs(5);
+  const picked = await promptInput(recents);
+  console.log(
+    `  ${c.label("loaded")} ${c.value(Object.keys(picked.keyMap).length)} ${c.label("english keys from")} ${c.path(picked.sourceLabel)}`
+  );
+  console.log("");
+  console.log(c.head("[Step 2/3] Target languages"));
+  const allLangs = await loadLanguages();
+  const selectedLangs = await promptTargetLanguages(allLangs);
+  console.log(
+    `  ${c.label("targets:")} ${selectedLangs.map((l) => c.value(l.code)).join(c.label(", "))} ${c.label(`(${selectedLangs.length} languages)`)}`
+  );
+  console.log("");
+  console.log(c.head("[Step 3/3] Model"));
+  const modelSpinner = new Spinner();
+  const models = await fetchModels(modelSpinner);
+  const model = await promptModel(models);
+  console.log(`  ${c.label("model:")} ${c.value(model)}`);
+  console.log("");
+  printHeader({
+    model,
+    sourceLabel: picked.sourceLabel,
+    keyCount: Object.keys(picked.keyMap).length,
+    langs: selectedLangs,
+    outputDir: path3.relative(process.cwd(), runDir)
+  });
+  const promptTemplate = await fs3.readFile(PROMPT_PATH, "utf8");
+  const prompt = renderPrompt(promptTemplate, selectedLangs, picked.keyMap);
+  const t0 = Date.now();
+  const spinner = new Spinner();
+  const { response, thinking, connectMs, thinkingMs, responseMs, metrics, responseTokens, thinkingTokens } = await callOllama(model, prompt, spinner);
+  const totalMs = Date.now() - t0;
+  const jsonText = extractJSON(response);
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonText);
+  } catch (e) {
+    const debugPath = `${outputPath}.raw.txt`;
+    await fs3.writeFile(debugPath, response, "utf8");
+    throw new Error(
+      `Failed to parse JSON from model output. Raw response saved to ${debugPath}.
+${e.message}`
+    );
+  }
+  const expectedLangs = [SOURCE_LANG, ...selectedLangs.map((l) => l.code)];
+  const expectedKeys = Object.keys(picked.keyMap);
+  const report = validateTranslation(parsed, expectedLangs, expectedKeys);
+  const sorted = sortedLangBundle(parsed, expectedLangs, expectedKeys);
+  await fs3.writeFile(outputPath, JSON.stringify(sorted, null, 2) + "\n", "utf8");
+  const responseRate = metrics.evalTokens && metrics.evalMs ? (metrics.evalTokens / metrics.evalMs * 1e3).toFixed(1) : "\u2014";
+  process.stdout.write(`
+  ${rule()}
+`);
+  process.stdout.write(`  ${C.greenBold("\u2713 Done")} ${C.dim(`in ${(totalMs / 1e3).toFixed(1)}s total`)}
+`);
+  process.stdout.write(`  ${rule()}
+`);
+  process.stdout.write(`  ${C.bold("Timings")}
+`);
+  process.stdout.write(
+    `  ${C.dim("   connect  :")} ${fmtMs(connectMs)}   ${C.dim("load:")} ${fmtMs(metrics.loadMs)}
+`
+  );
+  process.stdout.write(
+    `  ${C.dim("   thinking :")} ${fmtMs(thinkingMs)} ${C.dim(`(${thinkingTokens} tok streamed)`)}
+`
+  );
+  process.stdout.write(
+    `  ${C.dim("   response :")} ${fmtMs(responseMs)} ${C.dim(`(${responseTokens} tok streamed)`)}
+`
+  );
+  process.stdout.write(`  ${C.bold("Tokens")} ${C.dim("(from Ollama)")}
+`);
+  process.stdout.write(
+    `  ${C.dim("   prompt   :")} ${fmtTokOrDash(metrics.promptTokens)} tok   ${C.dim("eval:")} ${fmtMs(metrics.promptEvalMs)}
+`
+  );
+  process.stdout.write(
+    `  ${C.dim("   output   :")} ${fmtTokOrDash(metrics.evalTokens)} tok   ${C.dim("eval:")} ${fmtMs(metrics.evalMs)}   ${C.dim("rate:")} ${responseRate} tok/s
+`
+  );
+  process.stdout.write(`  ${C.bold("Output")}
+`);
+  process.stdout.write(
+    `  ${C.dim("   json     :")} ${response.length} chars, ${expectedLangs.length} langs ${C.dim(`(${expectedLangs.join(", ")})`)}
+`
+  );
+  process.stdout.write(`  ${C.dim("   thinking :")} ${thinking.length} chars
+`);
+  process.stdout.write(`  ${C.dim("   wrote    :")} ${outputPath}
+`);
+  process.stdout.write(`  ${C.dim("   log      :")} ${logAbs}
+`);
+  if (report.missingLangs.length > 0 || Object.keys(report.perLangMissingKeys).length > 0) {
+    process.stdout.write(`
+  ${C.yellowBold("\u26A0 Validation warnings:")}
+`);
+    if (report.missingLangs.length > 0) {
+      process.stdout.write(
+        `  ${C.dim("   missing langs:")} ${report.missingLangs.join(", ")}
+`
+      );
+    }
+    for (const [lang, keys] of Object.entries(report.perLangMissingKeys)) {
+      const preview = keys.slice(0, 5).join(", ") + (keys.length > 5 ? `, \u2026 (+${keys.length - 5})` : "");
+      process.stdout.write(`  ${C.dim(`   ${lang} missing ${keys.length} key(s):`)} ${preview}
+`);
+    }
+    for (const [lang, keys] of Object.entries(report.perLangExtraKeys)) {
+      const preview = keys.slice(0, 5).join(", ") + (keys.length > 5 ? `, \u2026 (+${keys.length - 5})` : "");
+      process.stdout.write(`  ${C.dim(`   ${lang} extra ${keys.length} key(s):`)} ${preview}
+`);
+    }
+  } else {
+    process.stdout.write(`
+  ${C.green("\u2713 Validation passed")} ${C.dim("(all languages have all keys)")}
+`);
+  }
+  process.stdout.write(`  ${rule()}
+
+`);
+  await logTee.teardown();
+}
+function fmtTokOrDash(n) {
+  return n === void 0 ? C.dim("\u2014") : String(n);
+}
+async function runCommand3(_argv) {
+  try {
+    await main3();
+  } catch (err) {
+    process.stdout.write("\n");
+    console.error(formatError(err));
+    process.stdout.write(`
+${ansi.red}${ansi.bold}[fatal]${ansi.reset} translation failed
+`);
+    process.exit(1);
+  }
+}
+
+// src/cli.ts
+var SUBCOMMANDS = [
+  { name: "extract", summary: "Scan source for translation keys", run: runCommand },
+  { name: "diff", summary: "Compare extracted keys against a translation file", run: runCommand2 },
+  { name: "translate", summary: "Translate missing keys via Ollama", run: runCommand3 }
+];
+function printHelp() {
+  const pad = Math.max(...SUBCOMMANDS.map((s) => s.name.length));
+  process.stdout.write(`
+  i18n-toolkit \u2014 extract, diff, and translate i18n keys for React/Next.js
+
+  Usage:
+    i18n-toolkit <command> [options]
+
+  Commands:
+${SUBCOMMANDS.map((s) => `    ${s.name.padEnd(pad)}  ${s.summary}`).join("\n")}
+    ${"help".padEnd(pad)}  Show this message
+
+  Examples:
+    i18n-toolkit extract --src ./src
+    i18n-toolkit diff --src ./src --resource ./translations.json
+    i18n-toolkit translate
+
+  Pass --help to any command for command-specific options.
+
+`);
+}
+async function main4() {
+  const [sub, ...rest] = process.argv.slice(2);
+  if (!sub || sub === "help" || sub === "-h" || sub === "--help") {
+    printHelp();
+    process.exit(sub ? 0 : 0);
+  }
+  const cmd = SUBCOMMANDS.find((s) => s.name === sub);
+  if (!cmd) {
+    process.stderr.write(`
+  Unknown command: ${sub}
+`);
+    printHelp();
+    process.exit(2);
+  }
+  process.argv = [process.argv[0], process.argv[1], ...rest];
+  await cmd.run(rest);
+}
+main4().catch((err) => {
+  process.stderr.write(`
+[fatal] ${err instanceof Error ? err.message : String(err)}
+`);
+  if (err instanceof Error && err.stack) process.stderr.write(err.stack + "\n");
+  process.exit(1);
+});