@better-translate/cli 1.0.1 → 2.0.1

package/dist/{chunk-JFSWNLL6.js → chunk-55TGASZJ.js}

@@ -179,33 +179,32 @@ function toJavaScriptIdentifier(value) {
 
 // src/config-loader.ts
 var DEFAULT_CONFIG_FILE = "better-translate.config.ts";
-function resolveProviderModelSpec(model) {
+function resolveCliLanguageModel(model) {
   assert(
     isRecord(model),
-    'Config requires model to be a non-empty string or openai("model-id", { apiKey }).'
+    "Config requires model to be a non-empty string or an AI SDK language model instance."
   );
   assert(
-    model.kind === "provider-model",
-    'Config requires model to be a non-empty string or openai("model-id", { apiKey }).'
+    model.specificationVersion === "v3",
+    "Config requires model to be a non-empty string or an AI SDK language model instance."
   );
   assert(
-    model.provider === "openai",
-    'Only openai("model-id", { apiKey }) is supported for built-in provider mode right now.'
+    typeof model.provider === "string" && model.provider.trim().length > 0,
+    "AI SDK language model instances require a non-empty provider string."
   );
   assert(
     typeof model.modelId === "string" && model.modelId.trim().length > 0,
-    'openai("model-id", { apiKey }) requires a non-empty model id.'
+    "AI SDK language model instances require a non-empty modelId string."
   );
   assert(
-    typeof model.apiKey === "string" && model.apiKey.trim().length > 0,
-    'openai("model-id", { apiKey }) requires a non-empty apiKey string.'
+    typeof model.doGenerate === "function",
+    "AI SDK language model instances must provide a doGenerate function."
   );
-  return {
-    apiKey: model.apiKey.trim(),
-    kind: "provider-model",
-    modelId: model.modelId.trim(),
-    provider: "openai"
-  };
+  assert(
+    typeof model.doStream === "function",
+    "AI SDK language model instances must provide a doStream function."
+  );
+  return model;
 }
 function resolveConfig(rawConfig, configDirectory) {
   assert(
@@ -271,7 +270,7 @@ function resolveConfig(rawConfig, configDirectory) {
   if (typeof model === "string") {
     assert(
       model.trim().length > 0,
-      'Config requires a non-empty model string, for example "openai/gpt-4.1".'
+      'Config requires a non-empty model string, for example "provider/model-id".'
     );
     assert(
       isRecord(gateway),
@@ -291,9 +290,9 @@ function resolveConfig(rawConfig, configDirectory) {
   }
   assert(
     gateway === void 0,
-    "Config must not include gateway when model is created with openai(...)."
+    "Config must not include gateway when model is an AI SDK language model instance."
   );
-  const resolvedModel = resolveProviderModelSpec(model);
+  const resolvedModel = resolveCliLanguageModel(model);
   return {
     ...resolvedBase,
     model: resolvedModel
@@ -322,21 +321,630 @@ async function loadCliConfig(options = {}) {
   };
 }
 
+// src/extract.ts
+import { readdir, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import path5 from "path";
+import ts2 from "typescript";
+
+// src/messages.ts
+import { readFile as readFile2 } from "fs/promises";
+import path4 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 = path4.extname(sourcePath);
+  const sourceText = await readFile2(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 = path4.extname(sourcePath);
+  const basename = path4.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 path4.join(path4.dirname(sourcePath), `${replaced}${extension}`);
+}
+function formatTsPropertyKey(key) {
+  if (key === "__proto__") {
+    return JSON.stringify(key);
+  }
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(key) ? key : JSON.stringify(key);
+}
+function serializeTsObject(messages, indentLevel = 0) {
+  const entries = Object.entries(messages);
+  if (entries.length === 0) {
+    return "{}";
+  }
+  const indent = "  ".repeat(indentLevel);
+  const childIndent = "  ".repeat(indentLevel + 1);
+  const lines = entries.map(([key, value]) => {
+    const propertyKey = formatTsPropertyKey(key);
+    if (typeof value === "string") {
+      return `${childIndent}${propertyKey}: ${JSON.stringify(value)},`;
+    }
+    return `${childIndent}${propertyKey}: ${serializeTsObject(
+      value,
+      indentLevel + 1
+    )},`;
+  });
+  return `{
+${lines.join("\n")}
+${indent}}`;
+}
+function serializeMessages(messages, format, locale) {
+  if (format === "json") {
+    return `${JSON.stringify(messages, null, 2)}
+`;
+  }
+  const identifier = toJavaScriptIdentifier(locale);
+  const objectLiteral = serializeTsObject(messages);
+  return `// generated by @better-translate/cli
+export const ${identifier} = ${objectLiteral} as const;
+
+export default ${identifier};
+`;
+}
+
+// src/extract.ts
+var DEFAULT_MAX_LENGTH = 40;
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".cjs",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".mts",
+  ".ts",
+  ".tsx"
+]);
+var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".git",
+  ".next",
+  ".turbo",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules"
+]);
+var NAMESPACE_ROOTS = /* @__PURE__ */ new Set([
+  "app",
+  "components",
+  "lib",
+  "pages",
+  "routes",
+  "src"
+]);
+function createDefaultLogger() {
+  return {
+    error(message) {
+      console.error(message);
+    },
+    info(message) {
+      console.log(message);
+    }
+  };
+}
+function cloneMessages(messages) {
+  return JSON.parse(JSON.stringify(messages));
+}
+function slugifySegment(value) {
+  const normalized = value.normalize("NFKD").replace(/\p{M}+/gu, "").trim();
+  const parts = normalized.split(/[^\p{L}\p{N}]+/u).map((part) => part.trim()).filter(Boolean);
+  if (parts.length === 0) {
+    return "message";
+  }
+  const [head, ...tail] = parts;
+  return `${head.toLowerCase()}${tail.map((part) => `${part[0].toUpperCase()}${part.slice(1).toLowerCase()}`).join("")}`;
+}
+function createLeafKey(value, maxLength) {
+  const slug = slugifySegment(value);
+  if (slug.length <= maxLength) {
+    return slug;
+  }
+  return slug.slice(0, maxLength);
+}
+function deriveNamespace(configDirectory, sourcePath) {
+  const relativePath = path5.relative(configDirectory, sourcePath);
+  const withoutExtension = relativePath.slice(
+    0,
+    relativePath.length - path5.extname(relativePath).length
+  );
+  const rawSegments = withoutExtension.split(path5.sep).map((segment) => segment.trim()).filter(Boolean);
+  const segments = [...rawSegments];
+  while (segments.length > 1 && NAMESPACE_ROOTS.has(segments[0].toLowerCase())) {
+    segments.shift();
+  }
+  return segments.map((segment) => slugifySegment(segment)).join(".");
+}
+function getMessageValue(messages, keyPath) {
+  let current = messages;
+  for (const segment of keyPath.split(".")) {
+    if (!isRecord(current) || !Object.prototype.hasOwnProperty.call(current, segment)) {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return typeof current === "string" ? current : void 0;
+}
+function setMessageValue(messages, keyPath, value, logWarning) {
+  const segments = keyPath.split(".");
+  let current = messages;
+  for (const segment of segments.slice(0, -1)) {
+    const existing = Object.prototype.hasOwnProperty.call(current, segment) ? current[segment] : void 0;
+    if (existing !== void 0 && !isRecord(existing)) {
+      logWarning?.(
+        `key "${keyPath}" conflicts with existing leaf value at segment "${segment}"; skipping.`
+      );
+      return false;
+    }
+    if (!isRecord(existing)) {
+      current[segment] = {};
+    }
+    current = current[segment];
+  }
+  const finalSegment = segments[segments.length - 1];
+  const finalExisting = Object.prototype.hasOwnProperty.call(current, finalSegment) ? current[finalSegment] : void 0;
+  if (isRecord(finalExisting)) {
+    logWarning?.(
+      `key "${keyPath}" conflicts with existing nested object at "${finalSegment}"; skipping.`
+    );
+    return false;
+  }
+  current[finalSegment] = value;
+  return true;
+}
+function createScriptKind(sourcePath) {
+  const extension = path5.extname(sourcePath);
+  switch (extension) {
+    case ".js":
+    case ".cjs":
+    case ".mjs":
+      return ts2.ScriptKind.JS;
+    case ".jsx":
+      return ts2.ScriptKind.JSX;
+    case ".tsx":
+      return ts2.ScriptKind.TSX;
+    default:
+      return ts2.ScriptKind.TS;
+  }
+}
+function getLiteralArgument(node) {
+  if (ts2.isStringLiteral(node)) {
+    return node.text;
+  }
+  if (ts2.isNoSubstitutionTemplateLiteral(node)) {
+    return node.text;
+  }
+  return null;
+}
+function getObjectPropertyName(node) {
+  if (ts2.isIdentifier(node) || ts2.isStringLiteral(node)) {
+    return node.text;
+  }
+  return null;
+}
+function getBtMarkerState(node) {
+  if (!node) {
+    return "none";
+  }
+  if (!ts2.isObjectLiteralExpression(node)) {
+    return "none";
+  }
+  let sawBt = false;
+  for (const property of node.properties) {
+    if (!ts2.isPropertyAssignment(property)) {
+      continue;
+    }
+    const name = getObjectPropertyName(property.name);
+    if (name !== "bt") {
+      continue;
+    }
+    sawBt = true;
+    if (property.initializer.kind !== ts2.SyntaxKind.TrueKeyword) {
+      return "invalid";
+    }
+  }
+  return sawBt ? "valid" : "none";
+}
+function buildPreservedOptionsText(sourceFile, node) {
+  if (!node || !ts2.isObjectLiteralExpression(node)) {
+    return null;
+  }
+  const remainingProperties = node.properties.filter((property) => {
+    if (!ts2.isPropertyAssignment(property)) {
+      return true;
+    }
+    const name = getObjectPropertyName(property.name);
+    return name !== "bt";
+  });
+  if (remainingProperties.length === 0) {
+    return null;
+  }
+  const printer = ts2.createPrinter();
+  const objectLiteral = ts2.factory.updateObjectLiteralExpression(
+    node,
+    remainingProperties
+  );
+  return printer.printNode(
+    ts2.EmitHint.Unspecified,
+    objectLiteral,
+    sourceFile
+  );
+}
+function createWarning(sourceFile, node, message) {
+  const position = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+  return `${sourceFile.fileName}:${position.line + 1}: ${message}`;
+}
+function analyzeFile(options) {
+  const { configDirectory, maxLength, messages, sourcePath, sourceText } = options;
+  const sourceFile = ts2.createSourceFile(
+    sourcePath,
+    sourceText,
+    ts2.ScriptTarget.Latest,
+    true,
+    createScriptKind(sourcePath)
+  );
+  const namespace = deriveNamespace(configDirectory, sourcePath);
+  const literalCandidates = [];
+  const warnings = [];
+  const seenWarnings = /* @__PURE__ */ new Set();
+  const logWarning = (warning) => {
+    if (seenWarnings.has(warning)) {
+      return;
+    }
+    seenWarnings.add(warning);
+    warnings.push(warning);
+  };
+  const visit = (node) => {
+    if (!ts2.isCallExpression(node)) {
+      ts2.forEachChild(node, visit);
+      return;
+    }
+    const callee = node.expression;
+    const isIdentifierCall = ts2.isIdentifier(callee) && callee.text === "t";
+    const isPropertyCall = ts2.isPropertyAccessExpression(callee) && callee.name.text === "t";
+    if (!isIdentifierCall && !isPropertyCall) {
+      ts2.forEachChild(node, visit);
+      return;
+    }
+    const markerState = getBtMarkerState(node.arguments[1]);
+    if (markerState === "none") {
+      ts2.forEachChild(node, visit);
+      return;
+    }
+    if (markerState === "invalid") {
+      logWarning(
+        createWarning(
+          sourceFile,
+          node,
+          "skipped marked t() call because the bt marker must be written as bt: true."
+        )
+      );
+      ts2.forEachChild(node, visit);
+      return;
+    }
+    const firstArgument = node.arguments[0];
+    if (!firstArgument) {
+      logWarning(
+        createWarning(
+          sourceFile,
+          node,
+          "skipped marked t() call because the first argument is missing."
+        )
+      );
+      ts2.forEachChild(node, visit);
+      return;
+    }
+    const literalValue = getLiteralArgument(firstArgument);
+    if (literalValue === null) {
+      logWarning(
+        createWarning(
+          sourceFile,
+          node,
+          "skipped marked t() call because the first argument is not a static string literal."
+        )
+      );
+      ts2.forEachChild(node, visit);
+      return;
+    }
+    const leafKey = createLeafKey(literalValue, maxLength);
+    const fullKey = namespace ? `${namespace}.${leafKey}` : leafKey;
+    const nodeStart = node.getStart(sourceFile);
+    const nodeEnd = node.getEnd();
+    const overlapping = literalCandidates.some((existing) => {
+      const existingStart = existing.callExpression.getStart(sourceFile);
+      const existingEnd = existing.callExpression.getEnd();
+      return nodeStart < existingEnd && nodeEnd > existingStart;
+    });
+    if (overlapping) {
+      logWarning(
+        createWarning(
+          sourceFile,
+          node,
+          "skipped marked t() call because it overlaps with another marked t() call."
+        )
+      );
+      ts2.forEachChild(node, visit);
+      return;
+    }
+    literalCandidates.push({
+      callExpression: node,
+      fullKey,
+      rewrittenOptionsText: buildPreservedOptionsText(sourceFile, node.arguments[1]),
+      sourceValue: literalValue
+    });
+    ts2.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  const duplicateStrings = /* @__PURE__ */ new Set();
+  const duplicateCounts = /* @__PURE__ */ new Map();
+  for (const candidate of literalCandidates) {
+    duplicateCounts.set(
+      candidate.sourceValue,
+      (duplicateCounts.get(candidate.sourceValue) ?? 0) + 1
+    );
+  }
+  for (const [sourceValue, count] of duplicateCounts) {
+    if (count > 1) {
+      duplicateStrings.add(sourceValue);
+      logWarning(
+        `${sourcePath}: skipped ${count} marked t() calls for "${sourceValue}" because the same string appears more than once in the file.`
+      );
+    }
+  }
+  const collisionMap = /* @__PURE__ */ new Map();
+  for (const candidate of literalCandidates) {
+    const values = collisionMap.get(candidate.fullKey) ?? /* @__PURE__ */ new Set();
+    values.add(candidate.sourceValue);
+    collisionMap.set(candidate.fullKey, values);
+  }
+  const collidedKeys = /* @__PURE__ */ new Set();
+  for (const [key, values] of collisionMap) {
+    if (values.size > 1) {
+      collidedKeys.add(key);
+      logWarning(
+        `${sourcePath}: skipped marked t() calls for "${key}" because multiple strings would generate the same key.`
+      );
+    }
+  }
+  const successfulCandidates = [];
+  const addedKeys = [];
+  for (const candidate of literalCandidates) {
+    if (duplicateStrings.has(candidate.sourceValue)) {
+      continue;
+    }
+    if (collidedKeys.has(candidate.fullKey)) {
+      continue;
+    }
+    const existingValue = getMessageValue(messages, candidate.fullKey);
+    if (existingValue === void 0) {
+      const written = setMessageValue(
+        messages,
+        candidate.fullKey,
+        candidate.sourceValue,
+        logWarning
+      );
+      if (written) {
+        addedKeys.push(candidate.fullKey);
+        successfulCandidates.push(candidate);
+      }
+      continue;
+    }
+    if (existingValue !== candidate.sourceValue) {
+      logWarning(
+        `${sourcePath}: skipped marked t() call for "${candidate.fullKey}" because the key already exists with a different value.`
+      );
+      continue;
+    }
+    successfulCandidates.push(candidate);
+  }
+  if (successfulCandidates.length === 0) {
+    return {
+      addedKeys,
+      updatedSource: null,
+      warnings
+    };
+  }
+  const updatedSource = successfulCandidates.sort(
+    (left, right) => right.callExpression.getStart(sourceFile) - left.callExpression.getStart(sourceFile)
+  ).reduce((currentText, candidate) => {
+    const start = candidate.callExpression.getStart(sourceFile);
+    const end = candidate.callExpression.getEnd();
+    const expressionText = candidate.callExpression.expression.getText(sourceFile);
+    const replacement = candidate.rewrittenOptionsText ? `${expressionText}(${JSON.stringify(candidate.fullKey)}, ${candidate.rewrittenOptionsText})` : `${expressionText}(${JSON.stringify(candidate.fullKey)})`;
+    return `${currentText.slice(0, start)}${replacement}${currentText.slice(end)}`;
+  }, sourceText);
+  return {
+    addedKeys,
+    updatedSource: updatedSource === sourceText ? null : updatedSource,
+    warnings
+  };
+}
+async function collectSourceFiles(directory, ignoredPaths) {
+  const entries = (await readdir(directory, {
+    withFileTypes: true
+  })).sort((a, b) => a.name.localeCompare(b.name));
+  const files = [];
+  for (const entry of entries) {
+    const entryPath = path5.join(directory, entry.name);
+    if (ignoredPaths.has(entryPath)) {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      if (IGNORED_DIRECTORIES.has(entry.name)) {
+        continue;
+      }
+      files.push(...await collectSourceFiles(entryPath, ignoredPaths));
+      continue;
+    }
+    if (SOURCE_EXTENSIONS.has(path5.extname(entry.name))) {
+      files.push(entryPath);
+    }
+  }
+  return files;
+}
+async function extractProject(options = {}) {
+  const logger = options.logger ?? createDefaultLogger();
+  const dryRun = options.dryRun ?? false;
+  const maxLength = options.maxLength ?? DEFAULT_MAX_LENGTH;
+  assert(
+    Number.isInteger(maxLength) && maxLength > 0,
+    "--max-length must be a positive integer."
+  );
+  logger.info("Loading Better Translate config...");
+  const loadedConfig = await loadCliConfig({
+    configPath: options.configPath,
+    cwd: options.cwd
+  });
+  logger.info(`Using config: ${loadedConfig.path}`);
+  logger.info(`Source locale: ${loadedConfig.config.sourceLocale}`);
+  const loadedSourceMessages = await loadSourceMessages(
+    loadedConfig.config.messages.entry,
+    loadedConfig.config.sourceLocale
+  );
+  const messages = cloneMessages(loadedSourceMessages.messages);
+  const ignoredPaths = /* @__PURE__ */ new Set([loadedConfig.config.messages.entry]);
+  const sourcePaths = await collectSourceFiles(
+    loadedConfig.directory,
+    ignoredPaths
+  );
+  const rewrittenPaths = [];
+  const warnings = [];
+  const updatedKeys = [];
+  for (const sourcePath of sourcePaths) {
+    const sourceText = await readFile3(sourcePath, "utf8");
+    const analysis = analyzeFile({
+      configDirectory: loadedConfig.directory,
+      maxLength,
+      messages,
+      sourcePath,
+      sourceText
+    });
+    warnings.push(...analysis.warnings);
+    updatedKeys.push(...analysis.addedKeys);
+    if (!analysis.updatedSource) {
+      continue;
+    }
+    rewrittenPaths.push(sourcePath);
+    if (dryRun) {
+      logger.info(`[dry-run] rewrote ${sourcePath}`);
+      continue;
+    }
+    await writeFile2(sourcePath, analysis.updatedSource, "utf8");
+    logger.info(`rewrote ${sourcePath}`);
+  }
+  const hasMessageChanges = updatedKeys.length > 0 || JSON.stringify(messages) !== JSON.stringify(loadedSourceMessages.messages);
+  if (hasMessageChanges) {
+    const serialized = serializeMessages(
+      messages,
+      loadedSourceMessages.format,
+      loadedConfig.config.sourceLocale
+    );
+    if (loadedSourceMessages.format === "ts" && !loadedSourceMessages.sourceText.startsWith(
+      "// generated by @better-translate/cli"
+    )) {
+      logger.info(
+        `warn source messages file "${loadedConfig.config.messages.entry}" was not generated by the CLI; skipping update to avoid overwriting manual content. Use a .json source file or replace the file with a CLI-generated one.`
+      );
+    } else if (dryRun) {
+      logger.info(
+        `[dry-run] updated messages ${loadedConfig.config.messages.entry}`
+      );
+    } else {
+      await writeFile2(loadedConfig.config.messages.entry, serialized, "utf8");
+      logger.info(`updated messages ${loadedConfig.config.messages.entry}`);
+    }
+  }
+  for (const warning of warnings) {
+    logger.error(`warn ${warning}`);
+  }
+  const fileLabel = rewrittenPaths.length === 1 ? "file" : "files";
+  const keyLabel = updatedKeys.length === 1 ? "key" : "keys";
+  logger.info(
+    `processed ${rewrittenPaths.length} ${fileLabel} and synced ${updatedKeys.length} ${keyLabel}.`
+  );
+  return {
+    dryRun,
+    filePaths: rewrittenPaths,
+    loadedConfig,
+    updatedMessages: updatedKeys,
+    warnings
+  };
+}
+
 // src/generate.ts
-import { mkdir, writeFile as writeFile2 } from "fs/promises";
-import path6 from "path";
+import { mkdir, writeFile as writeFile3 } from "fs/promises";
+import path7 from "path";
 
 // src/markdown.ts
-import { readdir, readFile as readFile2 } from "fs/promises";
-import path4 from "path";
+import { readdir as readdir2, readFile as readFile4 } from "fs/promises";
+import path6 from "path";
 import matter from "gray-matter";
 async function walkDirectory(directory) {
-  const entries = await readdir(directory, {
+  const entries = await readdir2(directory, {
     withFileTypes: true
   });
   const files = await Promise.all(
     entries.map(async (entry) => {
-      const entryPath = path4.join(directory, entry.name);
+      const entryPath = path6.join(directory, entry.name);
       if (entry.isDirectory()) {
         return walkDirectory(entryPath);
       }
@@ -422,11 +1030,11 @@ async function listMarkdownSourceFiles(rootDir, extensions) {
   ).sort();
 }
 async function loadMarkdownDocument(rootDir, sourcePath) {
-  const sourceText = await readFile2(sourcePath, "utf8");
+  const sourceText = await readFile4(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("/");
+  const relativePath = path6.relative(rootDir, sourcePath).split(path6.sep).join("/");
   return {
     body: parsed.content,
     frontmatter,
@@ -438,109 +1046,20 @@ async function loadMarkdownDocument(rootDir, sourcePath) {
   };
 }
 function deriveTargetMarkdownRoot(rootDir, sourceLocale, targetLocale) {
-  const basename = path4.basename(rootDir);
+  const basename = path6.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);
+  return path6.join(path6.dirname(rootDir), targetLocale);
 }
 function deriveTargetMarkdownPath(rootDir, sourceLocale, targetLocale, relativePath) {
-  return path4.join(
+  return path6.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.",
@@ -638,10 +1157,10 @@ async function persistWrite(write, options) {
     );
     return;
   }
-  await mkdir(path6.dirname(write.targetPath), {
+  await mkdir(path7.dirname(write.targetPath), {
     recursive: true
   });
-  await writeFile2(write.targetPath, write.content, "utf8");
+  await writeFile3(write.targetPath, write.content, "utf8");
   options.logger.info(
     `wrote ${write.kind}:${write.locale} ${write.targetPath}`
   );
@@ -654,7 +1173,7 @@ function prepareGatewayEnvironment(apiKey) {
   process.env.AI_GATEWAY_API_KEY = apiKey;
 }
 async function createDefaultGenerator(model) {
-  const { generateWithAiSdk } = await import("./ai-sdk-generator-WPQCTPGA.js");
+  const { generateWithAiSdk } = await import("./ai-sdk-generator-F2X3W7NC.js");
   return async (request) => generateWithAiSdk(model, request);
 }
 async function resolveRuntimeModel(config) {
@@ -665,13 +1184,9 @@ async function resolveRuntimeModel(config) {
       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)
+    description: `Using configured provider model: ${config.model.provider}/${config.model.modelId}`,
+    model: config.model
   };
 }
 function validateMarkdownTranslation(frontmatterStrings, value) {
@@ -850,5 +1365,6 @@ async function generateProject(options = {}) {
 
 export {
   loadCliConfig,
+  extractProject,
   generateProject
 };