blume 1.6.4 → 1.6.6

package/dist/cli/chunk-wkq5tbtq.js

@@ -0,0 +1,1141 @@
+#!/usr/bin/env node
+import {
+  DISALLOWED_TOOLS,
+  duration,
+  money,
+  readAgentOutput,
+  runAgentHeadless,
+  seconds
+} from "./chunk-s5e5jt53.js";
+import {
+  AGENTS
+} from "./chunk-8gnpdsn1.js";
+import {
+  reportInternalError
+} from "./chunk-btfr9yvw.js";
+import {
+  writeTextAtomic
+} from "./chunk-ev67ycx0.js";
+import {
+  frontmatter_default,
+  i18nEnabled,
+  localeCodes,
+  localeTargetPath,
+  scanBody,
+  scanProject
+} from "./chunk-etsqspj6.js";
+import {
+  createModuleLoader,
+  folderMetaSchema
+} from "./chunk-vv3f8mb6.js";
+import"./chunk-27gtm2ym.js";
+import"./chunk-4xyggvgf.js";
+import"./chunk-6kzzpsx8.js";
+import {
+  BlumeError,
+  countBySeverity,
+  flushStdout,
+  logger
+} from "./chunk-ey89bjj1.js";
+import {
+  commandMeta
+} from "./chunk-2aj8ddew.js";
+
+// src/cli/commands/translate.ts
+import { defineCommand } from "citty";
+
+// src/translate/agents.ts
+var DEFAULT_TRANSLATE_TIMEOUT_MS = 600000;
+var claudeArgs = () => [
+  "-p",
+  "--output-format",
+  "json",
+  "--strict-mcp-config",
+  "--disallowedTools",
+  DISALLOWED_TOOLS.join(","),
+  "--max-turns",
+  "1"
+];
+var codexArgs = (lastMessagePath) => [
+  "exec",
+  "--skip-git-repo-check",
+  "--ignore-user-config",
+  "--ephemeral",
+  "--sandbox",
+  "read-only",
+  "--output-last-message",
+  lastMessagePath,
+  "-"
+];
+var translateAgentArgs = (kind, lastMessagePath) => kind === "claude" ? claudeArgs() : codexArgs(lastMessagePath);
+
+// src/translate/ledger.ts
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { join } from "pathe";
+import { z } from "zod";
+var LEDGER_FILE = "blume.translations.json";
+var ledgerSchema = z.object({
+  files: z.record(z.string(), z.record(z.string(), z.string())),
+  version: z.literal(1)
+});
+var emptyLedger = () => ({
+  files: {},
+  version: 1
+});
+var hashSource = (text) => createHash("sha256").update(text).digest("hex").slice(0, 16);
+var readLedger = async (root) => {
+  let raw;
+  try {
+    raw = await readFile(join(root, LEDGER_FILE), "utf-8");
+  } catch {
+    return emptyLedger();
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return emptyLedger();
+  }
+  const parsed = ledgerSchema.safeParse(data);
+  return parsed.success ? parsed.data : emptyLedger();
+};
+var serializeLedger = (ledger) => {
+  const files = {};
+  for (const source of Object.keys(ledger.files).toSorted()) {
+    const locales = ledger.files[source] ?? {};
+    files[source] = Object.fromEntries(Object.keys(locales).toSorted().map((locale) => [locale, locales[locale] ?? ""]));
+  }
+  return `${JSON.stringify({ files, version: ledger.version }, null, 2)}
+`;
+};
+var writeLedger = async (root, ledger) => {
+  const path = join(root, LEDGER_FILE);
+  const content = serializeLedger(ledger);
+  let existing = null;
+  try {
+    existing = await readFile(path, "utf-8");
+  } catch {
+    existing = null;
+  }
+  if (existing === content) {
+    return false;
+  }
+  await writeTextAtomic(path, content);
+  return true;
+};
+var stampLedger = (ledger, sourceRel, locale, hash) => {
+  const locales = ledger.files[sourceRel] ?? {};
+  locales[locale] = hash;
+  ledger.files[sourceRel] = locales;
+};
+var pruneLedger = (ledger, knownSources, knownLocales) => {
+  const files = {};
+  for (const [source, locales] of Object.entries(ledger.files)) {
+    if (!knownSources.has(source)) {
+      continue;
+    }
+    const kept = Object.fromEntries(Object.entries(locales).filter(([locale]) => knownLocales.has(locale)));
+    if (Object.keys(kept).length > 0) {
+      files[source] = kept;
+    }
+  }
+  return { files, version: ledger.version };
+};
+
+// src/translate/report.ts
+import { colors } from "consola/utils";
+var ESC = String.fromCodePoint(27);
+var GLYPH = {
+  failed: "✖",
+  partial: "!",
+  translated: "✔"
+};
+var STATUS_COLOR = {
+  failed: colors.red,
+  partial: colors.yellow,
+  translated: colors.green
+};
+var SPINNER_FRAMES = [
+  "⠋",
+  "⠙",
+  "⠹",
+  "⠸",
+  "⠼",
+  "⠴",
+  "⠦",
+  "⠧",
+  "⠇",
+  "⠏"
+];
+var SPINNER_INTERVAL_MS = 80;
+var REWRITE = `\r${ESC}[K`;
+var itemLabel = (item) => item.kind === "page" ? `${item.sourceRel} → ${item.locale}` : `meta title${item.entries.length === 1 ? "" : "s"} (${item.entries.length}) → ${item.locale}`;
+var spinnerLine = (active, done, total, frame) => {
+  const first = active[0];
+  const more = active.length > 1 ? ` (+${active.length - 1} more)` : "";
+  return `  ${colors.cyan(SPINNER_FRAMES[frame % SPINNER_FRAMES.length])} ${itemLabel(first)}${more} ${colors.dim(`${done}/${total}`)}`;
+};
+var itemEndLine = (result) => {
+  const color = STATUS_COLOR[result.status];
+  const glyph = color(GLYPH[result.status]);
+  const label = itemLabel(result.item);
+  if (result.status === "translated") {
+    const cells = [seconds(result.durationMs), money(result.costUsd)].filter((cell) => cell !== "").join(" ");
+    return `  ${glyph} ${label} ${colors.dim(cells)}`;
+  }
+  const word = result.status === "partial" ? "partial" : "failed";
+  return `  ${glyph} ${label} ${color(word)}${result.detail ? colors.dim(`: ${result.detail}`) : ""}`;
+};
+var translateHeaderLine = (itemCount, localeCount, agent) => `${colors.bold("blume translate")}  ${itemCount} item(s) · ${localeCount} locale(s) · ${AGENTS[agent].name}`;
+var translateSummaryLine = (result, workList) => {
+  const { counts } = result;
+  const parts = [
+    `Translated ${counts.translated} file${counts.translated === 1 ? "" : "s"} into ${workList.targetLocales.length} locale${workList.targetLocales.length === 1 ? "" : "s"}`,
+    counts.failed > 0 ? `${counts.failed} failed` : "",
+    counts.partial > 0 ? `${counts.partial} partial` : "",
+    workList.untracked.length > 0 ? `${workList.untracked.length} adopted` : "",
+    workList.upToDate > 0 ? `${workList.upToDate} already up to date` : "",
+    duration(result.durationMs),
+    money(result.costUsd)
+  ].filter((part) => part !== "");
+  return parts.join(" · ");
+};
+var diagnosticLines = (diagnostics) => diagnostics.map((diagnostic) => `  ${colors.yellow("⚠")} ${colors.dim(diagnostic.message)}`);
+var driftRows = (workList) => workList.items.flatMap((item) => item.kind === "page" ? [
+  {
+    locale: item.locale,
+    sourceRel: item.sourceRel,
+    status: item.status
+  }
+] : item.entries.map((entry) => ({
+  locale: item.locale,
+  sourceRel: entry.meta.sourceRel,
+  status: entry.status
+})));
+var checkLines = (workList) => [
+  ...driftRows(workList).map((row) => `  ${colors.red("✖")} ${row.sourceRel} → ${row.locale} ${colors.dim(row.status)}`),
+  ...workList.untracked.map((entry) => `  ${colors.dim(`⊘ ${entry.sourceRel} → ${entry.locale} untracked (adopted by the next translate run)`)}`)
+];
+var checkSummaryLine = (workList) => {
+  const rows = driftRows(workList);
+  const missing = rows.filter((row) => row.status === "missing").length;
+  const stale = rows.filter((row) => row.status === "stale").length;
+  const parts = [
+    missing > 0 ? `${missing} missing` : "",
+    stale > 0 ? `${stale} stale` : "",
+    workList.untracked.length > 0 ? `${workList.untracked.length} untracked` : "",
+    `${workList.upToDate} up to date`
+  ].filter((part) => part !== "");
+  return parts.join(" · ");
+};
+var hasDrift = (workList) => workList.items.length > 0;
+var checkReportJson = (workList) => {
+  const locales = {};
+  for (const locale of workList.targetLocales) {
+    locales[locale] = { missing: [], stale: [], untracked: [] };
+  }
+  for (const row of driftRows(workList)) {
+    locales[row.locale]?.[row.status].push(row.sourceRel);
+  }
+  for (const entry of workList.untracked) {
+    locales[entry.locale]?.untracked.push(entry.sourceRel);
+  }
+  return `${JSON.stringify({
+    diagnostics: workList.diagnostics,
+    summary: countBySeverity(workList.diagnostics),
+    translate: { locales, upToDate: workList.upToDate }
+  }, null, 2)}
+`;
+};
+var resultJson = (result) => ({
+  costUsd: result.costUsd,
+  detail: result.detail,
+  durationMs: result.durationMs,
+  kind: result.item.kind,
+  locale: result.item.locale,
+  status: result.status,
+  ...result.item.kind === "page" ? { source: result.item.sourceRel, target: result.item.targetRel } : {
+    sources: result.item.entries.map((entry) => entry.meta.sourceRel)
+  }
+});
+var translateReportJson = (result, workList) => {
+  const diagnostics = [...workList.diagnostics, ...result.diagnostics];
+  return `${JSON.stringify({
+    diagnostics,
+    summary: countBySeverity(diagnostics),
+    translate: {
+      adopted: workList.untracked.length,
+      agent: result.agent,
+      costUsd: result.costUsd,
+      counts: result.counts,
+      durationMs: result.durationMs,
+      results: result.results.map(resultJson),
+      upToDate: workList.upToDate
+    }
+  }, null, 2)}
+`;
+};
+var createProgressRenderer = (options) => {
+  const now = options.now ?? (() => performance.now());
+  let timer;
+  const active = new Map;
+  let done = 0;
+  let total = 0;
+  let startedAt = 0;
+  const paint = () => {
+    if (active.size > 0) {
+      const frame = Math.floor((now() - startedAt) / SPINNER_INTERVAL_MS);
+      options.write(`${REWRITE}${spinnerLine([...active.values()], done, total, frame)}`);
+    }
+  };
+  const clearTimer = () => {
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+  };
+  return {
+    onProgress(event) {
+      ({ total } = event);
+      if (event.kind === "item-start") {
+        active.set(event.index, event.item);
+        if (!options.isTTY) {
+          return;
+        }
+        if (!timer) {
+          startedAt = now();
+          timer = setInterval(paint, SPINNER_INTERVAL_MS);
+          timer.unref?.();
+        }
+        paint();
+        return;
+      }
+      active.delete(event.index);
+      done += 1;
+      const line = itemEndLine(event.result);
+      if (!options.isTTY) {
+        options.write(`${line}
+`);
+        return;
+      }
+      options.write(`${REWRITE}${line}
+`);
+      if (active.size > 0) {
+        paint();
+      } else {
+        clearTimer();
+      }
+    },
+    stop() {
+      clearTimer();
+      active.clear();
+    }
+  };
+};
+
+// src/translate/run.ts
+import { existsSync } from "node:fs";
+import { mkdtemp, readFile as readFile3 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import pLimit from "p-limit";
+import pMap from "p-map";
+import { join as join3 } from "pathe";
+
+// src/translate/meta.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { dirname, join as join2, relative } from "pathe";
+import { glob } from "tinyglobby";
+var META_FILES = ["**/meta.ts", "**/meta.js", "**/meta.mjs"];
+var isFactoryModule = (value) => typeof value === "function";
+var metaTargetPath = (meta, locale) => join2(meta.contentRoot, locale, meta.dir, "meta.ts");
+var discoverTranslatableMeta = async (project) => {
+  const { i18n } = project.config;
+  if (!i18n || i18n.parser !== "dir") {
+    return { diagnostics: [], metas: [] };
+  }
+  const localeDirs = new Set(i18n.locales.flatMap((locale) => locale.code === i18n.defaultLocale ? [] : [locale.code.toLowerCase()]));
+  const load = createModuleLoader();
+  const metas = [];
+  const diagnostics = [];
+  const roots = project.sources.flatMap((source) => source.staged || !source.contentRoot ? [] : [source.contentRoot]);
+  for (const contentRoot of roots) {
+    const files = await glob(META_FILES, {
+      absolute: true,
+      cwd: contentRoot,
+      ignore: ["**/node_modules/**", "**/.blume/**", "**/dist/**"],
+      onlyFiles: true
+    });
+    for (const file of files.toSorted()) {
+      const dir = relative(contentRoot, dirname(file));
+      const first = dir.split("/")[0]?.toLowerCase();
+      if (first && localeDirs.has(first)) {
+        continue;
+      }
+      const [raw, mod] = await Promise.all([
+        readFile2(file, "utf-8"),
+        load(file)
+      ]);
+      if (isFactoryModule(mod)) {
+        diagnostics.push({
+          code: "BLUME_TRANSLATE_META_FACTORY",
+          file,
+          message: "This meta file default-exports a function, so `blume translate` cannot generate per-locale copies of it.",
+          severity: "warning",
+          suggestion: "Export a plain object, or author the locale's meta file by hand."
+        });
+        continue;
+      }
+      const parsed = folderMetaSchema.safeParse(mod);
+      if (!parsed.success || parsed.data.title === undefined) {
+        continue;
+      }
+      metas.push({
+        contentRoot,
+        data: parsed.data,
+        dir: dir === "." ? "" : dir,
+        file,
+        raw,
+        sourceRel: relative(project.context.root, file),
+        title: parsed.data.title
+      });
+    }
+  }
+  return { diagnostics, metas };
+};
+var generateMetaModule = (meta, translatedTitle) => {
+  const data = {
+    ...meta,
+    title: translatedTitle
+  };
+  const lines = Object.entries(data).toSorted(([a], [b]) => a < b ? -1 : 1).filter(([, value]) => value !== undefined).map(([key, value]) => `  ${key}: ${JSON.stringify(value)},`);
+  return [
+    "// Generated by `blume translate` — edit the default locale's meta file",
+    "// and rerun the translation instead of editing this copy.",
+    "export default {",
+    ...lines,
+    "};",
+    ""
+  ].join(`
+`);
+};
+
+// src/translate/prompts.ts
+var TRANSLATABLE_KEY_PATHS = [
+  ["title"],
+  ["description"],
+  ["sidebar", "label"],
+  ["sidebar", "badge"],
+  ["seo", "title"],
+  ["seo", "description"]
+];
+var localeName = (locale) => `${locale.label} (${locale.code})`;
+var KEY_LIST = TRANSLATABLE_KEY_PATHS.map((path) => path.join(".")).join(", ");
+var pagePrompt = (sourceText, target, source, previousTranslation) => {
+  const styleRule = target.style === undefined ? "" : `
+- Write the translation in this style: ${target.style}`;
+  const previousRule = previousTranslation === undefined ? "" : `
+- A translation of an earlier revision of this page is included below. Match its register, formality, dialect, and terminology exactly; re-translate only what the changed source requires and keep everything else word-for-word identical.${target.style === undefined ? "" : " Where the previous translation disagrees with the style rule above, the style rule wins."}`;
+  const previousSection = previousTranslation === undefined ? "" : `
+The previous translation begins after this line and ends at the "page source" marker.
+${previousTranslation}`;
+  return `Translate the following documentation page from ${localeName(source)} into ${localeName(target)}.
+
+Rules:
+- Translate the prose: headings, paragraphs, list items, table cells, admonitions, and image alt text.
+- In the YAML frontmatter, translate ONLY the values of these keys: ${KEY_LIST}. Copy every other frontmatter key and value exactly as written.
+- Never translate or alter: code blocks, inline code, import/export statements, JSX/MDX component names and their attributes, URLs, link targets, HTML tags, or frontmatter keys.
+- A heading may end with anchor markers: \`[#some-id]\`, \`{#some-id}\` (also written \`\\{#some-id\\}\`), \`[!toc]\`, or \`[toc]\`. Copy every marker exactly as written, in the same position at the end of the translated heading — never translate, reorder, or drop a marker, and never change the id inside \`[#...]\` or \`{#...}\` (anchors must stay identical across languages).
+
+- Preserve the document structure exactly: the same headings, the same lists and tables, and the same number of code fences.${styleRule}${previousRule}
+- Output ONLY the complete translated file. Do not wrap it in a code fence. Do not add commentary before or after it.
+${previousSection}
+The page source begins after this line.
+${sourceText}`;
+};
+var metaPrompt = (titles, target, source) => `Translate the following documentation sidebar section titles from ${localeName(source)} into ${localeName(target)}.
+
+The input is a JSON object mapping a directory path to its title. Reply with ONLY a JSON object that has exactly the same keys, where each value is the title translated into ${localeName(target)}. Do not translate the keys. Do not add commentary.${target.style === undefined ? "" : `
+Write the titles in this style: ${target.style}`}
+
+${JSON.stringify(titles, null, 2)}`;
+
+// src/translate/anchors.ts
+var ATX_CLOSE = /\s+#+$/u;
+var structureOf = (headings) => headings.map((heading) => heading.depth).join(",");
+var pinLine = (line, id) => {
+  const eol = line.endsWith("\r") ? "\r" : "";
+  const body = line.slice(0, line.length - eol.length).trimEnd();
+  const close = body.match(ATX_CLOSE)?.[0] ?? "";
+  const head = body.slice(0, body.length - close.length);
+  return `${head} [#${id}]${close}${eol}`;
+};
+var pinHeadingAnchors = (sourceText, translatedText) => {
+  const source = scanBody(sourceText);
+  const translated = scanBody(translatedText);
+  if (structureOf(source.headings) !== structureOf(translated.headings)) {
+    return {
+      pinned: 0,
+      skipped: `heading structure differs (source has ${source.headings.length} headings, translation has ${translated.headings.length})`,
+      text: translatedText
+    };
+  }
+  const lines = translatedText.split(`
+`);
+  let pinned = 0;
+  for (const [index, heading] of translated.headings.entries()) {
+    const site = translated.sites[index];
+    const sourceId = source.headings[index]?.slug;
+    if (!site || site.pinned || sourceId === undefined || heading.slug === sourceId) {
+      continue;
+    }
+    lines[site.line - 1] = pinLine(lines[site.line - 1] ?? "", sourceId);
+    pinned += 1;
+  }
+  if (pinned === 0) {
+    return { pinned, text: translatedText };
+  }
+  const text = lines.join(`
+`);
+  const rendered = scanBody(text).headings.map((heading) => heading.slug);
+  const expected = source.headings.map((heading) => heading.slug);
+  if (rendered.join(`
+`) !== expected.join(`
+`)) {
+    return {
+      pinned: 0,
+      skipped: "pinned anchors did not reproduce the source heading ids",
+      text: translatedText
+    };
+  }
+  return { pinned, text };
+};
+
+// src/translate/validate.ts
+var FRONTMATTER_OPEN = /^---\r?\n/u;
+var FENCE_LINE = /^\s*(?:```|~~~)/u;
+var stripOuterFence = (text) => {
+  const trimmed = text.trim();
+  const match = trimmed.match(/^(?<fence>`{3,}|~{3,})[^\n]*\n(?<inner>[\s\S]*?)\n\k<fence>\s*$/u);
+  return match?.groups?.inner ?? trimmed;
+};
+var countFenceLines = (text) => text.split(`
+`).filter((line) => FENCE_LINE.test(line)).length;
+var isKeyedObject = (value) => typeof value === "object" && value !== null;
+var isString = (value) => typeof value === "string";
+var getPath = (data, path) => {
+  let value = data;
+  for (const key of path) {
+    if (!isKeyedObject(value)) {
+      return;
+    }
+    value = value[key];
+  }
+  return value;
+};
+var setPath = (data, path, value) => {
+  let parent = data;
+  for (const key of path.slice(0, -1)) {
+    parent = parent[key];
+  }
+  parent[path.at(-1)] = value;
+};
+var ensureTrailingNewline = (text) => text.endsWith(`
+`) ? text : `${text}
+`;
+var validateTranslation = (sourceText, agentText) => {
+  const candidate = stripOuterFence(agentText);
+  if (candidate === "") {
+    return { ok: false, reason: "agent returned empty output" };
+  }
+  const sourceHasFrontmatter = FRONTMATTER_OPEN.test(sourceText);
+  const source = frontmatter_default(sourceText);
+  if (sourceHasFrontmatter && !FRONTMATTER_OPEN.test(candidate)) {
+    return {
+      ok: false,
+      reason: "translation dropped the frontmatter (must start with ---)"
+    };
+  }
+  let parsed;
+  try {
+    parsed = frontmatter_default(candidate);
+  } catch {
+    return { ok: false, reason: "frontmatter does not parse as YAML" };
+  }
+  const rawBody = ensureTrailingNewline(parsed.content.replace(/^\r?\n/u, ""));
+  if (rawBody.trim() === "") {
+    return { ok: false, reason: "translation has an empty body" };
+  }
+  const sourceFences = countFenceLines(source.content);
+  const candidateFences = countFenceLines(rawBody);
+  if (sourceFences !== candidateFences) {
+    return {
+      ok: false,
+      reason: `code fence count changed (source has ${sourceFences}, translation has ${candidateFences})`
+    };
+  }
+  const body = pinHeadingAnchors(source.content, rawBody).text;
+  if (!sourceHasFrontmatter) {
+    return { ok: true, text: body };
+  }
+  const data = structuredClone(source.data);
+  for (const path of TRANSLATABLE_KEY_PATHS) {
+    const original = getPath(source.data, path);
+    const translated = getPath(parsed.data, path);
+    if (isString(original) && isString(translated) && translated.trim() !== "") {
+      setPath(data, path, translated);
+    }
+  }
+  return {
+    ok: true,
+    text: ensureTrailingNewline(frontmatter_default.stringify(body, data))
+  };
+};
+var parseMetaTitles = (agentText, expectedKeys) => {
+  const start = agentText.indexOf("{");
+  const end = agentText.lastIndexOf("}");
+  let parsed;
+  if (start !== -1 && end > start) {
+    try {
+      parsed = JSON.parse(agentText.slice(start, end + 1));
+    } catch {
+      parsed = undefined;
+    }
+  }
+  const record = isKeyedObject(parsed) ? parsed : {};
+  const titles = {};
+  const missing = [];
+  for (const key of expectedKeys) {
+    const value = record[key];
+    if (isString(value) && value.trim() !== "") {
+      titles[key] = value;
+    } else {
+      missing.push(key);
+    }
+  }
+  return { missing, titles };
+};
+
+// src/translate/run.ts
+var metaDirKey = (dir) => dir === "" ? "." : dir;
+var invokeAgent = async (context, prompt, index) => {
+  const messagePath = join3(context.dir, `message-${index}.txt`);
+  const result = await context.run(context.bin, translateAgentArgs(context.kind, messagePath), { cwd: context.dir, prompt, timeoutMs: context.timeoutMs });
+  return await readAgentOutput(context.kind, result, messagePath);
+};
+var runPageItem = async (item, index, context, ledger) => {
+  const started = performance.now();
+  const done = (status, detail, costUsd) => ({
+    costUsd,
+    detail,
+    durationMs: Math.round(performance.now() - started),
+    item,
+    status
+  });
+  const sourceText = await readFile3(item.sourcePath, "utf-8");
+  if (item.verbatim) {
+    await writeTextAtomic(item.targetPath, sourceText);
+    stampLedger(ledger, item.sourceRel, item.locale, hashSource(sourceText));
+    return done("translated");
+  }
+  const target = context.targets.get(item.locale);
+  const previousTranslation = existsSync(item.targetPath) ? await readFile3(item.targetPath, "utf-8") : undefined;
+  const output = await invokeAgent(context, pagePrompt(sourceText, target, context.source, previousTranslation), index);
+  if (output.isError) {
+    return done("failed", output.detail ?? "agent failed", output.costUsd);
+  }
+  const validated = validateTranslation(sourceText, output.text);
+  if (!validated.ok) {
+    return done("failed", validated.reason, output.costUsd);
+  }
+  await writeTextAtomic(item.targetPath, validated.text);
+  stampLedger(ledger, item.sourceRel, item.locale, hashSource(sourceText));
+  return done("translated", undefined, output.costUsd);
+};
+var runMetaItem = async (item, index, context, ledger) => {
+  const started = performance.now();
+  const done = (status, detail, costUsd) => ({
+    costUsd,
+    detail,
+    durationMs: Math.round(performance.now() - started),
+    item,
+    status
+  });
+  const titles = Object.fromEntries(item.entries.map((entry) => [metaDirKey(entry.meta.dir), entry.meta.title]));
+  const target = context.targets.get(item.locale);
+  const output = await invokeAgent(context, metaPrompt(titles, target, context.source), index);
+  if (output.isError) {
+    return done("failed", output.detail ?? "agent failed", output.costUsd);
+  }
+  const parsed = parseMetaTitles(output.text, Object.keys(titles));
+  for (const entry of item.entries) {
+    const translated = parsed.titles[metaDirKey(entry.meta.dir)];
+    if (translated === undefined) {
+      continue;
+    }
+    await writeTextAtomic(entry.targetPath, generateMetaModule(entry.meta.data, translated));
+    stampLedger(ledger, entry.meta.sourceRel, item.locale, hashSource(entry.meta.raw));
+  }
+  if (parsed.missing.length === item.entries.length) {
+    return done("failed", "reply contained no usable titles", output.costUsd);
+  }
+  if (parsed.missing.length > 0) {
+    return done("partial", `no translation for: ${parsed.missing.join(", ")}`, output.costUsd);
+  }
+  return done("translated", undefined, output.costUsd);
+};
+var itemDiagnostic = (result) => {
+  const { item } = result;
+  const site = item.kind === "page" ? { file: item.sourcePath, subject: item.sourceRel } : {
+    file: item.entries[0]?.meta.file,
+    subject: `meta titles (${item.entries.length})`
+  };
+  return {
+    code: result.status === "partial" ? "BLUME_TRANSLATE_META_PARTIAL" : "BLUME_TRANSLATE_FAILED",
+    file: site.file,
+    message: `Translating ${site.subject} into "${item.locale}" ${result.status === "partial" ? "partially failed" : "failed"}: ${result.detail ?? "unknown error"}.`,
+    severity: result.status === "partial" ? "warning" : "error"
+  };
+};
+var runTranslate = async (options) => {
+  const started = performance.now();
+  const { i18n } = options.project.config;
+  if (!i18n) {
+    throw new Error("blume translate requires i18n to be configured");
+  }
+  const source = i18n.locales.find((locale) => locale.code === i18n.defaultLocale);
+  const context = {
+    bin: AGENTS[options.agent].bin,
+    dir: await mkdtemp(join3(tmpdir(), "blume-translate-")),
+    kind: options.agent,
+    run: options.run ?? runAgentHeadless,
+    source,
+    targets: new Map(i18n.locales.map((locale) => [locale.code, locale])),
+    timeoutMs: options.timeoutMs ?? DEFAULT_TRANSLATE_TIMEOUT_MS
+  };
+  const { items } = options.workList;
+  const concurrency = Math.max(1, Math.min(options.concurrency ?? 1, items.length || 1));
+  const persistLimit = pLimit(1);
+  const persist = () => persistLimit(() => options.persistLedger?.());
+  const results = await pMap(items, async (item, index) => {
+    options.onProgress?.({
+      index,
+      item,
+      kind: "item-start",
+      total: items.length
+    });
+    const result = await (item.kind === "page" ? runPageItem(item, index, context, options.ledger) : runMetaItem(item, index, context, options.ledger));
+    await persist();
+    options.onProgress?.({
+      index,
+      kind: "item-end",
+      result,
+      total: items.length
+    });
+    return result;
+  }, { concurrency });
+  const diagnostics = [];
+  for (const result of results) {
+    if (result.status !== "translated") {
+      diagnostics.push(itemDiagnostic(result));
+    }
+  }
+  const counts = {
+    failed: 0,
+    partial: 0,
+    translated: 0
+  };
+  for (const result of results) {
+    counts[result.status] += 1;
+  }
+  const costs = results.flatMap((result) => result.costUsd === undefined ? [] : [result.costUsd]);
+  return {
+    agent: options.agent,
+    costUsd: costs.length > 0 ? costs.reduce((total, cost) => total + cost, 0) : undefined,
+    counts,
+    diagnostics,
+    durationMs: Math.round(performance.now() - started),
+    results
+  };
+};
+
+// src/translate/work-list.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { readFile as readFile4 } from "node:fs/promises";
+import { dirname as dirname2, extname, join as join4, relative as relative2 } from "pathe";
+var PAGE_EXTENSIONS = new Set([".md", ".mdx"]);
+var translatablePages = (project, i18n) => {
+  const rootsByName = new Map(project.sources.flatMap((source) => source.staged || !source.contentRoot ? [] : [[source.name, source.contentRoot]]));
+  const seen = new Set;
+  const universe = [];
+  for (const page of project.graph.pages) {
+    if (page.locale !== i18n.defaultLocale || page.fallback || !page.sourcePath || seen.has(page.sourcePath) || page.version !== "") {
+      continue;
+    }
+    const ext = extname(page.sourcePath);
+    const base = page.sourcePath.slice(0, page.sourcePath.length - ext.length);
+    const contentRoot = rootsByName.get(page.source.name);
+    if (!PAGE_EXTENSIONS.has(ext) || base.endsWith(".$") || !contentRoot) {
+      continue;
+    }
+    seen.add(page.sourcePath);
+    universe.push({ contentRoot, ext, page, sourcePath: page.sourcePath });
+  }
+  return universe;
+};
+var classifyPair = (exists, stamp, hash, force) => {
+  if (!exists) {
+    return "missing";
+  }
+  if (stamp === undefined) {
+    return force ? "stale" : "untracked";
+  }
+  return stamp !== hash || force ? "stale" : "current";
+};
+var partialWorkItems = async (universe, project, i18n, ledger, targetLocales, force) => {
+  const work = {
+    items: [],
+    sources: [],
+    untracked: [],
+    upToDate: 0
+  };
+  if (i18n.parser !== "dir") {
+    return work;
+  }
+  const { root } = project.context;
+  const pagePaths = new Set(project.graph.pages.flatMap((page) => page.sourcePath ? [page.sourcePath] : []));
+  const partials = new Map;
+  for (const { page, contentRoot } of universe) {
+    for (const partial of page.includes ?? []) {
+      if (!(pagePaths.has(partial) || partials.has(partial))) {
+        partials.set(partial, contentRoot);
+      }
+    }
+  }
+  for (const [partialPath, contentRoot] of partials) {
+    const sourceRel = relative2(root, partialPath);
+    work.sources.push(sourceRel);
+    const hash = hashSource(await readFile4(partialPath, "utf-8"));
+    const ext = extname(partialPath);
+    const verbatim = !PAGE_EXTENSIONS.has(ext.toLowerCase());
+    const contentRel = relative2(contentRoot, partialPath);
+    for (const locale of targetLocales) {
+      const targetPath = join4(contentRoot, localeTargetPath(contentRel, ext, locale, i18n));
+      const item = (status) => {
+        const partialItem = {
+          kind: "page",
+          locale,
+          sourcePath: partialPath,
+          sourceRel,
+          status,
+          targetPath,
+          targetRel: relative2(root, targetPath)
+        };
+        if (verbatim) {
+          partialItem.verbatim = true;
+        }
+        return partialItem;
+      };
+      const stamp = ledger.files[sourceRel]?.[locale];
+      const outcome = classifyPair(existsSync2(targetPath), stamp, hash, force);
+      if (outcome === "untracked") {
+        work.untracked.push({ hash, kind: "page", locale, sourceRel });
+      } else if (outcome === "current") {
+        work.upToDate += 1;
+      } else {
+        work.items.push(item(outcome));
+      }
+    }
+  }
+  return work;
+};
+var computeWorkList = async (project, ledger, options = {}) => {
+  const { i18n } = project.config;
+  if (!i18n) {
+    return {
+      diagnostics: [],
+      items: [],
+      knownSources: new Set,
+      targetLocales: [],
+      untracked: [],
+      upToDate: 0
+    };
+  }
+  const targetLocales = localeCodes(i18n).filter((code) => code !== i18n.defaultLocale && (options.locales === undefined || options.locales.includes(code)));
+  const translated = new Set(project.graph.pages.flatMap((page) => page.fallback ? [] : [`${page.translationKey}\x00${page.locale}`]));
+  const { root } = project.context;
+  const knownSources = new Set;
+  const untracked = [];
+  const pageItems = [];
+  let upToDate = 0;
+  const universe = translatablePages(project, i18n);
+  for (const { page, contentRoot, ext, sourcePath } of universe) {
+    const sourceRel = relative2(root, sourcePath);
+    knownSources.add(sourceRel);
+    const hash = hashSource(await readFile4(sourcePath, "utf-8"));
+    const contentRel = relative2(contentRoot, sourcePath);
+    for (const locale of targetLocales) {
+      const targetPath = join4(contentRoot, localeTargetPath(contentRel, ext, locale, i18n));
+      const item = (status) => ({
+        kind: "page",
+        locale,
+        sourcePath,
+        sourceRel,
+        status,
+        targetPath,
+        targetRel: relative2(root, targetPath)
+      });
+      const exists = translated.has(`${page.translationKey}\x00${locale}`);
+      const stamp = ledger.files[sourceRel]?.[locale];
+      const outcome = classifyPair(exists, stamp, hash, options.force === true);
+      if (outcome === "untracked") {
+        untracked.push({ hash, kind: "page", locale, sourceRel });
+      } else if (outcome === "current") {
+        upToDate += 1;
+      } else {
+        pageItems.push(item(outcome));
+      }
+    }
+  }
+  const partialWork = await partialWorkItems(universe, project, i18n, ledger, targetLocales, options.force ?? false);
+  for (const rel of partialWork.sources) {
+    knownSources.add(rel);
+  }
+  pageItems.push(...partialWork.items);
+  untracked.push(...partialWork.untracked);
+  upToDate += partialWork.upToDate;
+  const meta = await discoverTranslatableMeta(project);
+  const metaItems = [];
+  for (const locale of targetLocales) {
+    const entries = [];
+    for (const source of meta.metas) {
+      knownSources.add(source.sourceRel);
+      const targetDir = dirname2(metaTargetPath(source, locale));
+      const exists = ["meta.ts", "meta.js", "meta.mjs"].some((name) => existsSync2(join4(targetDir, name)));
+      const hash = hashSource(source.raw);
+      const stamp = ledger.files[source.sourceRel]?.[locale];
+      const entry = (status) => ({
+        meta: source,
+        status,
+        targetPath: metaTargetPath(source, locale)
+      });
+      const outcome = classifyPair(exists, stamp, hash, options.force === true);
+      if (outcome === "untracked") {
+        untracked.push({
+          hash,
+          kind: "meta",
+          locale,
+          sourceRel: source.sourceRel
+        });
+      } else if (outcome === "current") {
+        upToDate += 1;
+      } else {
+        entries.push(entry(outcome));
+      }
+    }
+    if (entries.length > 0) {
+      metaItems.push({ entries, kind: "meta", locale });
+    }
+  }
+  pageItems.sort((a, b) => a.sourceRel === b.sourceRel ? a.locale.localeCompare(b.locale) : a.sourceRel.localeCompare(b.sourceRel));
+  metaItems.sort((a, b) => a.locale.localeCompare(b.locale));
+  return {
+    diagnostics: meta.diagnostics,
+    items: [...pageItems, ...metaItems],
+    knownSources,
+    targetLocales,
+    untracked,
+    upToDate
+  };
+};
+
+// src/cli/commands/translate.ts
+var DEFAULT_TIMEOUT_S = DEFAULT_TRANSLATE_TIMEOUT_MS / 1000;
+var DEFAULT_CONCURRENCY = 4;
+var MAX_CONCURRENCY = 16;
+var parseFlags = (args) => {
+  const agents = Object.keys(AGENTS).filter((kind) => args[kind]);
+  if (agents.length > 1) {
+    logger.error("Pass exactly one of --claude or --codex.");
+    process.exit(1);
+  }
+  if (args.check && agents.length > 0) {
+    logger.error("--check is read-only and never runs an agent; drop --claude/--codex.");
+    process.exit(1);
+  }
+  if (!args.check && agents.length === 0) {
+    logger.error("Pass --claude or --codex to choose the agent CLI that translates.");
+    process.exit(1);
+  }
+  const timeoutS = args.timeout === undefined ? DEFAULT_TIMEOUT_S : Number(args.timeout);
+  if (!Number.isInteger(timeoutS) || timeoutS <= 0) {
+    logger.error(`Invalid --timeout "${args.timeout}" (whole seconds).`);
+    process.exit(1);
+  }
+  const concurrency = args.concurrency === undefined ? DEFAULT_CONCURRENCY : Number(args.concurrency);
+  if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > MAX_CONCURRENCY) {
+    logger.error(`Invalid --concurrency "${args.concurrency}" (use 1..${MAX_CONCURRENCY}).`);
+    process.exit(1);
+  }
+  return { agent: agents[0], concurrency, timeoutS };
+};
+var parseLocales = (value, i18n) => {
+  if (value === undefined) {
+    return;
+  }
+  const configured = new Map(i18n.locales.map((locale) => [locale.code.toLowerCase(), locale.code]));
+  const resolved = [];
+  for (const part of value.split(",")) {
+    const code = configured.get(part.trim().toLowerCase());
+    if (code === undefined) {
+      logger.error(`Unknown --locale "${part.trim()}" (configured: ${localeCodes(i18n).join(", ")}).`);
+      process.exit(1);
+    }
+    if (code === i18n.defaultLocale) {
+      logger.error(`--locale "${code}" is the default locale — it is the translation source, not a target.`);
+      process.exit(1);
+    }
+    resolved.push(code);
+  }
+  return resolved;
+};
+var notInstalled = (agent) => {
+  const cli = AGENTS[agent];
+  logger.error(`${cli.name} (\`${cli.bin}\`) was not found on PATH. Install it with \`${cli.install}\`.`);
+  return process.exit(1);
+};
+var translateCommand = defineCommand({
+  args: {
+    check: {
+      description: "Report missing/stale translations without writing anything; exits 1 on drift (for CI).",
+      type: "boolean"
+    },
+    claude: {
+      description: "Translate with Claude Code.",
+      type: "boolean"
+    },
+    codex: {
+      description: "Translate with Codex.",
+      type: "boolean"
+    },
+    concurrency: {
+      description: `Parallel agent sessions. Defaults to ${DEFAULT_CONCURRENCY}, max ${MAX_CONCURRENCY}.`,
+      type: "string"
+    },
+    force: {
+      description: "Retranslate everything, up-to-date and hand-authored files included.",
+      type: "boolean"
+    },
+    json: {
+      description: "Emit the report as JSON on stdout (for CI/editors).",
+      type: "boolean"
+    },
+    locale: {
+      description: "Comma-separated target locale codes; defaults to every non-default locale.",
+      type: "string"
+    },
+    timeout: {
+      description: `Agent time limit per file, in seconds. Defaults to ${DEFAULT_TIMEOUT_S}.`,
+      type: "string"
+    }
+  },
+  meta: commandMeta.translate,
+  async run({ args }) {
+    const root = process.cwd();
+    const { agent, concurrency, timeoutS } = parseFlags(args);
+    try {
+      const project = await scanProject(root, { mode: "build" });
+      if (!i18nEnabled(project.config)) {
+        logger.error("i18n is not configured — add `i18n.locales` to blume.config to use `blume translate`.");
+        process.exit(1);
+      }
+      const { i18n } = project.config;
+      if (localeCodes(i18n).every((code) => code === i18n.defaultLocale)) {
+        logger.error("i18n.locales has no locale besides the default — nothing to translate into.");
+        process.exit(1);
+      }
+      const locales = parseLocales(args.locale, i18n);
+      const ledger = await readLedger(root);
+      const workList = await computeWorkList(project, ledger, {
+        force: !args.check && Boolean(args.force),
+        locales
+      });
+      if (args.check) {
+        const lines = [
+          ...diagnosticLines(workList.diagnostics),
+          ...checkLines(workList),
+          "",
+          `  ${checkSummaryLine(workList)}`,
+          ""
+        ];
+        process.stderr.write(`${lines.join(`
+`)}
+`);
+        if (args.json) {
+          process.stdout.write(checkReportJson(workList));
+        }
+        if (hasDrift(workList)) {
+          await flushStdout();
+          process.exit(1);
+        }
+        return;
+      }
+      const kind = agent;
+      process.stderr.write(`${translateHeaderLine(workList.items.length, workList.targetLocales.length, kind)}
+
+`);
+      for (const entry of workList.untracked) {
+        stampLedger(ledger, entry.sourceRel, entry.locale, entry.hash);
+      }
+      await writeLedger(root, ledger);
+      const renderer = createProgressRenderer({
+        isTTY: process.stderr.isTTY === true,
+        write: (chunk) => process.stderr.write(chunk)
+      });
+      const result = await runTranslate({
+        agent: kind,
+        concurrency,
+        ledger,
+        onProgress: (event) => renderer.onProgress(event),
+        persistLedger: () => writeLedger(root, ledger),
+        project,
+        timeoutMs: timeoutS * 1000,
+        workList
+      });
+      renderer.stop();
+      const knownLocales = new Set(localeCodes(i18n).filter((code) => code !== i18n.defaultLocale));
+      await writeLedger(root, pruneLedger(ledger, workList.knownSources, knownLocales));
+      const tail = [
+        "",
+        ...diagnosticLines(workList.diagnostics),
+        `  ${translateSummaryLine(result, workList)}`,
+        ""
+      ];
+      process.stderr.write(tail.join(`
+`));
+      if (args.json) {
+        process.stdout.write(translateReportJson(result, workList));
+      }
+      if (result.counts.failed > 0 || result.counts.partial > 0) {
+        await flushStdout();
+        process.exit(1);
+      }
+    } catch (error) {
+      if (error instanceof BlumeError) {
+        logger.error(error.diagnostic.message);
+        process.exit(1);
+      }
+      if (error?.code === "ENOENT" && agent) {
+        notInstalled(agent);
+      }
+      reportInternalError(error);
+      process.exit(1);
+    }
+  }
+});
+export {
+  translateCommand
+};
+
+//# debugId=51E02F84D7BE6FE064756E2164756E21
+//# sourceMappingURL=chunk-wkq5tbtq.js.map