translate-kit 0.1.0

package/dist/cli.js

@@ -0,0 +1,2548 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config.ts
+import { loadConfig } from "c12";
+import { z } from "zod";
+async function loadTranslateKitConfig() {
+  const { config } = await loadConfig({
+    name: "translate-kit"
+  });
+  if (!config || Object.keys(config).length === 0) {
+    throw new Error(
+      "No config found. Create a translate-kit.config.ts file or run `translate-kit init`."
+    );
+  }
+  const result = configSchema.safeParse(config);
+  if (!result.success) {
+    const errors = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new Error(`Invalid config:
+${errors}`);
+  }
+  return result.data;
+}
+var configSchema;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    configSchema = z.object({
+      model: z.custom(
+        (val) => val != null && typeof val === "object",
+        { message: "model must be an AI SDK LanguageModel instance" }
+      ),
+      mode: z.enum(["keys", "inline"]).default("keys"),
+      sourceLocale: z.string().min(1),
+      targetLocales: z.array(z.string().min(1)).min(1),
+      messagesDir: z.string().min(1),
+      translation: z.object({
+        batchSize: z.number().int().positive().default(50),
+        context: z.string().optional(),
+        glossary: z.record(z.string()).optional(),
+        tone: z.string().optional(),
+        retries: z.number().int().min(0).default(2),
+        concurrency: z.number().int().positive().default(3)
+      }).optional(),
+      scan: z.object({
+        include: z.array(z.string()),
+        exclude: z.array(z.string()).optional(),
+        keyStrategy: z.enum(["hash", "path"]).default("hash"),
+        translatableProps: z.array(z.string()).default(["placeholder", "title", "alt", "aria-label"]),
+        i18nImport: z.string().default("next-intl")
+      }).optional(),
+      inline: z.object({
+        componentPath: z.string().min(1)
+      }).optional()
+    }).refine((data) => data.mode !== "inline" || data.inline != null, {
+      message: "inline options are required when mode is 'inline'",
+      path: ["inline"]
+    });
+  }
+});
+
+// src/flatten.ts
+function flatten(obj, prefix = "") {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (typeof value === "string") {
+      result[fullKey] = value;
+    } else if (value != null && typeof value === "object" && !Array.isArray(value)) {
+      Object.assign(result, flatten(value, fullKey));
+    }
+  }
+  return result;
+}
+function unflatten(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const parts = key.split(".");
+    let current = result;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (part in current && typeof current[part] !== "object") {
+        console.warn(
+          `[translate-kit] Key conflict: "${parts.slice(0, i + 1).join(".")}" is a value but "${key}" expects it to be an object`
+        );
+        current[part] = {};
+      } else if (!(part in current)) {
+        current[part] = {};
+      }
+      current = current[part];
+    }
+    current[parts[parts.length - 1]] = value;
+  }
+  return result;
+}
+var init_flatten = __esm({
+  "src/flatten.ts"() {
+    "use strict";
+  }
+});
+
+// src/diff.ts
+import { createHash } from "crypto";
+import { readFile } from "fs/promises";
+import { join } from "path";
+function hashValue(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 16);
+}
+function isFileNotFound(err) {
+  return err instanceof Error && "code" in err && err.code === "ENOENT";
+}
+async function loadJsonFile(filePath) {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    if (isFileNotFound(err)) return {};
+    throw new Error(
+      `Failed to load ${filePath}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+async function loadLockFile(messagesDir) {
+  const lockPath = join(messagesDir, ".translate-lock.json");
+  try {
+    const content = await readFile(lockPath, "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    if (isFileNotFound(err)) return {};
+    throw new Error(
+      `Failed to load lock file: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function computeDiff(sourceFlat, targetFlat, lockData) {
+  const added = {};
+  const modified = {};
+  const removed = [];
+  const unchanged = {};
+  for (const [key, value] of Object.entries(sourceFlat)) {
+    const currentHash = hashValue(value);
+    const lockedHash = lockData[key];
+    if (!(key in targetFlat)) {
+      added[key] = value;
+    } else if (!lockedHash || lockedHash !== currentHash) {
+      modified[key] = value;
+    } else {
+      unchanged[key] = targetFlat[key];
+    }
+  }
+  for (const key of Object.keys(targetFlat)) {
+    if (!(key in sourceFlat)) {
+      removed.push(key);
+    }
+  }
+  return { added, modified, removed, unchanged };
+}
+var init_diff = __esm({
+  "src/diff.ts"() {
+    "use strict";
+    init_flatten();
+  }
+});
+
+// src/translate.ts
+import { generateObject } from "ai";
+import { z as z2 } from "zod";
+import pLimit from "p-limit";
+function buildPrompt(entries, sourceLocale, targetLocale, options) {
+  const lines = [
+    `Translate the following strings from "${sourceLocale}" to "${targetLocale}".`,
+    "",
+    "Rules:",
+    "- Preserve all placeholders like {name}, {{count}}, %s, %d exactly as-is",
+    "- Preserve HTML tags and markdown formatting",
+    "- Do NOT translate proper nouns, brand names, or technical identifiers",
+    "- Maintain the same level of formality and register",
+    "- Return natural, fluent translations (not word-for-word)"
+  ];
+  if (options?.tone) {
+    lines.push(`- Use a ${options.tone} tone`);
+  }
+  if (options?.context) {
+    lines.push(`
+Context: ${options.context}`);
+  }
+  if (options?.glossary && Object.keys(options.glossary).length > 0) {
+    lines.push("\nGlossary (use these exact translations):");
+    for (const [term, translation] of Object.entries(options.glossary)) {
+      lines.push(`  "${term}" \u2192 "${translation}"`);
+    }
+  }
+  lines.push("\nStrings to translate:");
+  for (const [key, value] of Object.entries(entries)) {
+    lines.push(`  "${key}": "${value}"`);
+  }
+  return lines.join("\n");
+}
+function buildSchema(keys) {
+  const shape = {};
+  for (const key of keys) {
+    shape[key] = z2.string();
+  }
+  return z2.object(shape);
+}
+async function translateBatchWithRetry(input, retries) {
+  const { model, entries, sourceLocale, targetLocale, options } = input;
+  const keys = Object.keys(entries);
+  const prompt = buildPrompt(entries, sourceLocale, targetLocale, options);
+  const schema = buildSchema(keys);
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      const { object } = await generateObject({
+        model,
+        prompt,
+        schema
+      });
+      return object;
+    } catch (error) {
+      lastError = error;
+      if (attempt < retries) {
+        const delay = Math.min(Math.pow(2, attempt) * 1e3, 3e4);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+  throw lastError;
+}
+async function translateAll(input) {
+  const {
+    model,
+    entries,
+    sourceLocale,
+    targetLocale,
+    options,
+    onBatchComplete
+  } = input;
+  const keys = Object.keys(entries);
+  if (keys.length === 0) return {};
+  const batchSize = options?.batchSize ?? 50;
+  const concurrency = options?.concurrency ?? 3;
+  const retries = options?.retries ?? 2;
+  const limit = pLimit(concurrency);
+  const batches = [];
+  for (let i = 0; i < keys.length; i += batchSize) {
+    const batchKeys = keys.slice(i, i + batchSize);
+    const batch = {};
+    for (const key of batchKeys) {
+      batch[key] = entries[key];
+    }
+    batches.push(batch);
+  }
+  const results = {};
+  await Promise.all(
+    batches.map(
+      (batch) => limit(async () => {
+        const translated = await translateBatchWithRetry(
+          { model, entries: batch, sourceLocale, targetLocale, options },
+          retries
+        );
+        Object.assign(results, translated);
+        onBatchComplete?.(translated);
+      })
+    )
+  );
+  return results;
+}
+var init_translate = __esm({
+  "src/translate.ts"() {
+    "use strict";
+  }
+});
+
+// src/writer.ts
+import { writeFile, mkdir } from "fs/promises";
+import { join as join2, dirname } from "path";
+async function writeTranslation(filePath, flatEntries, options) {
+  await mkdir(dirname(filePath), { recursive: true });
+  const data = options?.flat ? flatEntries : unflatten(flatEntries);
+  const content = JSON.stringify(data, null, 2) + "\n";
+  await writeFile(filePath, content, "utf-8");
+}
+async function writeLockFile(messagesDir, sourceFlat, existingLock, translatedKeys) {
+  const lock = { ...existingLock };
+  for (const key of translatedKeys) {
+    if (key in sourceFlat) {
+      lock[key] = hashValue(sourceFlat[key]);
+    }
+  }
+  for (const key of Object.keys(lock)) {
+    if (!(key in sourceFlat)) {
+      delete lock[key];
+    }
+  }
+  const lockPath = join2(messagesDir, ".translate-lock.json");
+  await mkdir(dirname(lockPath), { recursive: true });
+  const content = JSON.stringify(lock, null, 2) + "\n";
+  await writeFile(lockPath, content, "utf-8");
+}
+var init_writer = __esm({
+  "src/writer.ts"() {
+    "use strict";
+    init_flatten();
+    init_diff();
+  }
+});
+
+// src/scanner/parser.ts
+import { parse } from "@babel/parser";
+function parseFile(code, filename) {
+  return parse(code, {
+    sourceType: "module",
+    plugins: filename.endsWith(".tsx") || filename.endsWith(".ts") ? plugins : plugins.filter((p2) => p2 !== "typescript"),
+    sourceFilename: filename
+  });
+}
+var plugins;
+var init_parser = __esm({
+  "src/scanner/parser.ts"() {
+    "use strict";
+    plugins = ["typescript", "jsx", "decorators-legacy"];
+  }
+});
+
+// src/scanner/filters.ts
+function isContentProperty(propName) {
+  return CONTENT_PROPERTY_NAMES.includes(propName);
+}
+function isTranslatableProp(propName, customProps) {
+  if (NEVER_TRANSLATE_PROPS.includes(propName)) return false;
+  const allowed = customProps ?? DEFAULT_TRANSLATABLE_PROPS;
+  return allowed.includes(propName);
+}
+function isIgnoredTag(tagName) {
+  return IGNORE_TAGS.includes(tagName.toLowerCase());
+}
+function shouldIgnore(text2) {
+  const trimmed = text2.trim();
+  if (trimmed.length === 0) return true;
+  return IGNORE_PATTERNS.some((pattern) => pattern.test(trimmed));
+}
+var DEFAULT_TRANSLATABLE_PROPS, NEVER_TRANSLATE_PROPS, IGNORE_TAGS, IGNORE_PATTERNS, CONTENT_PROPERTY_NAMES;
+var init_filters = __esm({
+  "src/scanner/filters.ts"() {
+    "use strict";
+    DEFAULT_TRANSLATABLE_PROPS = [
+      "placeholder",
+      "title",
+      "alt",
+      "aria-label",
+      "aria-description",
+      "aria-placeholder",
+      "label"
+    ];
+    NEVER_TRANSLATE_PROPS = [
+      "className",
+      "class",
+      "id",
+      "key",
+      "ref",
+      "href",
+      "src",
+      "type",
+      "name",
+      "value",
+      "htmlFor",
+      "for",
+      "role",
+      "style",
+      "data-testid",
+      "data-cy",
+      "onClick",
+      "onChange",
+      "onSubmit",
+      "onFocus",
+      "onBlur"
+    ];
+    IGNORE_TAGS = [
+      "script",
+      "style",
+      "code",
+      "pre",
+      "svg",
+      "path",
+      "circle",
+      "rect",
+      "line",
+      "polyline",
+      "polygon"
+    ];
+    IGNORE_PATTERNS = [
+      /^\s*$/,
+      // Whitespace only
+      /^https?:\/\//,
+      // URLs
+      /^[a-z]+(-[a-z]+)+$/,
+      // kebab-case identifiers
+      /^[A-Z_]+$/,
+      // CONSTANT_CASE
+      /^[\d.,%$€£¥]+$/,
+      // Numbers, currency
+      /^[^a-zA-Z]*$/
+      // No letters at all
+    ];
+    CONTENT_PROPERTY_NAMES = [
+      "title",
+      "description",
+      "label",
+      "text",
+      "content",
+      "heading",
+      "subtitle",
+      "caption",
+      "summary",
+      "message",
+      "placeholder",
+      "alt"
+    ];
+  }
+});
+
+// src/utils/ast-helpers.ts
+function resolveDefault(mod) {
+  if (typeof mod === "function") return mod;
+  return mod.default;
+}
+function isInsideFunction(path) {
+  let current = path.parentPath;
+  while (current) {
+    if (current.isFunctionDeclaration() || current.isFunctionExpression() || current.isArrowFunctionExpression()) {
+      return true;
+    }
+    current = current.parentPath;
+  }
+  return false;
+}
+function getComponentName(path) {
+  let current = path;
+  while (current) {
+    if (current.isFunctionDeclaration() && current.node.id) {
+      return current.node.id.name;
+    }
+    if (current.isVariableDeclarator() && current.node.id?.type === "Identifier") {
+      const init = current.node.init;
+      if (init && (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression")) {
+        return current.node.id.name;
+      }
+    }
+    if (current.isExportDefaultDeclaration()) {
+      const decl = current.node.declaration;
+      if (decl.type === "FunctionDeclaration" && decl.id) {
+        return decl.id.name;
+      }
+    }
+    current = current.parentPath;
+  }
+  return void 0;
+}
+function getParentTagName(path) {
+  let current = path.parentPath;
+  while (current) {
+    if (current.isJSXElement()) {
+      const opening = current.node.openingElement;
+      if (opening.name.type === "JSXIdentifier") {
+        return opening.name.name;
+      }
+      if (opening.name.type === "JSXMemberExpression" && opening.name.object.type === "JSXIdentifier") {
+        return `${opening.name.object.name}.${opening.name.property.name}`;
+      }
+    }
+    current = current.parentPath;
+  }
+  return void 0;
+}
+var init_ast_helpers = __esm({
+  "src/utils/ast-helpers.ts"() {
+    "use strict";
+  }
+});
+
+// src/scanner/extractor.ts
+import _traverse from "@babel/traverse";
+function extractStrings(ast, filePath, translatableProps) {
+  const results = [];
+  traverse(ast, {
+    JSXText(path) {
+      const text2 = path.node.value.trim();
+      if (shouldIgnore(text2)) return;
+      const parentTag = getParentTagName(path);
+      if (parentTag && isIgnoredTag(parentTag)) return;
+      if (parentTag === "T") return;
+      results.push({
+        text: text2,
+        type: "jsx-text",
+        file: filePath,
+        line: path.node.loc?.start.line ?? 0,
+        column: path.node.loc?.start.column ?? 0,
+        componentName: getComponentName(path),
+        parentTag
+      });
+    },
+    JSXAttribute(path) {
+      const name = path.node.name;
+      const propName = name.type === "JSXIdentifier" ? name.name : name.name.name;
+      if (!isTranslatableProp(propName, translatableProps)) return;
+      const value = path.node.value;
+      if (!value) return;
+      let text2;
+      if (value.type === "StringLiteral") {
+        text2 = value.value;
+      } else if (value.type === "JSXExpressionContainer" && value.expression.type === "StringLiteral") {
+        text2 = value.expression.value;
+      }
+      if (!text2 || shouldIgnore(text2)) return;
+      const parentTag = getParentTagName(path);
+      if (parentTag && isIgnoredTag(parentTag)) return;
+      results.push({
+        text: text2,
+        type: "jsx-attribute",
+        file: filePath,
+        line: path.node.loc?.start.line ?? 0,
+        column: path.node.loc?.start.column ?? 0,
+        componentName: getComponentName(path),
+        propName,
+        parentTag
+      });
+    },
+    JSXExpressionContainer(path) {
+      const expr = path.node.expression;
+      if (expr.type !== "StringLiteral") return;
+      const text2 = expr.value.trim();
+      if (shouldIgnore(text2)) return;
+      if (path.parent.type === "JSXAttribute") return;
+      const parentTag = getParentTagName(path);
+      if (parentTag && isIgnoredTag(parentTag)) return;
+      results.push({
+        text: text2,
+        type: "jsx-expression",
+        file: filePath,
+        line: path.node.loc?.start.line ?? 0,
+        column: path.node.loc?.start.column ?? 0,
+        componentName: getComponentName(path),
+        parentTag
+      });
+    },
+    ObjectProperty(path) {
+      if (!isInsideFunction(path)) return;
+      const keyNode = path.node.key;
+      if (keyNode.type !== "Identifier" && keyNode.type !== "StringLiteral")
+        return;
+      const propName = keyNode.type === "Identifier" ? keyNode.name : keyNode.value;
+      if (!isContentProperty(propName)) return;
+      const valueNode = path.node.value;
+      if (valueNode.type !== "StringLiteral") return;
+      const text2 = valueNode.value.trim();
+      if (shouldIgnore(text2)) return;
+      results.push({
+        text: text2,
+        type: "object-property",
+        file: filePath,
+        line: valueNode.loc?.start.line ?? 0,
+        column: valueNode.loc?.start.column ?? 0,
+        componentName: getComponentName(path),
+        propName
+      });
+    },
+    CallExpression(path) {
+      const callee = path.node.callee;
+      if (callee.type !== "Identifier" || callee.name !== "t") return;
+      const args = path.node.arguments;
+      if (args.length === 0) return;
+      const firstArg = args[0];
+      if (firstArg.type !== "StringLiteral") return;
+      if (args.length >= 2 && args[1].type === "StringLiteral") {
+        results.push({
+          text: firstArg.value,
+          type: "t-call",
+          file: filePath,
+          line: path.node.loc?.start.line ?? 0,
+          column: path.node.loc?.start.column ?? 0,
+          componentName: getComponentName(path),
+          parentTag: getParentTagName(path),
+          id: args[1].value
+        });
+        return;
+      }
+      results.push({
+        text: firstArg.value,
+        type: "t-call",
+        file: filePath,
+        line: path.node.loc?.start.line ?? 0,
+        column: path.node.loc?.start.column ?? 0,
+        componentName: getComponentName(path),
+        parentTag: getParentTagName(path)
+      });
+    },
+    JSXElement(path) {
+      const opening = path.node.openingElement;
+      if (opening.name.type !== "JSXIdentifier" || opening.name.name !== "T")
+        return;
+      let id;
+      for (const attr of opening.attributes) {
+        if (attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && attr.name.name === "id" && attr.value?.type === "StringLiteral") {
+          id = attr.value.value;
+        }
+      }
+      let text2 = "";
+      for (const child of path.node.children) {
+        if (child.type === "JSXText") {
+          text2 += child.value;
+        }
+      }
+      text2 = text2.trim();
+      if (!text2) return;
+      results.push({
+        text: text2,
+        type: "T-component",
+        file: filePath,
+        line: path.node.loc?.start.line ?? 0,
+        column: path.node.loc?.start.column ?? 0,
+        componentName: getComponentName(path),
+        parentTag: getParentTagName(path),
+        id
+      });
+    }
+  });
+  return results;
+}
+var traverse;
+var init_extractor = __esm({
+  "src/scanner/extractor.ts"() {
+    "use strict";
+    init_filters();
+    init_ast_helpers();
+    traverse = resolveDefault(_traverse);
+  }
+});
+
+// src/scanner/key-generator.ts
+import { createHash as createHash2 } from "crypto";
+function slugify(text2) {
+  return text2.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "").slice(0, 32);
+}
+function generateKey(extracted, strategy) {
+  if (strategy === "hash") {
+    const hash = createHash2("sha256").update(extracted.text).digest("hex").slice(0, 12);
+    return hash;
+  }
+  const parts = [];
+  if (extracted.componentName) {
+    parts.push(extracted.componentName);
+  }
+  if (extracted.parentTag) {
+    parts.push(extracted.parentTag);
+  }
+  const slug = slugify(extracted.text);
+  parts.push(slug);
+  return parts.join(".");
+}
+var init_key_generator = __esm({
+  "src/scanner/key-generator.ts"() {
+    "use strict";
+  }
+});
+
+// src/logger.ts
+import pc from "picocolors";
+function logStart(sourceLocale, targetLocales) {
+  console.log(
+    `
+${pc.bold("translate-kit")} ${pc.dim("\xB7")} ${sourceLocale} ${pc.dim("\u2192")} ${targetLocales.join(", ")}
+`
+  );
+}
+function logLocaleStart(locale) {
+  console.log(`${pc.cyan("\u25CF")} ${pc.bold(locale)}`);
+}
+function logLocaleResult(result) {
+  const parts = [];
+  if (result.translated > 0) {
+    parts.push(pc.green(`${result.translated} translated`));
+  }
+  if (result.cached > 0) {
+    parts.push(pc.dim(`${result.cached} cached`));
+  }
+  if (result.removed > 0) {
+    parts.push(pc.yellow(`${result.removed} removed`));
+  }
+  if (result.errors > 0) {
+    parts.push(pc.red(`${result.errors} errors`));
+  }
+  const time = pc.dim(`${(result.duration / 1e3).toFixed(1)}s`);
+  console.log(`  ${parts.join(pc.dim(" \xB7 "))} ${time}`);
+}
+function logSummary(results) {
+  const totalTranslated = results.reduce((s, r) => s + r.translated, 0);
+  const totalCached = results.reduce((s, r) => s + r.cached, 0);
+  const totalDuration = results.reduce((s, r) => s + r.duration, 0);
+  console.log(
+    `
+${pc.bold("Done!")} ${totalTranslated} keys translated, ${totalCached} cached ${pc.dim(`(${(totalDuration / 1e3).toFixed(1)}s)`)}
+`
+  );
+}
+function logDryRun(locale, added, modified, removed, unchanged) {
+  console.log(`${pc.cyan("\u25CF")} ${pc.bold(locale)} ${pc.dim("(dry run)")}`);
+  console.log(
+    `  ${pc.green(`+${added}`)} added, ${pc.yellow(`~${modified}`)} modified, ${pc.red(`-${removed}`)} removed, ${pc.dim(`${unchanged} unchanged`)}`
+  );
+}
+function logScanResult(total, files) {
+  console.log(
+    `
+${pc.bold("Scan complete:")} ${pc.green(`${total} strings`)} from ${files} files
+`
+  );
+}
+function logError(message) {
+  console.error(`${pc.red("\u2716")} ${message}`);
+}
+function logWarning(message) {
+  console.log(`${pc.yellow("\u26A0")} ${message}`);
+}
+function logInfo(message) {
+  console.log(`  ${message}`);
+}
+function logSuccess(message) {
+  console.log(`${pc.green("\u2714")} ${message}`);
+}
+function logVerbose(message, verbose) {
+  if (verbose) {
+    console.log(pc.dim(`  ${message}`));
+  }
+}
+var init_logger = __esm({
+  "src/logger.ts"() {
+    "use strict";
+  }
+});
+
+// src/scanner/index.ts
+import { readFile as readFile2 } from "fs/promises";
+import { glob } from "tinyglobby";
+async function scan(options, cwd = process.cwd()) {
+  const files = await glob(options.include, {
+    ignore: options.exclude ?? [],
+    cwd,
+    absolute: true
+  });
+  const allStrings = [];
+  const messages = {};
+  const keyStrategy = options.keyStrategy ?? "hash";
+  for (const filePath of files) {
+    const code = await readFile2(filePath, "utf-8");
+    let ast;
+    try {
+      ast = parseFile(code, filePath);
+    } catch (err) {
+      logVerbose(
+        `Skipping unparseable file ${filePath}: ${err instanceof Error ? err.message : String(err)}`,
+        true
+      );
+      continue;
+    }
+    const strings = extractStrings(ast, filePath, options.translatableProps);
+    for (const str of strings) {
+      const key = generateKey(str, keyStrategy);
+      if (!(key in messages)) {
+        messages[key] = str.text;
+      }
+      allStrings.push(str);
+    }
+  }
+  return {
+    strings: allStrings,
+    messages,
+    fileCount: files.length
+  };
+}
+var init_scanner = __esm({
+  "src/scanner/index.ts"() {
+    "use strict";
+    init_parser();
+    init_extractor();
+    init_key_generator();
+    init_logger();
+  }
+});
+
+// src/scanner/key-ai.ts
+import { generateObject as generateObject2 } from "ai";
+import { z as z3 } from "zod";
+import pLimit2 from "p-limit";
+function buildPrompt2(strings) {
+  const lines = [
+    "Generate semantic i18n keys for these UI strings.",
+    "",
+    "Rules:",
+    "- Use dot notation with max 2 levels (namespace.key)",
+    "- Group by feature/section based on file path and component",
+    "- Use camelCase for key segments",
+    '- Common UI strings use "common." prefix (Save, Cancel, Loading, Submit, Close, Delete, Edit, Back, Next, etc.)',
+    '- Auth-related use "auth." prefix (Sign in, Log out, Register, Forgot password, etc.)',
+    '- Navigation use "nav." prefix',
+    '- Form-related use "form." prefix for generic form labels',
+    '- Error messages use "error." prefix',
+    "- Be consistent: same text should always get the same key",
+    "- Keys should be concise but descriptive",
+    "",
+    "Strings:"
+  ];
+  for (let i = 0; i < strings.length; i++) {
+    const str = strings[i];
+    const parts = [`[${i}] "${str.text}"`];
+    if (str.componentName) parts.push(`component: ${str.componentName}`);
+    if (str.parentTag) parts.push(`tag: ${str.parentTag}`);
+    if (str.propName) parts.push(`prop: ${str.propName}`);
+    if (str.file) parts.push(`file: ${str.file}`);
+    lines.push(`  ${parts.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+async function generateKeysBatchWithRetry(model, strings, retries) {
+  const prompt = buildPrompt2(strings);
+  const texts = strings.map((s) => s.text);
+  const schema = z3.object({
+    mappings: z3.array(
+      z3.object({
+        index: z3.number().describe("Zero-based index of the string"),
+        key: z3.string().describe("Semantic i18n key")
+      })
+    )
+  });
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      const { object } = await generateObject2({
+        model,
+        prompt,
+        schema
+      });
+      const result = {};
+      for (const mapping of object.mappings) {
+        if (mapping.index >= 0 && mapping.index < texts.length) {
+          result[texts[mapping.index]] = mapping.key;
+        }
+      }
+      return result;
+    } catch (error) {
+      lastError = error;
+      if (attempt < retries) {
+        const delay = Math.min(Math.pow(2, attempt) * 1e3, 3e4);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+  throw lastError;
+}
+function resolveCollisions(newKeys, existingMap) {
+  const usedKeys = new Set(Object.values(existingMap));
+  const result = {};
+  for (const [text2, key] of Object.entries(newKeys)) {
+    let finalKey = key;
+    let suffix = 2;
+    while (usedKeys.has(finalKey)) {
+      finalKey = `${key}${suffix}`;
+      suffix++;
+    }
+    usedKeys.add(finalKey);
+    result[text2] = finalKey;
+  }
+  return result;
+}
+async function generateSemanticKeys(input) {
+  const {
+    model,
+    strings,
+    existingMap = {},
+    batchSize = 50,
+    concurrency = 3,
+    retries = 2
+  } = input;
+  const newStrings = strings.filter((s) => !(s.text in existingMap));
+  if (newStrings.length === 0) return { ...existingMap };
+  const uniqueMap = /* @__PURE__ */ new Map();
+  for (const str of newStrings) {
+    if (!uniqueMap.has(str.text)) {
+      uniqueMap.set(str.text, str);
+    }
+  }
+  const uniqueStrings = Array.from(uniqueMap.values());
+  const limit = pLimit2(concurrency);
+  const batches = [];
+  for (let i = 0; i < uniqueStrings.length; i += batchSize) {
+    batches.push(uniqueStrings.slice(i, i + batchSize));
+  }
+  const allNewKeys = {};
+  await Promise.all(
+    batches.map(
+      (batch) => limit(async () => {
+        const keys = await generateKeysBatchWithRetry(model, batch, retries);
+        Object.assign(allNewKeys, keys);
+      })
+    )
+  );
+  const resolved = resolveCollisions(allNewKeys, existingMap);
+  return { ...existingMap, ...resolved };
+}
+var init_key_ai = __esm({
+  "src/scanner/key-ai.ts"() {
+    "use strict";
+  }
+});
+
+// src/codegen/transform.ts
+import _traverse2 from "@babel/traverse";
+import _generate from "@babel/generator";
+import * as t from "@babel/types";
+function findLastImportIndex(ast) {
+  let idx = -1;
+  for (let i = 0; i < ast.program.body.length; i++) {
+    if (ast.program.body[i].type === "ImportDeclaration") {
+      idx = i;
+    }
+  }
+  return idx;
+}
+function hasUseTranslationsImport(ast, importSource) {
+  for (const node of ast.program.body) {
+    if (node.type === "ImportDeclaration" && node.source.value === importSource) {
+      for (const spec of node.specifiers) {
+        if (spec.type === "ImportSpecifier" && spec.imported.type === "Identifier" && spec.imported.name === "useTranslations") {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function hasUseTranslationsCall(ast) {
+  let found = false;
+  traverse2(ast, {
+    VariableDeclarator(path) {
+      const init = path.node.init;
+      if (init?.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "useTranslations") {
+        found = true;
+        path.stop();
+      }
+    },
+    noScope: true
+  });
+  return found;
+}
+function transform(ast, textToKey, options = {}) {
+  if (options.mode === "inline") {
+    return transformInline(ast, textToKey, options);
+  }
+  const importSource = options.i18nImport ?? "next-intl";
+  let stringsWrapped = 0;
+  const componentsNeedingT = /* @__PURE__ */ new Set();
+  traverse2(ast, {
+    JSXText(path) {
+      const text2 = path.node.value.trim();
+      if (!text2 || !(text2 in textToKey)) return;
+      const parent = path.parentPath;
+      if (!parent?.isJSXElement()) return;
+      const key = textToKey[text2];
+      const tCall = t.jsxExpressionContainer(
+        t.callExpression(t.identifier("t"), [t.stringLiteral(key)])
+      );
+      const siblings = parent.node.children.filter((child) => {
+        if (child.type === "JSXText") return child.value.trim().length > 0;
+        return true;
+      });
+      if (siblings.length === 1) {
+        path.replaceWith(tCall);
+      } else {
+        const raw = path.node.value;
+        const hasLeading = raw !== raw.trimStart();
+        const hasTrailing = raw !== raw.trimEnd();
+        const nodes = [];
+        if (hasLeading) {
+          nodes.push(t.jsxExpressionContainer(t.stringLiteral(" ")));
+        }
+        nodes.push(tCall);
+        if (hasTrailing) {
+          nodes.push(t.jsxExpressionContainer(t.stringLiteral(" ")));
+        }
+        path.replaceWithMultiple(nodes);
+      }
+      stringsWrapped++;
+      const compName = getComponentName(path);
+      if (compName) componentsNeedingT.add(compName);
+    },
+    JSXAttribute(path) {
+      const value = path.node.value;
+      if (!value) return;
+      let text2;
+      if (value.type === "StringLiteral") {
+        text2 = value.value;
+      } else if (value.type === "JSXExpressionContainer" && value.expression.type === "StringLiteral") {
+        text2 = value.expression.value;
+      }
+      if (!text2 || !(text2 in textToKey)) return;
+      if (value.type === "JSXExpressionContainer" && value.expression.type === "CallExpression" && value.expression.callee.type === "Identifier" && value.expression.callee.name === "t") {
+        return;
+      }
+      const key = textToKey[text2];
+      path.node.value = t.jsxExpressionContainer(
+        t.callExpression(t.identifier("t"), [t.stringLiteral(key)])
+      );
+      stringsWrapped++;
+      const compName = getComponentName(path);
+      if (compName) componentsNeedingT.add(compName);
+    },
+    ObjectProperty(path) {
+      if (!isInsideFunction(path)) return;
+      const keyNode = path.node.key;
+      if (keyNode.type !== "Identifier" && keyNode.type !== "StringLiteral")
+        return;
+      const propName = keyNode.type === "Identifier" ? keyNode.name : keyNode.value;
+      if (!isContentProperty(propName)) return;
+      const valueNode = path.node.value;
+      if (valueNode.type !== "StringLiteral") return;
+      const text2 = valueNode.value;
+      if (!text2 || !(text2 in textToKey)) return;
+      const key = textToKey[text2];
+      path.node.value = t.callExpression(t.identifier("t"), [
+        t.stringLiteral(key)
+      ]);
+      stringsWrapped++;
+      const compName = getComponentName(path);
+      if (compName) componentsNeedingT.add(compName);
+    }
+  });
+  if (stringsWrapped === 0) {
+    return { code: generate(ast).code, stringsWrapped: 0, modified: false };
+  }
+  if (!hasUseTranslationsImport(ast, importSource)) {
+    const importDecl = t.importDeclaration(
+      [
+        t.importSpecifier(
+          t.identifier("useTranslations"),
+          t.identifier("useTranslations")
+        )
+      ],
+      t.stringLiteral(importSource)
+    );
+    const lastImportIndex = findLastImportIndex(ast);
+    if (lastImportIndex >= 0) {
+      ast.program.body.splice(lastImportIndex + 1, 0, importDecl);
+    } else {
+      ast.program.body.unshift(importDecl);
+    }
+  }
+  if (!hasUseTranslationsCall(ast)) {
+    traverse2(ast, {
+      FunctionDeclaration(path) {
+        const name = path.node.id?.name;
+        if (!name || !componentsNeedingT.has(name)) return;
+        injectTDeclaration(path);
+      },
+      VariableDeclarator(path) {
+        if (path.node.id.type !== "Identifier") return;
+        const name = path.node.id.name;
+        if (!componentsNeedingT.has(name)) return;
+        const init = path.node.init;
+        if (!init) return;
+        if (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression") {
+          if (init.body.type === "BlockStatement") {
+            injectTIntoBlock(init.body);
+          }
+        }
+      },
+      noScope: true
+    });
+  }
+  const output = generate(ast, { retainLines: false });
+  return { code: output.code, stringsWrapped, modified: true };
+}
+function injectTDeclaration(path) {
+  const body = path.node.body;
+  if (body.type !== "BlockStatement") return;
+  injectTIntoBlock(body);
+}
+function injectTIntoBlock(block) {
+  for (const stmt of block.body) {
+    if (stmt.type === "VariableDeclaration" && stmt.declarations.some(
+      (d) => d.id.type === "Identifier" && d.id.name === "t" && d.init?.type === "CallExpression" && d.init.callee.type === "Identifier" && d.init.callee.name === "useTranslations"
+    )) {
+      return;
+    }
+  }
+  const tDecl = t.variableDeclaration("const", [
+    t.variableDeclarator(
+      t.identifier("t"),
+      t.callExpression(t.identifier("useTranslations"), [])
+    )
+  ]);
+  block.body.unshift(tDecl);
+}
+function isClientFile(ast) {
+  if (ast.program.directives) {
+    for (const directive of ast.program.directives) {
+      if (directive.value?.value === "use client") {
+        return true;
+      }
+    }
+  }
+  for (const node of ast.program.body) {
+    if (node.type === "ExpressionStatement" && node.expression.type === "StringLiteral" && node.expression.value === "use client") {
+      return true;
+    }
+  }
+  return false;
+}
+function hasInlineImport(ast, componentPath) {
+  let hasT = false;
+  let hasHook = false;
+  for (const node of ast.program.body) {
+    if (node.type !== "ImportDeclaration") continue;
+    const src = node.source.value;
+    if (src !== componentPath && src !== `${componentPath}-server` && src !== `${componentPath}/t-server`)
+      continue;
+    for (const spec of node.specifiers) {
+      if (spec.type === "ImportSpecifier" && spec.imported.type === "Identifier") {
+        if (spec.imported.name === "T") hasT = true;
+        if (spec.imported.name === "useT" || spec.imported.name === "createT")
+          hasHook = true;
+      }
+    }
+  }
+  return { hasT, hasHook };
+}
+function hasInlineHookCall(ast, hookName) {
+  let found = false;
+  traverse2(ast, {
+    VariableDeclarator(path) {
+      const init = path.node.init;
+      if (init?.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === hookName) {
+        found = true;
+        path.stop();
+      }
+    },
+    noScope: true
+  });
+  return found;
+}
+function transformInline(ast, textToKey, options) {
+  const componentPath = options.componentPath ?? "@/components/t";
+  const isClient = isClientFile(ast);
+  let stringsWrapped = 0;
+  const componentsNeedingT = /* @__PURE__ */ new Set();
+  let needsTComponent = false;
+  let repaired = false;
+  if (!isClient) {
+    traverse2(ast, {
+      CallExpression(path) {
+        if (path.node.callee.type === "Identifier" && path.node.callee.name === "createT" && path.node.arguments.length > 0 && path.node.arguments[0].type === "Identifier") {
+          const argName = path.node.arguments[0].name;
+          if (!path.scope.hasBinding(argName)) {
+            logWarning(
+              `Repaired createT(${argName}) \u2192 createT() \u2014 "${argName}" was not in scope`
+            );
+            path.node.arguments = [];
+            repaired = true;
+          }
+        }
+      }
+    });
+  }
+  traverse2(ast, {
+    JSXText(path) {
+      const text2 = path.node.value.trim();
+      if (!text2 || !(text2 in textToKey)) return;
+      const parent = path.parentPath;
+      if (!parent?.isJSXElement()) return;
+      const parentOpening = parent.node.openingElement;
+      if (parentOpening.name.type === "JSXIdentifier" && parentOpening.name.name === "T") {
+        return;
+      }
+      const key = textToKey[text2];
+      needsTComponent = true;
+      const tElement = t.jsxElement(
+        t.jsxOpeningElement(t.jsxIdentifier("T"), [
+          t.jsxAttribute(t.jsxIdentifier("id"), t.stringLiteral(key))
+        ]),
+        t.jsxClosingElement(t.jsxIdentifier("T")),
+        [t.jsxText(text2)],
+        false
+      );
+      const siblings = parent.node.children.filter((child) => {
+        if (child.type === "JSXText") return child.value.trim().length > 0;
+        return true;
+      });
+      if (siblings.length === 1) {
+        path.replaceWith(tElement);
+      } else {
+        const raw = path.node.value;
+        const hasLeading = raw !== raw.trimStart();
+        const hasTrailing = raw !== raw.trimEnd();
+        const nodes = [];
+        if (hasLeading) {
+          nodes.push(t.jsxExpressionContainer(t.stringLiteral(" ")));
+        }
+        nodes.push(tElement);
+        if (hasTrailing) {
+          nodes.push(t.jsxExpressionContainer(t.stringLiteral(" ")));
+        }
+        path.replaceWithMultiple(nodes);
+      }
+      stringsWrapped++;
+    },
+    JSXAttribute(path) {
+      const value = path.node.value;
+      if (!value) return;
+      let text2;
+      if (value.type === "StringLiteral") {
+        text2 = value.value;
+      } else if (value.type === "JSXExpressionContainer" && value.expression.type === "StringLiteral") {
+        text2 = value.expression.value;
+      }
+      if (!text2 || !(text2 in textToKey)) return;
+      if (value.type === "JSXExpressionContainer" && value.expression.type === "CallExpression" && value.expression.callee.type === "Identifier" && value.expression.callee.name === "t") {
+        return;
+      }
+      const key = textToKey[text2];
+      path.node.value = t.jsxExpressionContainer(
+        t.callExpression(t.identifier("t"), [
+          t.stringLiteral(text2),
+          t.stringLiteral(key)
+        ])
+      );
+      stringsWrapped++;
+      const compName = getComponentName(path);
+      if (compName) componentsNeedingT.add(compName);
+    },
+    ObjectProperty(path) {
+      if (!isInsideFunction(path)) return;
+      const keyNode = path.node.key;
+      if (keyNode.type !== "Identifier" && keyNode.type !== "StringLiteral")
+        return;
+      const propName = keyNode.type === "Identifier" ? keyNode.name : keyNode.value;
+      if (!isContentProperty(propName)) return;
+      const valueNode = path.node.value;
+      if (valueNode.type !== "StringLiteral") return;
+      const text2 = valueNode.value;
+      if (!text2 || !(text2 in textToKey)) return;
+      const key = textToKey[text2];
+      path.node.value = t.callExpression(t.identifier("t"), [
+        t.stringLiteral(text2),
+        t.stringLiteral(key)
+      ]);
+      stringsWrapped++;
+      const compName = getComponentName(path);
+      if (compName) componentsNeedingT.add(compName);
+    }
+  });
+  if (stringsWrapped === 0 && !repaired) {
+    return { code: generate(ast).code, stringsWrapped: 0, modified: false };
+  }
+  if (stringsWrapped === 0 && repaired) {
+    const output2 = generate(ast, { retainLines: false });
+    return { code: output2.code, stringsWrapped: 0, modified: true };
+  }
+  const needsHook = componentsNeedingT.size > 0;
+  const hookName = isClient ? "useT" : "createT";
+  const importPath = isClient ? componentPath : `${componentPath}-server`;
+  const existing = hasInlineImport(ast, componentPath);
+  const specifiers = [];
+  if (needsTComponent && !existing.hasT) {
+    specifiers.push(t.importSpecifier(t.identifier("T"), t.identifier("T")));
+  }
+  if (needsHook && !existing.hasHook) {
+    specifiers.push(
+      t.importSpecifier(t.identifier(hookName), t.identifier(hookName))
+    );
+  }
+  if (specifiers.length > 0) {
+    let appended = false;
+    for (const node of ast.program.body) {
+      if (node.type === "ImportDeclaration" && (node.source.value === importPath || node.source.value === componentPath)) {
+        node.specifiers.push(...specifiers);
+        node.source.value = importPath;
+        appended = true;
+        break;
+      }
+    }
+    if (!appended) {
+      const importDecl = t.importDeclaration(
+        specifiers,
+        t.stringLiteral(importPath)
+      );
+      const lastImportIndex = findLastImportIndex(ast);
+      if (lastImportIndex >= 0) {
+        ast.program.body.splice(lastImportIndex + 1, 0, importDecl);
+      } else {
+        let insertIdx = 0;
+        if (ast.program.body[0]?.type === "ExpressionStatement" && ast.program.body[0].expression.type === "StringLiteral" && ast.program.body[0].expression.value === "use client") {
+          insertIdx = 1;
+        }
+        ast.program.body.splice(insertIdx, 0, importDecl);
+      }
+    }
+  }
+  if (needsHook && !hasInlineHookCall(ast, hookName)) {
+    const hookCall = isClient ? t.callExpression(t.identifier("useT"), []) : t.callExpression(t.identifier("createT"), []);
+    traverse2(ast, {
+      FunctionDeclaration(path) {
+        const name = path.node.id?.name;
+        if (!name || !componentsNeedingT.has(name)) return;
+        const body = path.node.body;
+        if (body.type !== "BlockStatement") return;
+        injectInlineHookIntoBlock(body, hookCall);
+      },
+      VariableDeclarator(path) {
+        if (path.node.id.type !== "Identifier") return;
+        const name = path.node.id.name;
+        if (!componentsNeedingT.has(name)) return;
+        const init = path.node.init;
+        if (!init) return;
+        if (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression") {
+          if (init.body.type === "BlockStatement") {
+            injectInlineHookIntoBlock(init.body, hookCall);
+          }
+        }
+      },
+      noScope: true
+    });
+  }
+  const output = generate(ast, { retainLines: false });
+  return { code: output.code, stringsWrapped, modified: true };
+}
+function injectInlineHookIntoBlock(block, hookCall) {
+  for (const stmt of block.body) {
+    if (stmt.type === "VariableDeclaration" && stmt.declarations.some(
+      (d) => d.id.type === "Identifier" && d.id.name === "t" && d.init?.type === "CallExpression" && d.init.callee.type === "Identifier" && (d.init.callee.name === "useT" || d.init.callee.name === "createT")
+    )) {
+      return;
+    }
+  }
+  const tDecl = t.variableDeclaration("const", [
+    t.variableDeclarator(t.identifier("t"), hookCall)
+  ]);
+  block.body.unshift(tDecl);
+}
+var traverse2, generate;
+var init_transform = __esm({
+  "src/codegen/transform.ts"() {
+    "use strict";
+    init_filters();
+    init_ast_helpers();
+    init_logger();
+    traverse2 = resolveDefault(_traverse2);
+    generate = resolveDefault(_generate);
+  }
+});
+
+// src/codegen/index.ts
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { glob as glob2 } from "tinyglobby";
+async function codegen(options, cwd = process.cwd()) {
+  const files = await glob2(options.include, {
+    ignore: options.exclude ?? [],
+    cwd,
+    absolute: true
+  });
+  let filesModified = 0;
+  let stringsWrapped = 0;
+  const transformOpts = {
+    i18nImport: options.i18nImport,
+    mode: options.mode,
+    componentPath: options.componentPath
+  };
+  for (const filePath of files) {
+    const code = await readFile3(filePath, "utf-8");
+    let ast;
+    try {
+      ast = parseFile(code, filePath);
+    } catch (err) {
+      logVerbose(
+        `Skipping unparseable file ${filePath}: ${err instanceof Error ? err.message : String(err)}`,
+        true
+      );
+      continue;
+    }
+    const result = transform(ast, options.textToKey, transformOpts);
+    if (result.modified) {
+      await writeFile2(filePath, result.code, "utf-8");
+      filesModified++;
+      stringsWrapped += result.stringsWrapped;
+    }
+  }
+  return {
+    filesModified,
+    stringsWrapped,
+    filesProcessed: files.length
+  };
+}
+var init_codegen = __esm({
+  "src/codegen/index.ts"() {
+    "use strict";
+    init_parser();
+    init_transform();
+    init_logger();
+  }
+});
+
+// src/templates/t-component.ts
+function generateI18nHelper(opts) {
+  const allLocales = [opts.sourceLocale, ...opts.targetLocales];
+  const allLocalesStr = allLocales.map((l) => `"${l}"`).join(", ");
+  return `import { headers } from "next/headers";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+const supported = [${allLocalesStr}] as const;
+type Locale = (typeof supported)[number];
+const defaultLocale: Locale = "${opts.sourceLocale}";
+
+function parseAcceptLanguage(header: string): Locale {
+  const langs = header
+    .split(",")
+    .map((part) => {
+      const [lang, q] = part.trim().split(";q=");
+      return { lang: lang.split("-")[0].toLowerCase(), q: q ? parseFloat(q) : 1 };
+    })
+    .sort((a, b) => b.q - a.q);
+
+  for (const { lang } of langs) {
+    if (supported.includes(lang as Locale)) return lang as Locale;
+  }
+  return defaultLocale;
+}
+
+export async function getLocale(): Promise<Locale> {
+  const h = await headers();
+  const acceptLang = h.get("accept-language") ?? "";
+  return parseAcceptLanguage(acceptLang);
+}
+
+export async function getMessages(locale: string): Promise<Record<string, string>> {
+  if (locale === defaultLocale) return {};
+  try {
+    const filePath = join(process.cwd(), "${opts.messagesDir}", \`\${locale}.json\`);
+    const content = await readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+`;
+}
+var CLIENT_TEMPLATE, SERVER_TEMPLATE;
+var init_t_component = __esm({
+  "src/templates/t-component.ts"() {
+    "use strict";
+    CLIENT_TEMPLATE = `"use client";
+import { createContext, useContext, type ReactNode } from "react";
+
+type Messages = Record<string, string>;
+const I18nCtx = createContext<Messages>({});
+
+export function I18nProvider({ messages = {}, children }: { messages?: Messages; children: ReactNode }) {
+  return <I18nCtx.Provider value={messages}>{children}</I18nCtx.Provider>;
+}
+
+export function T({ id, children }: { id?: string; children: ReactNode }) {
+  const msgs = useContext(I18nCtx);
+  if (!id) return <>{children}</>;
+  return <>{msgs[id] ?? children}</>;
+}
+
+export function useT() {
+  const msgs = useContext(I18nCtx);
+  return (text: string, id?: string): string => {
+    if (!id) return text;
+    return msgs[id] ?? text;
+  };
+}
+`;
+    SERVER_TEMPLATE = `import type { ReactNode } from "react";
+
+type Messages = Record<string, string>;
+
+export function T({ id, children, messages = {} }: { id?: string; children: ReactNode; messages?: Messages }) {
+  if (!id) return <>{children}</>;
+  return <>{messages[id] ?? children}</>;
+}
+
+export function createT(messages: Messages = {}) {
+  return (text: string, id?: string): string => {
+    if (!id) return text;
+    return messages[id] ?? text;
+  };
+}
+`;
+  }
+});
+
+// src/init.ts
+var init_exports = {};
+__export(init_exports, {
+  runInitWizard: () => runInitWizard
+});
+import * as p from "@clack/prompts";
+import { existsSync } from "fs";
+import { join as join3, relative } from "path";
+import { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
+function detectIncludePatterns(cwd) {
+  const patterns = [];
+  if (existsSync(join3(cwd, "app")))
+    patterns.push("app/**/*.tsx", "app/**/*.jsx");
+  if (existsSync(join3(cwd, "src")))
+    patterns.push("src/**/*.tsx", "src/**/*.jsx");
+  if (existsSync(join3(cwd, "pages")))
+    patterns.push("pages/**/*.tsx", "pages/**/*.jsx");
+  if (existsSync(join3(cwd, "src", "app"))) {
+    return patterns.filter((p2) => !p2.startsWith("app/"));
+  }
+  return patterns.length > 0 ? patterns : ["**/*.tsx", "**/*.jsx"];
+}
+function cancel2() {
+  p.cancel("Setup cancelled.");
+  process.exit(0);
+}
+function findPackageInNodeModules(cwd, pkg) {
+  let dir = cwd;
+  const parts = pkg.split("/");
+  while (true) {
+    if (existsSync(join3(dir, "node_modules", ...parts, "package.json"))) {
+      return true;
+    }
+    const parent = join3(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return false;
+}
+async function ensurePackageInstalled(cwd, pkg, label) {
+  while (!findPackageInNodeModules(cwd, pkg)) {
+    p.log.warn(`${label} (${pkg}) is not installed.`);
+    const retry = await p.confirm({
+      message: `Install it now with your package manager, then press Enter. Continue?`
+    });
+    if (p.isCancel(retry) || !retry) cancel2();
+  }
+  p.log.success(`${label} found.`);
+}
+function generateConfigFile(opts) {
+  const provider = AI_PROVIDERS[opts.providerKey];
+  const lines = [];
+  lines.push(`import { ${provider.fn} } from "${provider.pkg}";`);
+  lines.push(``);
+  lines.push(`export default {`);
+  lines.push(`  model: ${provider.fn}("${opts.modelName}"),`);
+  if (opts.mode === "inline") {
+    lines.push(`  mode: "inline",`);
+  }
+  lines.push(`  sourceLocale: "${opts.sourceLocale}",`);
+  lines.push(
+    `  targetLocales: [${opts.targetLocales.map((l) => `"${l}"`).join(", ")}],`
+  );
+  lines.push(`  messagesDir: "${opts.messagesDir}",`);
+  const hasTranslation = opts.context || opts.tone !== "neutral";
+  if (hasTranslation) {
+    lines.push(`  translation: {`);
+    if (opts.context) {
+      lines.push(`    context: "${opts.context}",`);
+    }
+    if (opts.tone !== "neutral") {
+      lines.push(`    tone: "${opts.tone}",`);
+    }
+    lines.push(`  },`);
+  }
+  lines.push(`  scan: {`);
+  lines.push(
+    `    include: [${opts.includePatterns.map((p2) => `"${p2}"`).join(", ")}],`
+  );
+  lines.push(`    exclude: ["**/*.test.*", "**/*.spec.*"],`);
+  if (opts.mode === "keys" && opts.i18nImport) {
+    lines.push(`    i18nImport: "${opts.i18nImport}",`);
+  }
+  lines.push(`  },`);
+  if (opts.mode === "inline" && opts.componentPath) {
+    lines.push(`  inline: {`);
+    lines.push(`    componentPath: "${opts.componentPath}",`);
+    lines.push(`  },`);
+  }
+  lines.push(`};`);
+  lines.push(``);
+  return lines.join("\n");
+}
+function canParse(content, filePath) {
+  try {
+    parseFile(content, filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function safeWriteModifiedFile(filePath, original, modified, label) {
+  if (!canParse(modified, filePath)) {
+    p.log.warn(
+      `Could not safely modify ${label}. Please apply changes manually:
+  File: ${filePath}`
+    );
+    return false;
+  }
+  await writeFile3(filePath, modified, "utf-8");
+  return true;
+}
+function detectSrcDir(cwd) {
+  return existsSync(join3(cwd, "src", "app"));
+}
+function resolveComponentPath(cwd, componentPath) {
+  if (componentPath.startsWith("@/")) {
+    const rel = componentPath.slice(2);
+    const useSrc = existsSync(join3(cwd, "src"));
+    return join3(cwd, useSrc ? "src" : "", rel);
+  }
+  if (componentPath.startsWith("~/")) {
+    return join3(cwd, componentPath.slice(2));
+  }
+  return join3(cwd, componentPath);
+}
+function findLayoutFile(base) {
+  for (const ext of ["tsx", "jsx", "ts", "js"]) {
+    const candidate = join3(base, "app", `layout.${ext}`);
+    if (existsSync(candidate)) return candidate;
+  }
+  return void 0;
+}
+async function createEmptyMessageFiles(msgDir, locales) {
+  await mkdir2(msgDir, { recursive: true });
+  for (const locale of locales) {
+    const msgFile = join3(msgDir, `${locale}.json`);
+    if (!existsSync(msgFile)) {
+      await writeFile3(msgFile, "{}\n", "utf-8");
+    }
+  }
+}
+function insertImportsAfterLast(content, importLines) {
+  const lastImportIdx = content.lastIndexOf("import ");
+  const endOfLastImport = content.indexOf("\n", lastImportIdx);
+  return content.slice(0, endOfLastImport + 1) + importLines + content.slice(endOfLastImport + 1);
+}
+function ensureAsyncLayout(content) {
+  if (content.match(/async\s+function\s+\w*Layout/)) return content;
+  return content.replace(
+    /export\s+default\s+function\s+(\w*Layout)/,
+    "export default async function $1"
+  );
+}
+async function setupNextIntl(cwd, sourceLocale, targetLocales, messagesDir) {
+  const useSrc = detectSrcDir(cwd);
+  const base = useSrc ? join3(cwd, "src") : cwd;
+  const allLocales = [sourceLocale, ...targetLocales];
+  const filesCreated = [];
+  const i18nDir = join3(base, "i18n");
+  await mkdir2(i18nDir, { recursive: true });
+  const requestFile = join3(i18nDir, "request.ts");
+  if (!existsSync(requestFile)) {
+    const relMessages = relative(i18nDir, join3(cwd, messagesDir));
+    const allLocalesStr = allLocales.map((l) => `"${l}"`).join(", ");
+    await writeFile3(
+      requestFile,
+      `import { getRequestConfig } from "next-intl/server";
+import { headers } from "next/headers";
+
+const supported = [${allLocalesStr}] as const;
+type Locale = (typeof supported)[number];
+const defaultLocale: Locale = "${sourceLocale}";
+
+function parseAcceptLanguage(header: string): Locale {
+  const langs = header
+    .split(",")
+    .map((part) => {
+      const [lang, q] = part.trim().split(";q=");
+      return { lang: lang.split("-")[0].toLowerCase(), q: q ? parseFloat(q) : 1 };
+    })
+    .sort((a, b) => b.q - a.q);
+
+  for (const { lang } of langs) {
+    if (supported.includes(lang as Locale)) return lang as Locale;
+  }
+  return defaultLocale;
+}
+
+export default getRequestConfig(async () => {
+  const h = await headers();
+  const acceptLang = h.get("accept-language") ?? "";
+  const locale = parseAcceptLanguage(acceptLang);
+
+  return {
+    locale,
+    messages: (await import(\`${relMessages}/\${locale}.json\`)).default,
+  };
+});
+`,
+      "utf-8"
+    );
+    filesCreated.push(relative(cwd, requestFile));
+  }
+  const nextConfigPath = join3(cwd, "next.config.ts");
+  if (existsSync(nextConfigPath)) {
+    const content = await readFile4(nextConfigPath, "utf-8");
+    if (!content.includes("next-intl")) {
+      const importLine = `import createNextIntlPlugin from "next-intl/plugin";
+`;
+      const pluginLine = `const withNextIntl = createNextIntlPlugin();
+`;
+      const wrapped = content.replace(
+        /export default (.+?);/,
+        "export default withNextIntl($1);"
+      );
+      const updated = importLine + "\n" + pluginLine + "\n" + wrapped;
+      if (await safeWriteModifiedFile(
+        nextConfigPath,
+        content,
+        updated,
+        "next.config.ts"
+      )) {
+        filesCreated.push("next.config.ts (updated)");
+      }
+    }
+  }
+  const layoutPath = findLayoutFile(base);
+  if (layoutPath) {
+    let layoutContent = await readFile4(layoutPath, "utf-8");
+    if (!layoutContent.includes("NextIntlClientProvider")) {
+      const original = layoutContent;
+      const importLines = 'import { NextIntlClientProvider } from "next-intl";\nimport { getMessages } from "next-intl/server";\n';
+      layoutContent = insertImportsAfterLast(layoutContent, importLines);
+      layoutContent = ensureAsyncLayout(layoutContent);
+      layoutContent = layoutContent.replace(
+        /return\s*\(/,
+        "const messages = await getMessages();\n\n  return ("
+      );
+      layoutContent = layoutContent.replace(
+        /(<body[^>]*>)/,
+        "$1\n        <NextIntlClientProvider messages={messages}>"
+      );
+      layoutContent = layoutContent.replace(
+        /<\/body>/,
+        "  </NextIntlClientProvider>\n      </body>"
+      );
+      if (await safeWriteModifiedFile(
+        layoutPath,
+        original,
+        layoutContent,
+        "root layout"
+      )) {
+        filesCreated.push(relative(cwd, layoutPath) + " (updated)");
+      }
+    }
+  }
+  await createEmptyMessageFiles(join3(cwd, messagesDir), allLocales);
+  if (filesCreated.length > 0) {
+    p.log.success(`next-intl configured: ${filesCreated.join(", ")}`);
+  }
+}
+async function dropInlineComponents(cwd, componentPath) {
+  const fsPath = resolveComponentPath(cwd, componentPath);
+  const dir = join3(fsPath, "..");
+  await mkdir2(dir, { recursive: true });
+  const clientFile = `${fsPath}.tsx`;
+  const serverFile = `${fsPath}-server.tsx`;
+  await writeFile3(clientFile, CLIENT_TEMPLATE, "utf-8");
+  await writeFile3(serverFile, SERVER_TEMPLATE, "utf-8");
+  const relClient = relative(cwd, clientFile);
+  const relServer = relative(cwd, serverFile);
+  p.log.success(`Created inline components: ${relClient}, ${relServer}`);
+}
+async function setupInlineI18n(cwd, componentPath, sourceLocale, targetLocales, messagesDir) {
+  const useSrc = existsSync(join3(cwd, "src"));
+  const base = useSrc ? join3(cwd, "src") : cwd;
+  const filesCreated = [];
+  const i18nDir = join3(base, "i18n");
+  await mkdir2(i18nDir, { recursive: true });
+  const helperFile = join3(i18nDir, "index.ts");
+  if (!existsSync(helperFile)) {
+    const helperContent = generateI18nHelper({
+      sourceLocale,
+      targetLocales,
+      messagesDir
+    });
+    await writeFile3(helperFile, helperContent, "utf-8");
+    filesCreated.push(relative(cwd, helperFile));
+  }
+  const layoutPath = findLayoutFile(base);
+  if (layoutPath) {
+    let layoutContent = await readFile4(layoutPath, "utf-8");
+    if (!layoutContent.includes("I18nProvider")) {
+      const original = layoutContent;
+      const importLines = `import { I18nProvider } from "${componentPath}";
+import { getLocale, getMessages } from "@/i18n";
+`;
+      layoutContent = insertImportsAfterLast(layoutContent, importLines);
+      layoutContent = ensureAsyncLayout(layoutContent);
+      layoutContent = layoutContent.replace(
+        /return\s*\(/,
+        "const locale = await getLocale();\n	const messages = await getMessages(locale);\n\n	return ("
+      );
+      layoutContent = layoutContent.replace(
+        /(<body[^>]*>)/,
+        "$1\n				<I18nProvider messages={messages}>"
+      );
+      layoutContent = layoutContent.replace(
+        /<\/body>/,
+        "	</I18nProvider>\n			</body>"
+      );
+      if (await safeWriteModifiedFile(
+        layoutPath,
+        original,
+        layoutContent,
+        "root layout"
+      )) {
+        filesCreated.push(relative(cwd, layoutPath) + " (updated)");
+      }
+    }
+  }
+  await createEmptyMessageFiles(join3(cwd, messagesDir), [
+    sourceLocale,
+    ...targetLocales
+  ]);
+  if (filesCreated.length > 0) {
+    p.log.success(`Inline i18n configured: ${filesCreated.join(", ")}`);
+  }
+}
+async function runInitWizard() {
+  const cwd = process.cwd();
+  const configPath = join3(cwd, "translate-kit.config.ts");
+  p.intro("translate-kit setup");
+  if (existsSync(configPath)) {
+    const overwrite = await p.confirm({
+      message: "translate-kit.config.ts already exists. Overwrite?"
+    });
+    if (p.isCancel(overwrite)) cancel2();
+    if (!overwrite) {
+      p.outro("Keeping existing config.");
+      return;
+    }
+  }
+  const mode = await p.select({
+    message: "Translation mode:",
+    options: [
+      {
+        value: "keys",
+        label: "Keys mode",
+        hint: "t('key') + JSON files"
+      },
+      {
+        value: "inline",
+        label: "Inline mode",
+        hint: "<T id='key'>text</T>, text stays in code"
+      }
+    ]
+  });
+  if (p.isCancel(mode)) cancel2();
+  const providerKey = await p.select({
+    message: "AI provider:",
+    options: Object.entries(AI_PROVIDERS).map(([key, val]) => ({
+      value: key,
+      label: key.charAt(0).toUpperCase() + key.slice(1),
+      hint: val.pkg
+    }))
+  });
+  if (p.isCancel(providerKey)) cancel2();
+  const provider = AI_PROVIDERS[providerKey];
+  const modelName = await p.text({
+    message: "Model:",
+    initialValue: provider.defaultModel
+  });
+  if (p.isCancel(modelName)) cancel2();
+  const sourceLocale = await p.text({
+    message: "Source locale:",
+    initialValue: "en"
+  });
+  if (p.isCancel(sourceLocale)) cancel2();
+  const targetLocales = await p.multiselect({
+    message: "Target locales:",
+    options: LOCALE_OPTIONS.filter((o) => o.value !== sourceLocale),
+    required: true
+  });
+  if (p.isCancel(targetLocales)) cancel2();
+  const messagesDir = await p.text({
+    message: "Messages directory:",
+    initialValue: "./messages"
+  });
+  if (p.isCancel(messagesDir)) cancel2();
+  const detected = detectIncludePatterns(cwd);
+  let includePatterns;
+  const useDetected = await p.confirm({
+    message: `Detected: ${detected.join(", ")} \u2014 Use these patterns?`
+  });
+  if (p.isCancel(useDetected)) cancel2();
+  if (useDetected) {
+    includePatterns = detected;
+  } else {
+    const customPatterns = await p.text({
+      message: "Include patterns (comma-separated):",
+      initialValue: "src/**/*.tsx, src/**/*.jsx"
+    });
+    if (p.isCancel(customPatterns)) cancel2();
+    includePatterns = customPatterns.split(",").map((s) => s.trim());
+  }
+  let i18nImport = "";
+  let componentPath;
+  if (mode === "inline") {
+    const cp = await p.text({
+      message: "Component import path:",
+      initialValue: "@/components/t"
+    });
+    if (p.isCancel(cp)) cancel2();
+    componentPath = cp;
+  } else {
+    const lib = await p.text({
+      message: "i18n library:",
+      initialValue: "next-intl"
+    });
+    if (p.isCancel(lib)) cancel2();
+    i18nImport = lib;
+  }
+  const context = await p.text({
+    message: "Project context (optional, for better translations):",
+    placeholder: "e.g. E-commerce platform, SaaS dashboard"
+  });
+  if (p.isCancel(context)) cancel2();
+  const tone = await p.select({
+    message: "Tone:",
+    options: [
+      { value: "neutral", label: "Neutral" },
+      { value: "formal", label: "Formal" },
+      { value: "casual", label: "Casual" }
+    ]
+  });
+  if (p.isCancel(tone)) cancel2();
+  await ensurePackageInstalled(cwd, provider.pkg, "AI provider");
+  if (i18nImport) {
+    await ensurePackageInstalled(cwd, i18nImport, "i18n library");
+  }
+  const configContent = generateConfigFile({
+    providerKey,
+    modelName,
+    sourceLocale,
+    targetLocales,
+    messagesDir,
+    includePatterns,
+    i18nImport,
+    context: context ?? "",
+    tone,
+    mode,
+    componentPath
+  });
+  await writeFile3(configPath, configContent, "utf-8");
+  p.log.success("Created translate-kit.config.ts");
+  if (mode === "inline" && componentPath) {
+    await dropInlineComponents(cwd, componentPath);
+    await setupInlineI18n(
+      cwd,
+      componentPath,
+      sourceLocale,
+      targetLocales,
+      messagesDir
+    );
+  } else if (i18nImport === "next-intl") {
+    await setupNextIntl(cwd, sourceLocale, targetLocales, messagesDir);
+  }
+  const runPipeline = await p.confirm({
+    message: "Run the full pipeline now?"
+  });
+  if (p.isCancel(runPipeline)) cancel2();
+  if (!runPipeline) {
+    p.outro("You're all set! Run translate-kit scan when ready.");
+    return;
+  }
+  let config;
+  try {
+    config = await loadTranslateKitConfig();
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    p.log.error(`Failed to load config: ${errMsg}`);
+    p.outro("Config created but pipeline skipped.");
+    return;
+  }
+  const { model } = config;
+  const scanOptions = {
+    include: includePatterns,
+    exclude: ["**/*.test.*", "**/*.spec.*"],
+    i18nImport
+  };
+  const s1 = p.spinner();
+  s1.start("Scanning...");
+  const scanResult = await scan(scanOptions, cwd);
+  const transformableStrings = scanResult.strings.filter(
+    (s) => s.type === "jsx-text" || s.type === "jsx-attribute" || s.type === "object-property"
+  );
+  s1.stop(
+    `Scanning... ${transformableStrings.length} strings from ${scanResult.fileCount} files`
+  );
+  if (transformableStrings.length === 0) {
+    p.log.warn("No translatable strings found. Check your include patterns.");
+    p.outro("Config created, but no strings to process.");
+    return;
+  }
+  const resolvedMessagesDir = join3(cwd, messagesDir);
+  await mkdir2(resolvedMessagesDir, { recursive: true });
+  let existingMap = {};
+  const mapPath = join3(resolvedMessagesDir, ".translate-map.json");
+  try {
+    existingMap = JSON.parse(await readFile4(mapPath, "utf-8"));
+  } catch {
+  }
+  const s2 = p.spinner();
+  s2.start("Generating keys...");
+  const textToKey = await generateSemanticKeys({
+    model,
+    strings: transformableStrings,
+    existingMap,
+    batchSize: config.translation?.batchSize ?? 50,
+    concurrency: config.translation?.concurrency ?? 3,
+    retries: config.translation?.retries ?? 2
+  });
+  s2.stop("Generating keys... done");
+  await writeFile3(mapPath, JSON.stringify(textToKey, null, 2) + "\n", "utf-8");
+  const messages = {};
+  for (const [text2, key] of Object.entries(textToKey)) {
+    messages[key] = text2;
+  }
+  let sourceFlat;
+  if (mode === "inline") {
+    sourceFlat = messages;
+  } else {
+    const sourceFile = join3(resolvedMessagesDir, `${sourceLocale}.json`);
+    const nested = unflatten(messages);
+    await writeFile3(
+      sourceFile,
+      JSON.stringify(nested, null, 2) + "\n",
+      "utf-8"
+    );
+    sourceFlat = messages;
+  }
+  const s3 = p.spinner();
+  s3.start("Codegen...");
+  const codegenResult = await codegen(
+    {
+      include: includePatterns,
+      exclude: ["**/*.test.*", "**/*.spec.*"],
+      textToKey,
+      i18nImport,
+      mode,
+      componentPath
+    },
+    cwd
+  );
+  s3.stop(
+    `Codegen... ${codegenResult.stringsWrapped} strings wrapped in ${codegenResult.filesModified} files`
+  );
+  const postScan = await scan(scanOptions, cwd);
+  const keyToText = {};
+  for (const [text2, key] of Object.entries(textToKey)) {
+    keyToText[key] = text2;
+  }
+  const reconciledMessages = {};
+  if (mode === "inline") {
+    const tComponents = postScan.strings.filter(
+      (s) => s.type === "T-component" && s.id
+    );
+    const inlineTCalls = postScan.strings.filter(
+      (s) => s.type === "t-call" && s.id
+    );
+    for (const tc of tComponents) {
+      if (tc.id && tc.id in keyToText) {
+        reconciledMessages[tc.id] = keyToText[tc.id];
+      }
+    }
+    for (const tc of inlineTCalls) {
+      if (tc.id && tc.id in keyToText) {
+        reconciledMessages[tc.id] = keyToText[tc.id];
+      }
+    }
+  } else {
+    const tCalls = postScan.strings.filter((s) => s.type === "t-call");
+    for (const tCall of tCalls) {
+      const key = tCall.text;
+      if (key in keyToText) {
+        reconciledMessages[key] = keyToText[key];
+      }
+    }
+    const sourceFile = join3(resolvedMessagesDir, `${sourceLocale}.json`);
+    const reconciledNested = unflatten(reconciledMessages);
+    await writeFile3(
+      sourceFile,
+      JSON.stringify(reconciledNested, null, 2) + "\n",
+      "utf-8"
+    );
+  }
+  sourceFlat = reconciledMessages;
+  const translationOpts = config.translation ?? {};
+  for (const locale of targetLocales) {
+    const st = p.spinner();
+    st.start(`Translating ${locale}...`);
+    const translated = await translateAll({
+      model,
+      entries: sourceFlat,
+      sourceLocale,
+      targetLocale: locale,
+      options: translationOpts
+    });
+    const targetFile = join3(resolvedMessagesDir, `${locale}.json`);
+    await writeTranslation(targetFile, translated, { flat: mode === "inline" });
+    const lockData = await loadLockFile(resolvedMessagesDir);
+    await writeLockFile(
+      resolvedMessagesDir,
+      sourceFlat,
+      lockData,
+      Object.keys(translated)
+    );
+    st.stop(`Translating ${locale}... done`);
+  }
+  p.outro("You're all set!");
+}
+var AI_PROVIDERS, LOCALE_OPTIONS;
+var init_init = __esm({
+  "src/init.ts"() {
+    "use strict";
+    init_config();
+    init_scanner();
+    init_key_ai();
+    init_codegen();
+    init_translate();
+    init_writer();
+    init_diff();
+    init_flatten();
+    init_t_component();
+    init_parser();
+    AI_PROVIDERS = {
+      openai: {
+        pkg: "@ai-sdk/openai",
+        fn: "openai",
+        defaultModel: "gpt-4o-mini"
+      },
+      anthropic: {
+        pkg: "@ai-sdk/anthropic",
+        fn: "anthropic",
+        defaultModel: "claude-sonnet-4-20250514"
+      },
+      google: {
+        pkg: "@ai-sdk/google",
+        fn: "google",
+        defaultModel: "gemini-2.0-flash"
+      },
+      mistral: {
+        pkg: "@ai-sdk/mistral",
+        fn: "mistral",
+        defaultModel: "mistral-large-latest"
+      },
+      groq: {
+        pkg: "@ai-sdk/groq",
+        fn: "groq",
+        defaultModel: "llama-3.3-70b-versatile"
+      }
+    };
+    LOCALE_OPTIONS = [
+      { value: "es", label: "Spanish (es)" },
+      { value: "fr", label: "French (fr)" },
+      { value: "de", label: "German (de)" },
+      { value: "pt", label: "Portuguese (pt)" },
+      { value: "ja", label: "Japanese (ja)" },
+      { value: "zh", label: "Chinese (zh)" },
+      { value: "ko", label: "Korean (ko)" },
+      { value: "ru", label: "Russian (ru)" },
+      { value: "ar", label: "Arabic (ar)" },
+      { value: "it", label: "Italian (it)" }
+    ];
+  }
+});
+
+// src/cli.ts
+init_config();
+init_flatten();
+init_diff();
+init_translate();
+init_writer();
+init_scanner();
+init_key_ai();
+init_codegen();
+init_logger();
+import "dotenv/config";
+import { defineCommand, runMain } from "citty";
+import { join as join4 } from "path";
+import { readFile as readFile5, writeFile as writeFile4, mkdir as mkdir3 } from "fs/promises";
+async function loadMapFile(messagesDir) {
+  const mapPath = join4(messagesDir, ".translate-map.json");
+  try {
+    const content = await readFile5(mapPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function writeMapFile(messagesDir, map) {
+  const mapPath = join4(messagesDir, ".translate-map.json");
+  await mkdir3(messagesDir, { recursive: true });
+  const content = JSON.stringify(map, null, 2) + "\n";
+  await writeFile4(mapPath, content, "utf-8");
+}
+var translateCommand = defineCommand({
+  meta: {
+    name: "translate",
+    description: "Translate messages to target locales"
+  },
+  args: {
+    "dry-run": {
+      type: "boolean",
+      description: "Show what would be translated without executing",
+      default: false
+    },
+    force: {
+      type: "boolean",
+      description: "Ignore cache, re-translate everything",
+      default: false
+    },
+    locale: {
+      type: "string",
+      description: "Only translate a specific locale"
+    },
+    verbose: {
+      type: "boolean",
+      description: "Verbose output",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const config = await loadTranslateKitConfig();
+    const { sourceLocale, targetLocales, messagesDir, model } = config;
+    const opts = config.translation ?? {};
+    const verbose = args.verbose;
+    const mode = config.mode ?? "keys";
+    const locales = args.locale ? [args.locale] : targetLocales;
+    if (args.locale && !targetLocales.includes(args.locale)) {
+      logWarning(
+        `Locale "${args.locale}" is not in targetLocales [${targetLocales.join(", ")}]`
+      );
+    }
+    let sourceFlat;
+    if (mode === "inline") {
+      const mapData = await loadMapFile(messagesDir);
+      sourceFlat = {};
+      for (const [text2, key] of Object.entries(mapData)) {
+        sourceFlat[key] = text2;
+      }
+    } else {
+      const sourceFile = join4(messagesDir, `${sourceLocale}.json`);
+      const sourceRaw = await loadJsonFile(sourceFile);
+      sourceFlat = flatten(sourceRaw);
+    }
+    if (Object.keys(sourceFlat).length === 0) {
+      logError(
+        mode === "inline" ? `No keys found in .translate-map.json. Run 'translate-kit scan' first.` : `No keys found in ${join4(messagesDir, `${sourceLocale}.json`)}`
+      );
+      process.exit(1);
+    }
+    logStart(sourceLocale, locales);
+    const results = [];
+    for (const locale of locales) {
+      const start = Date.now();
+      const targetFile = join4(messagesDir, `${locale}.json`);
+      logLocaleStart(locale);
+      const targetRaw = await loadJsonFile(targetFile);
+      const targetFlat = flatten(targetRaw);
+      let lockData = await loadLockFile(messagesDir);
+      if (args.force) {
+        lockData = {};
+      }
+      const diffResult = computeDiff(sourceFlat, targetFlat, lockData);
+      const toTranslate = { ...diffResult.added, ...diffResult.modified };
+      if (args["dry-run"]) {
+        logDryRun(
+          locale,
+          Object.keys(diffResult.added).length,
+          Object.keys(diffResult.modified).length,
+          diffResult.removed.length,
+          Object.keys(diffResult.unchanged).length
+        );
+        continue;
+      }
+      let translated = {};
+      let errors = 0;
+      if (Object.keys(toTranslate).length > 0) {
+        try {
+          translated = await translateAll({
+            model,
+            entries: toTranslate,
+            sourceLocale,
+            targetLocale: locale,
+            options: opts,
+            onBatchComplete: (batch) => {
+              logVerbose(
+                `Batch complete: ${Object.keys(batch).length} keys`,
+                verbose
+              );
+            }
+          });
+        } catch (err) {
+          errors = Object.keys(toTranslate).length;
+          logError(
+            `Translation failed for ${locale}: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+      const finalFlat = {
+        ...diffResult.unchanged,
+        ...translated
+      };
+      await writeTranslation(targetFile, finalFlat, {
+        flat: mode === "inline"
+      });
+      const allTranslatedKeys = Object.keys(finalFlat);
+      const currentLock = await loadLockFile(messagesDir);
+      await writeLockFile(
+        messagesDir,
+        sourceFlat,
+        currentLock,
+        allTranslatedKeys
+      );
+      const result = {
+        locale,
+        translated: Object.keys(translated).length,
+        cached: Object.keys(diffResult.unchanged).length,
+        removed: diffResult.removed.length,
+        errors,
+        duration: Date.now() - start
+      };
+      logLocaleResult(result);
+      results.push(result);
+    }
+    if (!args["dry-run"]) {
+      logSummary(results);
+    }
+  }
+});
+var scanCommand = defineCommand({
+  meta: {
+    name: "scan",
+    description: "Scan source code for translatable strings"
+  },
+  args: {
+    "dry-run": {
+      type: "boolean",
+      description: "Show found strings without writing files",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const config = await loadTranslateKitConfig();
+    const mode = config.mode ?? "keys";
+    if (!config.scan) {
+      logError(
+        "No scan configuration found. Add a 'scan' section to your config."
+      );
+      process.exit(1);
+    }
+    const result = await scan(config.scan);
+    const bareStrings = result.strings.filter((s) => {
+      if (s.type === "t-call") return false;
+      if (s.type === "T-component" && s.id) return false;
+      return true;
+    });
+    logScanResult(bareStrings.length, result.fileCount);
+    if (args["dry-run"]) {
+      for (const str of bareStrings) {
+        logInfo(
+          `"${str.text}" (${str.componentName ?? "unknown"}, ${str.file})`
+        );
+      }
+      if (mode === "inline") {
+        logInfo(
+          "\n  Inline mode: no source locale JSON will be created. Source text remains in code."
+        );
+      }
+      return;
+    }
+    const existingMap = await loadMapFile(config.messagesDir);
+    if (mode === "inline") {
+      const existingTComponents = result.strings.filter(
+        (s) => s.type === "T-component" && s.id
+      );
+      for (const tc of existingTComponents) {
+        if (tc.id && !(tc.text in existingMap)) {
+          existingMap[tc.text] = tc.id;
+        }
+      }
+      const existingInlineTCalls = result.strings.filter(
+        (s) => s.type === "t-call" && s.id
+      );
+      for (const tc of existingInlineTCalls) {
+        if (tc.id && !(tc.text in existingMap)) {
+          existingMap[tc.text] = tc.id;
+        }
+      }
+    }
+    logInfo("Generating semantic keys...");
+    const textToKey = await generateSemanticKeys({
+      model: config.model,
+      strings: bareStrings,
+      existingMap,
+      batchSize: config.translation?.batchSize ?? 50,
+      concurrency: config.translation?.concurrency ?? 3,
+      retries: config.translation?.retries ?? 2
+    });
+    await writeMapFile(config.messagesDir, textToKey);
+    logSuccess(
+      `Written .translate-map.json (${Object.keys(textToKey).length} keys)`
+    );
+    if (mode === "inline") {
+      logInfo(
+        "Inline mode: source text stays in code, no source locale JSON created."
+      );
+    } else {
+      const messages = {};
+      for (const [text2, key] of Object.entries(textToKey)) {
+        messages[key] = text2;
+      }
+      const sourceFile = join4(
+        config.messagesDir,
+        `${config.sourceLocale}.json`
+      );
+      await mkdir3(config.messagesDir, { recursive: true });
+      const nested = unflatten(messages);
+      const content = JSON.stringify(nested, null, 2) + "\n";
+      await writeFile4(sourceFile, content, "utf-8");
+      logSuccess(`Written to ${sourceFile}`);
+    }
+  }
+});
+var codegenCommand = defineCommand({
+  meta: {
+    name: "codegen",
+    description: "Replace strings in source code with t() calls"
+  },
+  args: {
+    "dry-run": {
+      type: "boolean",
+      description: "Show what would be changed without modifying files",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const config = await loadTranslateKitConfig();
+    const mode = config.mode ?? "keys";
+    if (!config.scan) {
+      logError(
+        "No scan configuration found. Add a 'scan' section to your config."
+      );
+      process.exit(1);
+    }
+    const textToKey = await loadMapFile(config.messagesDir);
+    if (Object.keys(textToKey).length === 0) {
+      logError("No .translate-map.json found. Run 'translate-kit scan' first.");
+      process.exit(1);
+    }
+    if (args["dry-run"]) {
+      if (mode === "inline") {
+        logInfo(
+          `
+  Would wrap ${Object.keys(textToKey).length} strings with <T> components
+`
+        );
+        for (const [text2, key] of Object.entries(textToKey)) {
+          logInfo(`"${text2}" \u2192 <T id="${key}">${text2}</T>`);
+        }
+      } else {
+        logInfo(
+          `
+  Would replace ${Object.keys(textToKey).length} strings with t() calls
+`
+        );
+        for (const [text2, key] of Object.entries(textToKey)) {
+          logInfo(`"${text2}" \u2192 t("${key}")`);
+        }
+      }
+      return;
+    }
+    const result = await codegen({
+      include: config.scan.include,
+      exclude: config.scan.exclude,
+      textToKey,
+      i18nImport: config.scan.i18nImport,
+      mode,
+      componentPath: config.inline?.componentPath
+    });
+    logSuccess(
+      `Codegen complete: ${result.stringsWrapped} strings wrapped in ${result.filesModified} files (${result.filesProcessed} files processed)`
+    );
+  }
+});
+var initCommand = defineCommand({
+  meta: {
+    name: "init",
+    description: "Interactive setup wizard for translate-kit"
+  },
+  async run() {
+    const { runInitWizard: runInitWizard2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+    await runInitWizard2();
+  }
+});
+var main = defineCommand({
+  meta: {
+    name: "translate-kit",
+    version: "0.1.0",
+    description: "AI-powered translation SDK for build time"
+  },
+  subCommands: {
+    translate: translateCommand,
+    scan: scanCommand,
+    codegen: codegenCommand,
+    init: initCommand
+  },
+  // Default to translate command
+  async run({ rawArgs }) {
+    if (rawArgs.length === 0 || rawArgs[0]?.startsWith("-")) {
+      await translateCommand.run({
+        args: {
+          _: rawArgs,
+          "dry-run": false,
+          force: false,
+          verbose: false,
+          locale: ""
+        },
+        rawArgs,
+        cmd: translateCommand
+      });
+    }
+  }
+});
+runMain(main);
+//# sourceMappingURL=cli.js.map