@better-translate/cli 1.0.0

package/dist/chunk-JFSWNLL6.js

@@ -0,0 +1,854 @@
+// src/config-loader.ts
+import { existsSync as existsSync2 } from "fs";
+import path3 from "path";
+
+// src/env.ts
+import { existsSync } from "fs";
+import path from "path";
+import dotenv from "dotenv";
+function loadEnvFiles(cwd) {
+  const mode = process.env.NODE_ENV || "development";
+  const candidates = [
+    ".env",
+    ".env.local",
+    `.env.${mode}`,
+    `.env.${mode}.local`
+  ];
+  const loaded = [];
+  for (const name of candidates) {
+    const filePath = path.join(cwd, name);
+    if (!existsSync(filePath)) {
+      continue;
+    }
+    dotenv.config({
+      override: true,
+      path: filePath,
+      quiet: true
+    });
+    loaded.push(filePath);
+  }
+  return loaded;
+}
+function loadEnvFilesFromDirectories(directories) {
+  const loaded = /* @__PURE__ */ new Set();
+  for (const directory of directories) {
+    for (const filePath of loadEnvFiles(directory)) {
+      loaded.add(filePath);
+    }
+  }
+  return [...loaded];
+}
+
+// src/module-loader.ts
+import { randomUUID } from "crypto";
+import { readFile, rm, writeFile } from "fs/promises";
+import path2 from "path";
+import { pathToFileURL } from "url";
+import ts from "typescript";
+async function importJavaScriptModule(modulePath) {
+  return await import(`${pathToFileURL(modulePath).href}?t=${Date.now()}`);
+}
+async function importTypeScriptModule(modulePath) {
+  const source = await readFile(modulePath, "utf8");
+  const tempPath = path2.join(
+    path2.dirname(modulePath),
+    `.better-translate-${randomUUID()}.mjs`
+  );
+  const transpiled = ts.transpileModule(source, {
+    compilerOptions: {
+      esModuleInterop: true,
+      module: ts.ModuleKind.ESNext,
+      moduleResolution: ts.ModuleResolutionKind.Bundler,
+      resolveJsonModule: true,
+      target: ts.ScriptTarget.ES2022
+    },
+    fileName: modulePath
+  });
+  await writeFile(tempPath, transpiled.outputText, "utf8");
+  try {
+    return await importJavaScriptModule(tempPath);
+  } finally {
+    await rm(tempPath, {
+      force: true
+    });
+  }
+}
+async function importModule(modulePath) {
+  if (path2.extname(modulePath) === ".ts") {
+    return importTypeScriptModule(modulePath);
+  }
+  return importJavaScriptModule(modulePath);
+}
+
+// src/validation.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+function isTranslationMessages(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return Object.values(value).every((entry) => {
+    if (typeof entry === "string") {
+      return true;
+    }
+    return isTranslationMessages(entry);
+  });
+}
+function assertTranslationMessages(value, message) {
+  assert(isTranslationMessages(value), message);
+}
+function flattenTranslationKeys(messages, prefix = "") {
+  const keys = [];
+  for (const [key, value] of Object.entries(messages)) {
+    const nextKey = prefix ? `${prefix}.${key}` : key;
+    if (typeof value === "string") {
+      keys.push(nextKey);
+      continue;
+    }
+    keys.push(...flattenTranslationKeys(value, nextKey));
+  }
+  return keys;
+}
+function assertExactMessageShape(reference, candidate, pathParts = []) {
+  assert(
+    isRecord(candidate),
+    `Generated translations must be an object at "${pathParts.join(".") || "<root>"}".`
+  );
+  const referenceKeys = Object.keys(reference).sort();
+  const candidateKeys = Object.keys(candidate).sort();
+  assert(
+    referenceKeys.length === candidateKeys.length,
+    `Generated translations changed the keys at "${pathParts.join(".") || "<root>"}".`
+  );
+  for (const key of referenceKeys) {
+    assert(
+      key in candidate,
+      `Generated translations are missing the key "${[...pathParts, key].join(".")}".`
+    );
+    const referenceValue = reference[key];
+    const candidateValue = candidate[key];
+    if (typeof referenceValue === "string") {
+      assert(
+        typeof candidateValue === "string",
+        `Generated translations must keep "${[...pathParts, key].join(".")}" as a string.`
+      );
+      continue;
+    }
+    assertExactMessageShape(referenceValue, candidateValue, [
+      ...pathParts,
+      key
+    ]);
+  }
+}
+function normalizeMarkdownExtensions(value) {
+  if (value === void 0) {
+    return [".md", ".mdx"];
+  }
+  assert(
+    Array.isArray(value),
+    "markdown.extensions must be an array when provided."
+  );
+  assert(
+    value.length > 0,
+    "markdown.extensions must include at least one extension."
+  );
+  const normalized = [...new Set(value)];
+  for (const extension of normalized) {
+    assert(
+      extension === ".md" || extension === ".mdx",
+      'markdown.extensions only supports ".md" and ".mdx".'
+    );
+  }
+  return normalized;
+}
+function toJavaScriptIdentifier(value) {
+  const parts = value.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((part) => part.toLowerCase());
+  if (parts.length === 0) {
+    return "messages";
+  }
+  const [head, ...tail] = parts;
+  const identifier = `${head}${tail.map((part) => `${part[0].toUpperCase()}${part.slice(1)}`).join("")}`;
+  return /^[a-zA-Z_$]/.test(identifier) ? identifier : `_${identifier}`;
+}
+
+// src/config-loader.ts
+var DEFAULT_CONFIG_FILE = "better-translate.config.ts";
+function resolveProviderModelSpec(model) {
+  assert(
+    isRecord(model),
+    'Config requires model to be a non-empty string or openai("model-id", { apiKey }).'
+  );
+  assert(
+    model.kind === "provider-model",
+    'Config requires model to be a non-empty string or openai("model-id", { apiKey }).'
+  );
+  assert(
+    model.provider === "openai",
+    'Only openai("model-id", { apiKey }) is supported for built-in provider mode right now.'
+  );
+  assert(
+    typeof model.modelId === "string" && model.modelId.trim().length > 0,
+    'openai("model-id", { apiKey }) requires a non-empty model id.'
+  );
+  assert(
+    typeof model.apiKey === "string" && model.apiKey.trim().length > 0,
+    'openai("model-id", { apiKey }) requires a non-empty apiKey string.'
+  );
+  return {
+    apiKey: model.apiKey.trim(),
+    kind: "provider-model",
+    modelId: model.modelId.trim(),
+    provider: "openai"
+  };
+}
+function resolveConfig(rawConfig, configDirectory) {
+  assert(
+    isRecord(rawConfig),
+    "better-translate.config.ts must export a config object."
+  );
+  const sourceLocale = rawConfig.sourceLocale;
+  assert(
+    typeof sourceLocale === "string" && sourceLocale.trim().length > 0,
+    "Config requires a non-empty sourceLocale string."
+  );
+  const locales = rawConfig.locales;
+  assert(Array.isArray(locales), "Config requires a locales array.");
+  const normalizedLocales = locales.map((locale) => {
+    assert(
+      typeof locale === "string" && locale.trim().length > 0,
+      "Config locales must be non-empty strings."
+    );
+    return locale.trim();
+  });
+  assert(
+    normalizedLocales.length > 0,
+    "Config requires at least one target locale."
+  );
+  assert(
+    new Set(normalizedLocales).size === normalizedLocales.length,
+    "Config locales must not contain duplicates."
+  );
+  assert(
+    !normalizedLocales.includes(sourceLocale),
+    "Config locales must not include the sourceLocale."
+  );
+  const messages = rawConfig.messages;
+  assert(isRecord(messages), "Config requires a messages object.");
+  assert(
+    typeof messages.entry === "string" && messages.entry.trim().length > 0,
+    "Config requires messages.entry."
+  );
+  const markdown = rawConfig.markdown;
+  const model = rawConfig.model;
+  const gateway = rawConfig.gateway;
+  const resolvedBase = {
+    locales: normalizedLocales,
+    markdown: markdown === void 0 ? void 0 : (() => {
+      assert(
+        isRecord(markdown),
+        "markdown must be an object when provided."
+      );
+      assert(
+        typeof markdown.rootDir === "string" && markdown.rootDir.trim().length > 0,
+        "markdown.rootDir must be a non-empty string."
+      );
+      return {
+        extensions: normalizeMarkdownExtensions(markdown.extensions),
+        rootDir: path3.resolve(configDirectory, markdown.rootDir)
+      };
+    })(),
+    messages: {
+      entry: path3.resolve(configDirectory, messages.entry)
+    },
+    sourceLocale
+  };
+  if (typeof model === "string") {
+    assert(
+      model.trim().length > 0,
+      'Config requires a non-empty model string, for example "openai/gpt-4.1".'
+    );
+    assert(
+      isRecord(gateway),
+      "Config requires a gateway object when model is a string."
+    );
+    assert(
+      typeof gateway.apiKey === "string" && gateway.apiKey.trim().length > 0,
+      "Config requires gateway.apiKey with the AI Gateway key string."
+    );
+    return {
+      ...resolvedBase,
+      gateway: {
+        apiKey: gateway.apiKey.trim()
+      },
+      model: model.trim()
+    };
+  }
+  assert(
+    gateway === void 0,
+    "Config must not include gateway when model is created with openai(...)."
+  );
+  const resolvedModel = resolveProviderModelSpec(model);
+  return {
+    ...resolvedBase,
+    model: resolvedModel
+  };
+}
+async function loadCliConfig(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const configPath = path3.resolve(
+    cwd,
+    options.configPath ?? DEFAULT_CONFIG_FILE
+  );
+  const configDirectory = path3.dirname(configPath);
+  loadEnvFilesFromDirectories(
+    configDirectory === cwd ? [cwd] : [cwd, configDirectory]
+  );
+  assert(
+    existsSync2(configPath),
+    `Could not find Better Translate config at "${configPath}".`
+  );
+  const module = await importModule(configPath);
+  const rawConfig = module.default ?? module.config ?? module;
+  return {
+    config: resolveConfig(rawConfig, configDirectory),
+    directory: configDirectory,
+    path: configPath
+  };
+}
+
+// src/generate.ts
+import { mkdir, writeFile as writeFile2 } from "fs/promises";
+import path6 from "path";
+
+// src/markdown.ts
+import { readdir, readFile as readFile2 } from "fs/promises";
+import path4 from "path";
+import matter from "gray-matter";
+async function walkDirectory(directory) {
+  const entries = await readdir(directory, {
+    withFileTypes: true
+  });
+  const files = await Promise.all(
+    entries.map(async (entry) => {
+      const entryPath = path4.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        return walkDirectory(entryPath);
+      }
+      if (entry.isFile()) {
+        return [entryPath];
+      }
+      return [];
+    })
+  );
+  return files.flat();
+}
+function extractFrontmatterStrings(value) {
+  if (!isRecord(value)) {
+    return {};
+  }
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === "string") {
+      result[key] = entry;
+      continue;
+    }
+    if (isRecord(entry)) {
+      const nested = extractFrontmatterStrings(entry);
+      if (Object.keys(nested).length > 0) {
+        result[key] = nested;
+      }
+    }
+  }
+  return result;
+}
+function createStringOnlySchema(value) {
+  const properties = {};
+  for (const [key, entry] of Object.entries(value)) {
+    properties[key] = typeof entry === "string" ? { type: "string" } : createStringOnlySchema(entry);
+  }
+  return {
+    additionalProperties: false,
+    properties,
+    required: Object.keys(value),
+    type: "object"
+  };
+}
+function createMarkdownOutputSchema(frontmatterStrings) {
+  return {
+    additionalProperties: false,
+    properties: {
+      body: {
+        type: "string"
+      },
+      frontmatter: createStringOnlySchema(frontmatterStrings)
+    },
+    required: ["body", "frontmatter"],
+    type: "object"
+  };
+}
+function mergeFrontmatterStrings(source, translatedStrings) {
+  const merged = {
+    ...source
+  };
+  for (const [key, entry] of Object.entries(translatedStrings)) {
+    if (typeof entry === "string") {
+      merged[key] = entry;
+      continue;
+    }
+    const nestedSource = isRecord(source[key]) ? source[key] : {};
+    merged[key] = mergeFrontmatterStrings(
+      nestedSource,
+      entry
+    );
+  }
+  return merged;
+}
+function applyMarkdownTranslation(sourceFrontmatter, translatedStrings, body) {
+  return matter.stringify(
+    body,
+    mergeFrontmatterStrings(sourceFrontmatter, translatedStrings)
+  );
+}
+async function listMarkdownSourceFiles(rootDir, extensions) {
+  const files = await walkDirectory(rootDir);
+  return files.filter(
+    (filePath) => extensions.some((extension) => filePath.endsWith(extension))
+  ).sort();
+}
+async function loadMarkdownDocument(rootDir, sourcePath) {
+  const sourceText = await readFile2(sourcePath, "utf8");
+  const parsed = matter(sourceText);
+  const frontmatter = isRecord(parsed.data) ? parsed.data : {};
+  const frontmatterStrings = extractFrontmatterStrings(frontmatter);
+  const relativePath = path4.relative(rootDir, sourcePath).split(path4.sep).join("/");
+  return {
+    body: parsed.content,
+    frontmatter,
+    frontmatterStrings,
+    relativePath,
+    schema: createMarkdownOutputSchema(frontmatterStrings),
+    sourceText,
+    sourcePath
+  };
+}
+function deriveTargetMarkdownRoot(rootDir, sourceLocale, targetLocale) {
+  const basename = path4.basename(rootDir);
+  assert(
+    basename === sourceLocale,
+    `markdown.rootDir must end with the source locale "${sourceLocale}" so the CLI can mirror sibling locale folders.`
+  );
+  return path4.join(path4.dirname(rootDir), targetLocale);
+}
+function deriveTargetMarkdownPath(rootDir, sourceLocale, targetLocale, relativePath) {
+  return path4.join(
+    deriveTargetMarkdownRoot(rootDir, sourceLocale, targetLocale),
+    relativePath
+  );
+}
+
+// src/messages.ts
+import { readFile as readFile3 } from "fs/promises";
+import path5 from "path";
+import {
+  createTranslationJsonSchema
+} from "@better-translate/core";
+function getExportedMessages(module, sourceLocale) {
+  const value = module.default ?? module[sourceLocale];
+  assert(
+    value !== void 0,
+    `The source translation module must export a default object or a named "${sourceLocale}" export.`
+  );
+  assertTranslationMessages(
+    value,
+    "The source translation file must export nested objects with string leaves only."
+  );
+  return value;
+}
+async function loadSourceMessages(sourcePath, sourceLocale) {
+  const extension = path5.extname(sourcePath);
+  const sourceText = await readFile3(sourcePath, "utf8");
+  if (extension === ".json") {
+    const parsed = JSON.parse(sourceText);
+    assertTranslationMessages(
+      parsed,
+      "The source JSON file must contain nested objects with string leaves only."
+    );
+    return {
+      format: "json",
+      keyPaths: flattenTranslationKeys(parsed),
+      messages: parsed,
+      schema: createTranslationJsonSchema(parsed),
+      sourceText,
+      sourcePath
+    };
+  }
+  assert(
+    extension === ".ts",
+    `Unsupported source translation extension "${extension}". Use .json or .ts.`
+  );
+  const module = await importModule(sourcePath);
+  const messages = getExportedMessages(module, sourceLocale);
+  return {
+    format: "ts",
+    keyPaths: flattenTranslationKeys(messages),
+    messages,
+    schema: createTranslationJsonSchema(messages),
+    sourceText,
+    sourcePath
+  };
+}
+function replaceLocaleSegment(basename, sourceLocale, targetLocale) {
+  if (basename === sourceLocale) {
+    return targetLocale;
+  }
+  const escapedSourceLocale = sourceLocale.replace(
+    /[.*+?^${}()|[\]\\]/g,
+    "\\$&"
+  );
+  const pattern = new RegExp(`(^|[._-])${escapedSourceLocale}(?=$|[._-])`);
+  const match = basename.match(pattern);
+  if (!match) {
+    return null;
+  }
+  return basename.replace(pattern, `${match[1]}${targetLocale}`);
+}
+function deriveTargetMessagesPath(sourcePath, sourceLocale, targetLocale) {
+  const extension = path5.extname(sourcePath);
+  const basename = path5.basename(sourcePath, extension);
+  const replaced = replaceLocaleSegment(basename, sourceLocale, targetLocale);
+  assert(
+    replaced,
+    `Could not derive a target messages filename from "${sourcePath}". The basename must contain the source locale "${sourceLocale}".`
+  );
+  return path5.join(path5.dirname(sourcePath), `${replaced}${extension}`);
+}
+function serializeMessages(messages, format, locale) {
+  if (format === "json") {
+    return `${JSON.stringify(messages, null, 2)}
+`;
+  }
+  const identifier = toJavaScriptIdentifier(locale);
+  const objectLiteral = JSON.stringify(messages, null, 2);
+  return `export const ${identifier} = ${objectLiteral} as const;
+
+export default ${identifier};
+`;
+}
+
+// src/prompts.ts
+var MESSAGE_SYSTEM_INSTRUCTIONS = [
+  "You are translating application locale files.",
+  "Mimic the source file's structure, tone, and formatting conventions.",
+  "Do not switch styles, rename concepts, regroup content, or invent missing text.",
+  "Return only structured output that preserves the exact object shape and every placeholder token."
+].join(" ");
+var MESSAGE_RULES = [
+  "- Keep the exact same keys and nested structure.",
+  "- Mimic the source file's wording style, punctuation style, capitalization style, and sentence density.",
+  "- Preserve placeholders like {name}, {count}, and similar tokens exactly.",
+  "- Preserve URLs, code identifiers, product names, and formatting markers unless they are natural-language text.",
+  "- Do not add explanations, comments, metadata, or extra keys.",
+  "- Do not simplify, reorganize, or normalize the content. Stay as close as possible to the source file's format."
+].join("\n");
+var MARKDOWN_SYSTEM_INSTRUCTIONS = [
+  "You are translating Markdown and MDX documents.",
+  "Mimic the source document's structure, formatting, and writing style.",
+  "Do not switch layouts, reorder sections, or alter code fences, JSX tags, links, or formatting markers."
+].join(" ");
+var MARKDOWN_RULES = [
+  "- Preserve headings, lists, emphasis markers, tables, code fences, inline code, HTML, JSX, and MDX tags.",
+  "- Preserve links, image URLs, import paths, filenames, and code snippets.",
+  "- Translate prose and string frontmatter values only.",
+  "- Keep the same section order, spacing intent, and formatting pattern as the source document.",
+  "- Do not add commentary, summaries, or extra sections."
+].join("\n");
+function createMessagesPrompt(options) {
+  const prompt = [
+    `Translate the source locale file into "${options.targetLocale}".`,
+    `Source locale: ${options.sourceLocale}`,
+    `Target locale: ${options.targetLocale}`,
+    `Source file: ${options.sourcePath}`,
+    "",
+    "Rules:",
+    MESSAGE_RULES,
+    "",
+    "Key paths:",
+    options.keyPaths.map((key) => `- ${key}`).join("\n"),
+    "",
+    "Source file content to mimic:",
+    options.sourceText,
+    "",
+    "Source messages:",
+    JSON.stringify(options.sourceMessages, null, 2)
+  ].join("\n");
+  return {
+    prompt,
+    system: MESSAGE_SYSTEM_INSTRUCTIONS
+  };
+}
+function createMarkdownPrompt(options) {
+  const prompt = [
+    `Translate this markdown document into "${options.targetLocale}".`,
+    `Source locale: ${options.sourceLocale}`,
+    `Target locale: ${options.targetLocale}`,
+    `Document path: ${options.relativePath}`,
+    "",
+    "Rules:",
+    MARKDOWN_RULES,
+    "",
+    "Source file content to mimic:",
+    options.sourceText,
+    "",
+    "Frontmatter string values:",
+    JSON.stringify(options.frontmatterStrings, null, 2),
+    "",
+    "Markdown body:",
+    options.body
+  ].join("\n");
+  return {
+    prompt,
+    system: MARKDOWN_SYSTEM_INSTRUCTIONS
+  };
+}
+
+// src/generate.ts
+function createConsoleLogger() {
+  return {
+    error(message) {
+      console.error(message);
+    },
+    info(message) {
+      console.log(message);
+    }
+  };
+}
+function describeError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function persistWrite(write, options) {
+  if (options.dryRun) {
+    options.logger.info(
+      `[dry-run] ${write.kind}:${write.locale} ${write.targetPath}`
+    );
+    return;
+  }
+  await mkdir(path6.dirname(write.targetPath), {
+    recursive: true
+  });
+  await writeFile2(write.targetPath, write.content, "utf8");
+  options.logger.info(
+    `wrote ${write.kind}:${write.locale} ${write.targetPath}`
+  );
+}
+function prepareGatewayEnvironment(apiKey) {
+  assert(
+    typeof apiKey === "string" && apiKey.length > 0,
+    "Missing AI Gateway key. Provide gateway.apiKey in better-translate.config.ts."
+  );
+  process.env.AI_GATEWAY_API_KEY = apiKey;
+}
+async function createDefaultGenerator(model) {
+  const { generateWithAiSdk } = await import("./ai-sdk-generator-WPQCTPGA.js");
+  return async (request) => generateWithAiSdk(model, request);
+}
+async function resolveRuntimeModel(config) {
+  if ("gateway" in config) {
+    prepareGatewayEnvironment(config.gateway.apiKey);
+    return {
+      description: `Using AI Gateway model: ${config.model}`,
+      model: config.model
+    };
+  }
+  const { createOpenAI } = await import("@ai-sdk/openai");
+  const provider = createOpenAI({
+    apiKey: config.model.apiKey
+  });
+  return {
+    description: `Using built-in OpenAI provider model: ${config.model.modelId}`,
+    model: provider(config.model.modelId)
+  };
+}
+function validateMarkdownTranslation(frontmatterStrings, value) {
+  assert(
+    isRecord(value),
+    "Generated markdown output must be an object with body and frontmatter."
+  );
+  assert(
+    typeof value.body === "string",
+    "Generated markdown output must include a string body."
+  );
+  assert(
+    isRecord(value.frontmatter),
+    "Generated markdown output must include a frontmatter object."
+  );
+  assertExactMessageShape(frontmatterStrings, value.frontmatter);
+  return {
+    body: value.body,
+    frontmatter: value.frontmatter
+  };
+}
+async function generateProject(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const logger = options.logger ?? createConsoleLogger();
+  logger.info("Loading Better Translate config...");
+  const loadedConfig = await loadCliConfig({
+    configPath: options.configPath,
+    cwd
+  });
+  const { config } = loadedConfig;
+  logger.info(`Using config: ${loadedConfig.path}`);
+  const resolvedModel = await resolveRuntimeModel(config);
+  logger.info(resolvedModel.description);
+  logger.info(`Source locale: ${config.sourceLocale}`);
+  logger.info(`Target locales: ${config.locales.join(", ")}`);
+  const generator = options.generator ?? await createDefaultGenerator(resolvedModel.model);
+  const writes = [];
+  logger.info(`Loading source messages from ${config.messages.entry}...`);
+  const sourceMessages = await loadSourceMessages(
+    config.messages.entry,
+    config.sourceLocale
+  );
+  logger.info(
+    `Loaded ${sourceMessages.keyPaths.length} translation key${sourceMessages.keyPaths.length === 1 ? "" : "s"}.`
+  );
+  const markdownSources = config.markdown ? await listMarkdownSourceFiles(
+    config.markdown.rootDir,
+    config.markdown.extensions
+  ) : [];
+  if (config.markdown) {
+    logger.info(
+      `Found ${markdownSources.length} markdown file${markdownSources.length === 1 ? "" : "s"} in ${config.markdown.rootDir}.`
+    );
+  } else {
+    logger.info("Markdown generation disabled.");
+  }
+  for (const locale of config.locales) {
+    logger.info(`Starting locale "${locale}"...`);
+    const messagePrompt = createMessagesPrompt({
+      keyPaths: sourceMessages.keyPaths,
+      sourceLocale: config.sourceLocale,
+      sourceMessages: sourceMessages.messages,
+      sourceText: sourceMessages.sourceText,
+      sourcePath: sourceMessages.sourcePath,
+      targetLocale: locale
+    });
+    logger.info(`Requesting message translation for "${locale}"...`);
+    const translatedMessages = await generator({
+      kind: "messages",
+      prompt: messagePrompt.prompt,
+      schema: sourceMessages.schema,
+      sourcePath: sourceMessages.sourcePath,
+      system: messagePrompt.system,
+      targetLocale: locale,
+      validate(value) {
+        assertExactMessageShape(sourceMessages.messages, value);
+        return value;
+      }
+    }).catch((error) => {
+      throw new Error(
+        `Failed translating messages for locale "${locale}" from "${sourceMessages.sourcePath}": ${describeError(error)}`
+      );
+    });
+    const messageWrite = {
+      content: serializeMessages(
+        translatedMessages,
+        sourceMessages.format,
+        locale
+      ),
+      kind: "messages",
+      locale,
+      sourcePath: sourceMessages.sourcePath,
+      targetPath: deriveTargetMessagesPath(
+        sourceMessages.sourcePath,
+        config.sourceLocale,
+        locale
+      )
+    };
+    writes.push(messageWrite);
+    logger.info(`Prepared messages:${locale} -> ${messageWrite.targetPath}`);
+    await persistWrite(messageWrite, {
+      dryRun: options.dryRun,
+      logger
+    });
+    for (const sourcePath of markdownSources) {
+      const document = await loadMarkdownDocument(
+        config.markdown.rootDir,
+        sourcePath
+      );
+      logger.info(
+        `Requesting markdown translation for "${locale}": ${document.relativePath}`
+      );
+      const markdownPrompt = createMarkdownPrompt({
+        body: document.body,
+        frontmatterStrings: document.frontmatterStrings,
+        relativePath: document.relativePath,
+        sourceLocale: config.sourceLocale,
+        sourceText: document.sourceText,
+        targetLocale: locale
+      });
+      const translatedDocument = await generator({
+        kind: "markdown",
+        prompt: markdownPrompt.prompt,
+        schema: document.schema,
+        sourcePath: document.sourcePath,
+        system: markdownPrompt.system,
+        targetLocale: locale,
+        validate(value) {
+          return validateMarkdownTranslation(
+            document.frontmatterStrings,
+            value
+          );
+        }
+      }).catch((error) => {
+        throw new Error(
+          `Failed translating markdown for locale "${locale}" from "${document.sourcePath}": ${describeError(error)}`
+        );
+      });
+      const markdownWrite = {
+        content: applyMarkdownTranslation(
+          document.frontmatter,
+          translatedDocument.frontmatter,
+          translatedDocument.body
+        ),
+        kind: "markdown",
+        locale,
+        sourcePath: document.sourcePath,
+        targetPath: deriveTargetMarkdownPath(
+          config.markdown.rootDir,
+          config.sourceLocale,
+          locale,
+          document.relativePath
+        )
+      };
+      writes.push(markdownWrite);
+      logger.info(`Prepared markdown:${locale} -> ${markdownWrite.targetPath}`);
+      await persistWrite(markdownWrite, {
+        dryRun: options.dryRun,
+        logger
+      });
+    }
+    logger.info(`Finished locale "${locale}".`);
+  }
+  if (options.dryRun) {
+    logger.info("Dry run enabled. No files were written.");
+  }
+  logger.info(
+    `${options.dryRun ? "planned" : "generated"} ${writes.length} file${writes.length === 1 ? "" : "s"}.`
+  );
+  return {
+    dryRun: Boolean(options.dryRun),
+    loadedConfig,
+    writes
+  };
+}
+
+export {
+  loadCliConfig,
+  generateProject
+};