@p6t/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1029 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { defineCommand as defineCommand5, runMain } from "citty";
+
+// src/commands/translate.ts
+import * as p from "@clack/prompts";
+import { defineCommand } from "citty";
+
+// src/config/loader.ts
+import fs from "fs";
+import path from "path";
+import { ConfigSchema } from "@p6t/config";
+var CONFIG_FILE = "i18n.json";
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+function findConfigFile(startDir) {
+  let dir = startDir;
+  while (true) {
+    const candidate = path.join(dir, CONFIG_FILE);
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function loadConfig(cwd = process.cwd()) {
+  const filePath = findConfigFile(cwd);
+  if (!filePath) {
+    throw new ConfigError(
+      `No ${CONFIG_FILE} found. Run \`p6t init\` to create one.`
+    );
+  }
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    throw new ConfigError(`Failed to parse ${filePath}`);
+  }
+  const result = ConfigSchema.safeParse(raw);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new ConfigError(`Invalid ${CONFIG_FILE}:
+${issues}`);
+  }
+  return result.data;
+}
+function getConfigDir(cwd = process.cwd()) {
+  const filePath = findConfigFile(cwd);
+  return filePath ? path.dirname(filePath) : cwd;
+}
+function resolveContextPath(template, locale, configDir) {
+  return path.resolve(configDir, template.replace("{locale}", locale));
+}
+
+// src/context/loader.ts
+import fs2 from "fs";
+function readFileSafe(filePath) {
+  try {
+    return fs2.readFileSync(filePath, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function readGlossary(filePath) {
+  const raw = readFileSafe(filePath);
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return Object.fromEntries(
+        Object.entries(parsed).flatMap(
+          ([k, v]) => typeof v === "string" ? [[k, v]] : []
+        )
+      );
+    }
+  } catch {
+  }
+  return {};
+}
+function loadContext(config, targetLocale, configDir) {
+  const descriptionPath = resolveContextPath(
+    config.context.description,
+    targetLocale,
+    configDir
+  );
+  const styleGuidePath = resolveContextPath(
+    config.context.styleGuide,
+    targetLocale,
+    configDir
+  );
+  const glossaryPath = resolveContextPath(
+    config.context.glossary,
+    targetLocale,
+    configDir
+  );
+  return {
+    description: readFileSafe(descriptionPath),
+    styleGuide: readFileSafe(styleGuidePath),
+    glossary: readGlossary(glossaryPath)
+  };
+}
+function formatGlossary(glossary) {
+  return Object.entries(glossary).map(([source, target]) => `${source} \u2192 ${target}`).join("\n");
+}
+
+// src/catalog/adapter.ts
+import fs3 from "fs";
+import path2 from "path";
+function detectFormat(configDir) {
+  const linguiConfigNames = [
+    "lingui.config.ts",
+    "lingui.config.js",
+    "lingui.config.mjs"
+  ];
+  for (const name of linguiConfigNames) {
+    if (fs3.existsSync(path2.join(configDir, name))) return "lingui";
+  }
+  return "lingui";
+}
+async function createAdapter(config, configDir) {
+  const format = config.format ?? detectFormat(configDir);
+  switch (format) {
+    case "lingui": {
+      const { createLinguiAdapter } = await import("./lingui-VSOT4HY4.js");
+      return createLinguiAdapter(configDir, config.catalogs);
+    }
+    case "react-intl": {
+      if (!config.catalogs || config.catalogs.length === 0) {
+        throw new Error(
+          'react-intl requires catalogs in i18n.json, e.g. [{ "path": "i18n/{locale}.json" }]'
+        );
+      }
+      const { createReactIntlAdapter } = await import("./react-intl-EIVHSW57.js");
+      return createReactIntlAdapter(configDir, config.catalogs);
+    }
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
+
+// src/llm/providers.ts
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createMistral } from "@ai-sdk/mistral";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenRouter } from "@openrouter/ai-sdk-provider";
+import { createOllama } from "ai-sdk-ollama";
+var ProviderError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ProviderError";
+  }
+};
+function createModel(provider) {
+  switch (provider.id) {
+    case "openai": {
+      const apiKey = process.env["OPENAI_API_KEY"];
+      if (!apiKey) throw new ProviderError("OPENAI_API_KEY env var is not set");
+      return createOpenAI({
+        apiKey,
+        ...provider.baseUrl !== void 0 ? { baseURL: provider.baseUrl } : {}
+      })(provider.model);
+    }
+    case "anthropic": {
+      const apiKey = process.env["ANTHROPIC_API_KEY"];
+      if (!apiKey)
+        throw new ProviderError("ANTHROPIC_API_KEY env var is not set");
+      return createAnthropic({
+        apiKey,
+        ...provider.baseUrl !== void 0 ? { baseURL: provider.baseUrl } : {}
+      })(provider.model);
+    }
+    case "google": {
+      const apiKey = process.env["GOOGLE_GENERATIVE_AI_API_KEY"] ?? process.env["GOOGLE_API_KEY"];
+      if (!apiKey)
+        throw new ProviderError(
+          "GOOGLE_GENERATIVE_AI_API_KEY (or GOOGLE_API_KEY) env var is not set"
+        );
+      return createGoogleGenerativeAI({
+        apiKey,
+        ...provider.baseUrl !== void 0 ? { baseURL: provider.baseUrl } : {}
+      })(provider.model);
+    }
+    case "mistral": {
+      const apiKey = process.env["MISTRAL_API_KEY"];
+      if (!apiKey)
+        throw new ProviderError("MISTRAL_API_KEY env var is not set");
+      return createMistral({
+        apiKey,
+        ...provider.baseUrl !== void 0 ? { baseURL: provider.baseUrl } : {}
+      })(provider.model);
+    }
+    case "ollama": {
+      return createOllama({
+        ...provider.baseUrl !== void 0 ? { baseURL: provider.baseUrl } : {}
+      })(provider.model);
+    }
+    case "openrouter": {
+      const apiKey = process.env["OPENROUTER_API_KEY"];
+      if (!apiKey)
+        throw new ProviderError("OPENROUTER_API_KEY env var is not set");
+      return createOpenRouter({ apiKey })(provider.model);
+    }
+  }
+}
+
+// src/llm/translator.ts
+import { generateText } from "ai";
+
+// src/llm/format.ts
+var BLOCK_SEP = "\n---\n";
+function serialiseUnits(units) {
+  const blocks = units.map((unit) => {
+    const lines = [`id: ${unit.id}`, `source: ${unit.source}`];
+    if (unit.sourcePlural) lines.push(`source_plural: ${unit.sourcePlural}`);
+    if (unit.context) lines.push(`context: ${unit.context}`);
+    if (unit.references?.length) {
+      lines.push(`ref: ${unit.references.join(", ")}`);
+    }
+    return lines.join("\n");
+  });
+  return "---\n" + blocks.join(BLOCK_SEP) + "\n---";
+}
+function serialiseOrphans(orphans) {
+  const blocks = orphans.map((o) => {
+    const lines = [`id: ${o.id}`];
+    if (o.source) lines.push(`source: ${o.source}`);
+    lines.push(`translation: ${o.translation}`);
+    if (o.context) lines.push(`context: ${o.context}`);
+    return lines.join("\n");
+  });
+  return "---\n" + blocks.join(BLOCK_SEP) + "\n---";
+}
+function parseResults(raw) {
+  const blocks = raw.split(/\n?---\n?/).map((b) => b.trim()).filter(Boolean);
+  const results = [];
+  for (const block of blocks) {
+    let id;
+    const translationLines = [];
+    let inTranslation = false;
+    for (const line of block.split("\n")) {
+      if (!inTranslation) {
+        const idMatch = /^id:\s*(.+)$/.exec(line);
+        if (idMatch) {
+          id = idMatch[1].trim();
+          continue;
+        }
+        const translationMatch = /^translation:\s*(.*)$/.exec(line) ?? /^target:\s*(.*)$/.exec(line);
+        if (translationMatch) {
+          translationLines.push(translationMatch[1] ?? "");
+          inTranslation = true;
+          continue;
+        }
+      } else {
+        translationLines.push(line);
+      }
+    }
+    if (id && translationLines.length > 0) {
+      results.push({ id, translation: translationLines.join("\n").trimEnd() });
+    }
+  }
+  return results;
+}
+
+// src/llm/translator.ts
+var DEFAULT_BATCH_SIZE = 200;
+var DEFAULT_MAX_ORPHANS = 50;
+function buildSystemPrompt(sourceLocale, targetLocale, ctx, orphans, customPrompt) {
+  const sections = [];
+  if (customPrompt) {
+    sections.push(customPrompt);
+  } else {
+    sections.push(
+      `You are a professional translator. Translate from ${sourceLocale} to ${targetLocale}.`
+    );
+  }
+  if (ctx.description) {
+    sections.push(`## Project description
+${ctx.description.trim()}`);
+  }
+  if (ctx.styleGuide) {
+    sections.push(`## Style guide (${targetLocale})
+${ctx.styleGuide.trim()}`);
+  }
+  const glossaryText = formatGlossary(ctx.glossary);
+  if (glossaryText) {
+    sections.push(
+      `## Glossary \u2014 always use these exact translations
+${glossaryText}`
+    );
+  }
+  if (orphans.length > 0) {
+    sections.push(
+      [
+        "## Previously translated strings (style reference)",
+        "These keys were removed or renamed from the source. Use them to maintain consistent tone and terminology:",
+        serialiseOrphans(orphans)
+      ].join("\n\n")
+    );
+  }
+  sections.push(
+    [
+      "## Instructions",
+      "- Return translations in exactly the format shown below.",
+      "- Maintain ICU message syntax (plurals, select, variables) unchanged in structure.",
+      "- Produce the correct plural categories for the target locale.",
+      "- Never add, remove, or rename interpolation variables.",
+      "- Never translate the `id` field.",
+      "- Output one block per input string, delimited by `---`.",
+      "",
+      "## Expected output format",
+      "---",
+      "id: example_key",
+      "translation: Translated text goes here",
+      "---"
+    ].join("\n")
+  );
+  return sections.join("\n\n");
+}
+function buildUserPrompt(group2, sourceLocale, targetLocale) {
+  const contextLine = group2.hasSourceRefs ? `These strings all appear in: ${group2.sourceFile}
+
+` : "";
+  return `Translate the following strings from ${sourceLocale} to ${targetLocale}:
+
+` + contextLine + serialiseUnits(group2.units);
+}
+var DefaultTranslator = class {
+  constructor(model, customPrompt, batchSize = DEFAULT_BATCH_SIZE, maxOrphans = DEFAULT_MAX_ORPHANS) {
+    this.model = model;
+    this.customPrompt = customPrompt;
+    this.batchSize = batchSize;
+    this.maxOrphans = maxOrphans;
+  }
+  async translate(group2, orphans, sourceLocale, targetLocale, ctx) {
+    if (group2.units.length === 0) {
+      return { results: [], missing: [], rawResponse: void 0 };
+    }
+    const trimmedOrphans = orphans.slice(0, this.maxOrphans);
+    const systemPrompt = buildSystemPrompt(
+      sourceLocale,
+      targetLocale,
+      ctx,
+      trimmedOrphans,
+      this.customPrompt
+    );
+    const results = [];
+    const missing = [];
+    let lastRawResponse;
+    for (let i = 0; i < group2.units.length; i += this.batchSize) {
+      const batchUnits = group2.units.slice(i, i + this.batchSize);
+      const batchGroup = { ...group2, units: batchUnits };
+      const userPrompt = buildUserPrompt(batchGroup, sourceLocale, targetLocale);
+      const { text: text2 } = await generateText({
+        model: this.model,
+        system: systemPrompt,
+        prompt: userPrompt
+      });
+      lastRawResponse = text2;
+      const batchResults = parseResults(text2);
+      const returned = new Set(batchResults.map((r) => r.id));
+      for (const unit of batchUnits) {
+        if (!returned.has(unit.id)) {
+          missing.push({ id: unit.id, source: unit.source });
+        }
+      }
+      results.push(...batchResults);
+    }
+    return { results, missing, rawResponse: lastRawResponse };
+  }
+};
+
+// src/commands/translate.ts
+var translateCommand = defineCommand({
+  meta: {
+    name: "translate",
+    description: "Translate missing strings in catalogs using an LLM"
+  },
+  args: {
+    locale: {
+      type: "string",
+      description: "Only translate a specific target locale",
+      alias: "l"
+    },
+    verbose: {
+      type: "boolean",
+      description: "Print raw LLM responses for debugging",
+      default: false
+    },
+    "max-orphans": {
+      type: "string",
+      description: "Maximum number of orphaned (removed) translations to include as style context in each prompt",
+      default: "50"
+    }
+  },
+  async run({ args }) {
+    p.intro("p6t translate");
+    let config;
+    try {
+      config = loadConfig();
+    } catch (err) {
+      if (err instanceof ConfigError) {
+        p.cancel(err.message);
+        process.exit(1);
+      }
+      throw err;
+    }
+    const configDir = getConfigDir();
+    const targetLocales = args.locale ? [args.locale] : config.locale.targets;
+    const maxOrphans = parseInt(args["max-orphans"], 10);
+    if (Number.isNaN(maxOrphans) || maxOrphans < 0) {
+      p.cancel("Invalid --max-orphans value. Must be a non-negative integer.");
+      process.exit(1);
+    }
+    let model;
+    try {
+      model = createModel(config.provider);
+    } catch (err) {
+      if (err instanceof ProviderError) {
+        p.cancel(err.message);
+        process.exit(1);
+      }
+      throw err;
+    }
+    const translator = new DefaultTranslator(
+      model,
+      config.provider.prompt,
+      void 0,
+      maxOrphans
+    );
+    let adapter;
+    try {
+      adapter = await createAdapter(config, configDir);
+    } catch (err) {
+      p.cancel(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+    for (const targetLocale of targetLocales) {
+      const ctx = loadContext(config, targetLocale, configDir);
+      const catalogPaths = adapter.getCatalogPathsForLocale(targetLocale);
+      const sourcePaths = adapter.getCatalogPathsForLocale(
+        config.locale.source
+      );
+      for (let i = 0; i < catalogPaths.length; i++) {
+        const targetPath = catalogPaths[i];
+        const sourcePath = sourcePaths[i];
+        if (!targetPath || !sourcePath) continue;
+        const orphans = adapter.removeStaleKeys(targetPath, sourcePath);
+        if (orphans.length > 0) {
+          p.log.info(
+            `Removed ${orphans.length} stale string${orphans.length === 1 ? "" : "s"} from ${targetLocale}`
+          );
+          for (const orphan of orphans) {
+            p.log.info(`  \u2022 ${orphan.id}: "${orphan.source}"`);
+          }
+        }
+        const pending = adapter.readPendingTranslations(targetPath, sourcePath);
+        const totalUnits = pending.groups.reduce(
+          (sum, g) => sum + g.units.length,
+          0
+        );
+        if (pending.groups.some((g) => g.hasSourceRefs === false && g.units.length > 0)) {
+          p.log.warn(
+            "Source file references not found in catalog. Translations will be grouped by catalog file instead of by component. For better results, run `formatjs extract` with `--extract-source-location`."
+          );
+        }
+        if (totalUnits === 0) {
+          if (orphans.length === 0) {
+            p.log.info(`${targetLocale}: already up to date`);
+          }
+          continue;
+        }
+        const allResults = [];
+        const allMissing = [];
+        let lastRawResponse;
+        for (const group2 of pending.groups) {
+          if (group2.units.length === 0) continue;
+          const contextLabel = group2.sourceFile;
+          const spinner3 = p.spinner();
+          spinner3.start(
+            `Translating ${group2.units.length} string${group2.units.length === 1 ? "" : "s"} in ${contextLabel} \u2192 ${targetLocale}`
+          );
+          try {
+            const batch = await translator.translate(
+              group2,
+              orphans,
+              config.locale.source,
+              targetLocale,
+              ctx
+            );
+            spinner3.stop(
+              `Translated ${batch.results.length}/${group2.units.length} strings in ${contextLabel} \u2192 ${targetLocale}`
+            );
+            allResults.push(...batch.results);
+            allMissing.push(...batch.missing);
+            if (batch.rawResponse) {
+              lastRawResponse = batch.rawResponse;
+            }
+          } catch (err) {
+            spinner3.stop(
+              `Failed to translate ${contextLabel} \u2192 ${targetLocale}`
+            );
+            p.log.error(err instanceof Error ? err.message : String(err));
+          }
+        }
+        if (allResults.length > 0) {
+          adapter.writeTranslations(targetPath, sourcePath, allResults);
+        }
+        if (allMissing.length > 0) {
+          p.log.warn(
+            `${allMissing.length} string${allMissing.length === 1 ? "" : "s"} not returned by the LLM:`
+          );
+          for (const unit of allMissing) {
+            const preview = unit.source.length > 60 ? unit.source.slice(0, 60) + "\u2026" : unit.source;
+            p.log.warn(`  \u2022 ${unit.id}: "${preview}"`);
+          }
+          if (args.verbose && lastRawResponse) {
+            p.log.info("Raw LLM response:");
+            process.stdout.write(lastRawResponse + "\n");
+          }
+        }
+      }
+    }
+    p.outro("Done");
+  }
+});
+
+// src/commands/init.ts
+import fs4 from "fs";
+import path3 from "path";
+import * as p2 from "@clack/prompts";
+import { defineCommand as defineCommand2 } from "citty";
+import { generateText as generateText2 } from "ai";
+var CONFIG_FILE2 = "i18n.json";
+function writeFileSafe(filePath, content) {
+  fs4.mkdirSync(path3.dirname(filePath), { recursive: true });
+  fs4.writeFileSync(filePath, content, "utf8");
+}
+function readFileSafe2(filePath) {
+  try {
+    return fs4.readFileSync(filePath, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function resolveContextPath2(template, locale, cwd) {
+  return path3.resolve(cwd, template.replace("{locale}", locale));
+}
+function detectFormatFromFiles(cwd) {
+  for (const dir of ["locale", "locales", "src/locales", "src/locale"]) {
+    const full = path3.join(cwd, dir);
+    if (!fs4.existsSync(full)) continue;
+    for (const entry of fs4.readdirSync(full, { recursive: true })) {
+      if (entry.endsWith(".po")) return "lingui";
+    }
+  }
+  for (const dir of [
+    "lang",
+    "src/lang",
+    "messages",
+    "src/messages",
+    "i18n",
+    "locales",
+    "src/locales",
+    "src/i18n"
+  ]) {
+    const full = path3.join(cwd, dir);
+    if (!fs4.existsSync(full)) continue;
+    for (const entry of fs4.readdirSync(full, { recursive: true })) {
+      if (!entry.endsWith(".json")) continue;
+      const raw = readFileSafe2(path3.join(full, entry));
+      if (!raw) continue;
+      try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed === "object" && parsed !== null) {
+          const values = Object.values(parsed);
+          if (values.some(
+            (v) => typeof v === "object" && v !== null && "defaultMessage" in v
+          )) {
+            return "react-intl";
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+async function draftDescription(readme, sourceStrings, model) {
+  const sample = sourceStrings.join("\n");
+  const prompt = [
+    "Write a concise project description (2-4 paragraphs) for a professional translator.",
+    "It should explain: what this product is, who uses it, its domain/industry, and any important vocabulary notes.",
+    "Base it on the README and sample UI strings below.",
+    readme ? `
+## README
+${readme.slice(0, 1e5)}` : "",
+    sample ? `
+## Sample UI strings
+${sample}` : ""
+  ].filter(Boolean).join("\n");
+  const { text: text2 } = await generateText2({
+    model,
+    system: "You are a localization consultant writing a project brief for professional translators. Be clear and practical.",
+    prompt
+  });
+  return text2.trim();
+}
+async function draftStyleGuide(locale, projectDescription, translatedPairs, model) {
+  const examplesSection = translatedPairs.length > 0 ? `
+## Existing translations (observe the established style)
+${translatedPairs.map(
+    ({ source, translation }) => `source: ${source}
+translation: ${translation}`
+  ).join("\n\n")}` : "";
+  const { text: text2 } = await generateText2({
+    model,
+    system: "You are a localization expert. Write a translation style guide in markdown.",
+    prompt: [
+      `Write a style guide for translating into ${locale}.`,
+      "Cover: formality level (formal/informal), tone, brand voice, punctuation conventions, number/date formats, and any locale-specific considerations.",
+      "Keep it practical \u2014 1-2 sentences per rule. Use markdown headings.",
+      "If existing translations are provided, infer the style from them rather than guessing.",
+      `
+## Project context
+${projectDescription}`,
+      examplesSection
+    ].filter(Boolean).join("\n")
+  });
+  return text2.trim();
+}
+async function draftGlossary(locale, sourceStrings, projectDescription, translatedPairs, styleGuide, model) {
+  const sample = sourceStrings.join("\n");
+  const existingSection = translatedPairs.length > 0 ? `
+## Existing translations (extract consistent term mappings from these)
+${translatedPairs.map(
+    ({ source, translation }) => `source: ${source}
+translation: ${translation}`
+  ).join("\n")}` : "";
+  const { text: text2 } = await generateText2({
+    model,
+    system: "You are a localization expert. Respond with valid JSON only \u2014 a flat object mapping English terms to their preferred translations. No markdown, no explanation.",
+    prompt: [
+      `Identify the most important domain-specific terms and provide their preferred ${locale} translations. This just needs to be enough for a smart translator to be able to consistenly translate the UI \u2014 shorter is better.`,
+      "If existing translations are provided, extract term mappings directly from them \u2014 prefer attested translations over guesses.",
+      `
+## Project context
+${projectDescription}`,
+      `
+## Style guide
+${styleGuide}`,
+      sample ? `
+## Source UI strings
+${sample}` : "",
+      existingSection
+    ].filter(Boolean).join("\n")
+  });
+  try {
+    const cleaned = text2.replace(/^```[a-z]*\n?/m, "").replace(/```$/m, "").trim();
+    const parsed = JSON.parse(cleaned);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return Object.fromEntries(
+        Object.entries(parsed).flatMap(
+          ([k, v]) => typeof v === "string" ? [[k, v]] : []
+        )
+      );
+    }
+  } catch {
+  }
+  return {};
+}
+var initCommand = defineCommand2({
+  meta: {
+    name: "init",
+    description: "Scaffold i18n.json and translation context files"
+  },
+  async run() {
+    p2.intro("p6t init");
+    const cwd = process.cwd();
+    if (fs4.existsSync(path3.join(cwd, CONFIG_FILE2))) {
+      const overwrite = await p2.confirm({
+        message: `${CONFIG_FILE2} already exists. Overwrite?`,
+        initialValue: false
+      });
+      if (p2.isCancel(overwrite) || !overwrite) {
+        p2.cancel("Aborted.");
+        process.exit(0);
+      }
+    }
+    const detectedFormat = detectFormatFromFiles(cwd);
+    const answers = await p2.group(
+      {
+        sourceLocale: () => p2.text({
+          message: "Source locale (language your strings are written in)",
+          placeholder: "en",
+          defaultValue: "en"
+        }),
+        targetLocales: () => p2.text({
+          message: "Target locales (comma-separated)",
+          placeholder: "de, fr, es",
+          validate: (v) => (v ?? "").trim() ? void 0 : "At least one target locale is required"
+        }),
+        providerId: () => p2.select({
+          message: "LLM provider",
+          options: [
+            { value: "openai", label: "OpenAI" },
+            { value: "anthropic", label: "Anthropic" },
+            { value: "google", label: "Google" },
+            { value: "mistral", label: "Mistral" },
+            { value: "ollama", label: "Ollama (local)" },
+            { value: "openrouter", label: "OpenRouter" }
+          ]
+        }),
+        model: () => p2.text({
+          message: "Model name",
+          placeholder: "gpt-4o",
+          validate: (v) => (v ?? "").trim() ? void 0 : "Model name is required"
+        }),
+        format: () => p2.select({
+          message: "Translation library / catalog format",
+          initialValue: detectedFormat,
+          options: [
+            { value: "lingui", label: "Lingui (.po)" },
+            { value: "react-intl", label: "react-intl / FormatJS (.json)" }
+          ]
+        }),
+        catalogPath: ({ results }) => {
+          if (results.format !== "react-intl") return void 0;
+          return p2.text({
+            message: "Catalog path template (use {locale} placeholder)",
+            placeholder: "i18n/{locale}.json",
+            validate: (v) => {
+              if (!(v ?? "").trim()) return "Catalog path is required";
+              if (!v.includes("{locale}"))
+                return "Path must contain {locale}";
+              return void 0;
+            }
+          });
+        },
+        draftContext: () => p2.confirm({
+          message: "Use the LLM to draft description, style guides, and glossaries? (requires API key)",
+          initialValue: true
+        })
+      },
+      {
+        onCancel: () => {
+          p2.cancel("Aborted.");
+          process.exit(0);
+        }
+      }
+    );
+    const targetLocales = answers.targetLocales.split(",").map((l) => l.trim()).filter(Boolean);
+    const providerId = answers.providerId;
+    const model = answers.model;
+    const sourceLocale = answers.sourceLocale;
+    const format = answers.format;
+    const draftContext = answers.draftContext;
+    const catalogPath = answers.catalogPath;
+    const config = {
+      version: 1,
+      format,
+      locale: { source: sourceLocale, targets: targetLocales },
+      provider: { id: providerId, model },
+      context: {
+        description: "i18n/description.md",
+        styleGuide: "i18n/{locale}/style-guide.md",
+        glossary: "i18n/{locale}/glossary.json"
+      }
+    };
+    if (format === "react-intl" && catalogPath) {
+      config.catalogs = [{ path: catalogPath }];
+    }
+    writeFileSafe(
+      path3.join(cwd, CONFIG_FILE2),
+      JSON.stringify(
+        { $schema: "https://p6t.dev/schema/i18n.json", ...config },
+        null,
+        2
+      ) + "\n"
+    );
+    p2.log.success(`Created ${CONFIG_FILE2}`);
+    let adapter;
+    try {
+      adapter = await createAdapter(config, cwd);
+    } catch (err) {
+      p2.log.warn(
+        `Could not load catalog adapter (${err instanceof Error ? err.message : String(err)}) \u2014 skipping LLM drafting.`
+      );
+      writeContextStubs(cwd, config, targetLocales);
+      p2.outro("Done (stubs created)");
+      return;
+    }
+    if (draftContext) {
+      let llmModel;
+      try {
+        llmModel = createModel({ id: providerId, model });
+      } catch (err) {
+        if (err instanceof ProviderError) {
+          p2.log.warn(
+            `${err.message} \u2014 skipping LLM drafting. Edit context files manually.`
+          );
+          writeContextStubs(cwd, config, targetLocales);
+          p2.outro("Done (stubs created)");
+          return;
+        }
+        throw err;
+      }
+      const spinner3 = p2.spinner();
+      const readme = readFileSafe2(path3.join(cwd, "README.md"));
+      const allCatalogs = adapter.discoverCatalogs(cwd);
+      const sourceCatalogs = allCatalogs.filter(
+        (f) => f.includes(`/${sourceLocale}/`) || path3.basename(f, path3.extname(f)) === sourceLocale
+      );
+      const sourceStrings = sourceCatalogs.flatMap(
+        (p5) => adapter.extractSourceStrings(p5)
+      );
+      spinner3.start("Drafting project description\u2026");
+      let description;
+      try {
+        description = await draftDescription(readme, sourceStrings, llmModel);
+        writeFileSafe(
+          path3.join(cwd, config.context.description),
+          description + "\n"
+        );
+        spinner3.stop(`Created ${config.context.description}`);
+      } catch (err) {
+        p2.log.warn(
+          `LLM description drafting failed (${err instanceof Error ? err.message : String(err)}) \u2014 writing stubs.`
+        );
+        writeContextStubs(cwd, config, targetLocales);
+        p2.outro("Done (stubs created)");
+        return;
+      }
+      for (const locale of targetLocales) {
+        spinner3.start(`Drafting style guide + glossary for ${locale}\u2026`);
+        const targetCatalogs = adapter.getCatalogPathsForLocale(locale);
+        const sourcePaths = adapter.getCatalogPathsForLocale(sourceLocale);
+        const translatedPairs = [];
+        for (let i = 0; i < targetCatalogs.length; i++) {
+          if (!fs4.existsSync(targetCatalogs[i])) continue;
+          const pairs = adapter.extractTranslatedPairs(
+            targetCatalogs[i],
+            sourcePaths[i]
+          );
+          translatedPairs.push(...pairs);
+        }
+        try {
+          const styleGuide = await draftStyleGuide(
+            locale,
+            description,
+            translatedPairs,
+            llmModel
+          );
+          const glossary = await draftGlossary(
+            locale,
+            sourceStrings,
+            description,
+            translatedPairs,
+            styleGuide,
+            llmModel
+          );
+          const styleGuidePath = resolveContextPath2(
+            config.context.styleGuide,
+            locale,
+            cwd
+          );
+          const glossaryPath = resolveContextPath2(
+            config.context.glossary,
+            locale,
+            cwd
+          );
+          writeFileSafe(styleGuidePath, styleGuide + "\n");
+          writeFileSafe(glossaryPath, JSON.stringify(glossary, null, 2) + "\n");
+          spinner3.stop(`Created context files for ${locale}`);
+        } catch (err) {
+          p2.log.warn(
+            `LLM drafting failed for ${locale} (${err instanceof Error ? err.message : String(err)}) \u2014 writing stubs.`
+          );
+          const styleGuidePath = resolveContextPath2(
+            config.context.styleGuide,
+            locale,
+            cwd
+          );
+          const glossaryPath = resolveContextPath2(
+            config.context.glossary,
+            locale,
+            cwd
+          );
+          if (!fs4.existsSync(styleGuidePath)) {
+            writeFileSafe(
+              styleGuidePath,
+              [
+                `# Style guide \u2014 ${locale}`,
+                "",
+                "## Tone and formality",
+                "<!-- Formal or informal? -->",
+                "",
+                "## Brand voice",
+                "<!-- How should the brand sound? -->",
+                "",
+                "## Punctuation and formatting",
+                "<!-- Any locale-specific rules? -->"
+              ].join("\n") + "\n"
+            );
+          }
+          if (!fs4.existsSync(glossaryPath)) {
+            writeFileSafe(glossaryPath, "{}\n");
+          }
+          spinner3.stop(`Created stub context files for ${locale}`);
+        }
+      }
+    } else {
+      writeContextStubs(cwd, config, targetLocales);
+    }
+    p2.note(
+      [
+        "Review and commit the generated files:",
+        `  ${CONFIG_FILE2}`,
+        `  i18n/description.md`,
+        ...targetLocales.map((l) => `  i18n/${l}/style-guide.md`),
+        ...targetLocales.map((l) => `  i18n/${l}/glossary.json`)
+      ].join("\n"),
+      "Next steps"
+    );
+    p2.outro("Done \u2014 run `p6t translate` when ready");
+  }
+});
+function writeContextStubs(cwd, config, targetLocales) {
+  const descPath = path3.join(cwd, config.context.description);
+  if (!fs4.existsSync(descPath)) {
+    writeFileSafe(
+      descPath,
+      [
+        "# Project description",
+        "",
+        "Describe your project here for translators:",
+        "- What does it do?",
+        "- Who are the users?",
+        "- What industry/domain?",
+        "- Any important vocabulary notes?"
+      ].join("\n") + "\n"
+    );
+    p2.log.success(`Created ${config.context.description}`);
+  }
+  for (const locale of targetLocales) {
+    const styleGuidePath = resolveContextPath2(
+      config.context.styleGuide,
+      locale,
+      cwd
+    );
+    const glossaryPath = resolveContextPath2(
+      config.context.glossary,
+      locale,
+      cwd
+    );
+    if (!fs4.existsSync(styleGuidePath)) {
+      writeFileSafe(
+        styleGuidePath,
+        [
+          `# Style guide \u2014 ${locale}`,
+          "",
+          "## Tone and formality",
+          "<!-- Formal or informal? -->",
+          "",
+          "## Brand voice",
+          "<!-- How should the brand sound? -->",
+          "",
+          "## Punctuation and formatting",
+          "<!-- Any locale-specific rules? -->"
+        ].join("\n") + "\n"
+      );
+    }
+    if (!fs4.existsSync(glossaryPath)) {
+      writeFileSafe(glossaryPath, "{}\n");
+    }
+    p2.log.success(`Created context files for ${locale}`);
+  }
+}
+
+// src/commands/push.ts
+import * as p3 from "@clack/prompts";
+import { defineCommand as defineCommand3 } from "citty";
+var pushCommand = defineCommand3({
+  meta: {
+    name: "push",
+    description: "Push translations to p6t web for review (coming soon)"
+  },
+  async run() {
+    p3.intro("p6t push");
+    p3.log.warn("Web integration is not yet implemented.");
+    p3.outro("Nothing pushed.");
+  }
+});
+
+// src/commands/pull.ts
+import * as p4 from "@clack/prompts";
+import { defineCommand as defineCommand4 } from "citty";
+var pullCommand = defineCommand4({
+  meta: {
+    name: "pull",
+    description: "Pull confirmed translations from p6t web (coming soon)"
+  },
+  async run() {
+    p4.intro("p6t pull");
+    p4.log.warn("Web integration is not yet implemented.");
+    p4.outro("Nothing pulled.");
+  }
+});
+
+// src/index.ts
+var main = defineCommand5({
+  meta: {
+    name: "p6t",
+    description: "p6t \u2014 AI-powered translation pipeline",
+    version: "0.0.0"
+  },
+  subCommands: {
+    translate: translateCommand,
+    init: initCommand,
+    push: pushCommand,
+    pull: pullCommand
+  }
+});
+runMain(main);