@menapo/vi18n 0.0.0-stage → 0.1.1

package/dist/run-BEcnBbu-.js

@@ -0,0 +1,694 @@
+import { n as DEFAULT_CONFIG, o as isDiagnosticError } from "./types-D3QGM8XO.js";
+import { t as VERSION } from "./version-Byqi2guX.js";
+import { t as PROVIDER_PRESETS } from "./openai-CTaMDcl-.js";
+import { t as EXCHANGE_FORMATS } from "./units-CQ5Q99RC.js";
+import { n as createOutput } from "./output-DWE3SIUA.js";
+import { t as EXIT } from "./types-wSh9fCBY.js";
+import { t as CliExit } from "./project-C4GpaN-n.js";
+import { resolve } from "node:path";
+import { parseArgs } from "node:util";
+//#region src/cli/args.ts
+/**
+* Command-line parsing (INTERNALS §2.14): `node:util` `parseArgs`, strict, so
+* an unknown flag or a stray positional is a usage error (exit 2) instead of
+* a silently different run. Global flags may appear before or after the
+* command name.
+*/
+const COMMANDS = [
+	"init",
+	"extract",
+	"check",
+	"status",
+	"compile",
+	"translate",
+	"migrate",
+	"sitemap",
+	"export",
+	"import",
+	"restore",
+	"which",
+	"merge-driver",
+	"lsp",
+	"mcp"
+];
+/** Commands that take positional arguments. */
+const POSITIONAL = /* @__PURE__ */ new Set([
+	"check",
+	"sitemap",
+	"import",
+	"which",
+	"merge-driver"
+]);
+const CATEGORIES = [
+	"missing",
+	"placeholders",
+	"syntax"
+];
+/** What `migrate --from` converts (PLAN §5.19). */
+const MIGRATIONS = [
+	"saas-i18n",
+	"i18next",
+	"react-intl",
+	"lingui",
+	"vue-i18n"
+];
+const GLOBAL = {
+	config: { type: "string" },
+	json: { type: "boolean" },
+	cwd: { type: "string" },
+	help: {
+		type: "boolean",
+		short: "h"
+	},
+	version: {
+		type: "boolean",
+		short: "v"
+	}
+};
+const OPTIONS = {
+	init: {
+		yes: {
+			type: "boolean",
+			short: "y"
+		},
+		format: { type: "string" },
+		locales: { type: "string" },
+		"source-locale": { type: "string" },
+		rich: { type: "boolean" }
+	},
+	extract: {
+		check: { type: "boolean" },
+		watch: { type: "boolean" },
+		yes: {
+			type: "boolean",
+			short: "y"
+		},
+		vite: { type: "boolean" }
+	},
+	check: {
+		ci: { type: "boolean" },
+		format: { type: "string" }
+	},
+	status: { locale: {
+		type: "string",
+		multiple: true
+	} },
+	compile: {
+		out: { type: "string" },
+		assets: { type: "string" },
+		strict: { type: "boolean" },
+		pseudo: { type: "boolean" },
+		check: { type: "boolean" }
+	},
+	translate: {
+		locale: {
+			type: "string",
+			multiple: true
+		},
+		model: { type: "string" },
+		retranslate: { type: "string" },
+		provider: { type: "string" },
+		tier: { type: "string" },
+		"dry-run": { type: "boolean" },
+		"max-cost": { type: "string" }
+	},
+	migrate: {
+		from: { type: "string" },
+		catalog: {
+			type: "string",
+			multiple: true
+		},
+		"keep-ids": { type: "boolean" },
+		write: { type: "boolean" }
+	},
+	sitemap: {
+		routes: { type: "string" },
+		"base-url": { type: "string" },
+		out: { type: "string" },
+		check: { type: "boolean" }
+	},
+	export: {
+		format: { type: "string" },
+		locale: {
+			type: "string",
+			multiple: true
+		},
+		out: { type: "string" },
+		missing: { type: "boolean" },
+		ai: { type: "boolean" }
+	},
+	import: {
+		format: { type: "string" },
+		locale: { type: "string" },
+		"dry-run": { type: "boolean" }
+	},
+	restore: {
+		from: { type: "string" },
+		locale: {
+			type: "string",
+			multiple: true
+		},
+		"dry-run": { type: "boolean" }
+	},
+	which: {},
+	"merge-driver": {},
+	lsp: {
+		stdio: { type: "boolean" },
+		clientProcessId: { type: "string" }
+	},
+	mcp: {}
+};
+/** Thrown inside flag conversion; becomes a `usage` result. */
+var UsageError = class extends Error {};
+function isCommand(name) {
+	return COMMANDS.includes(name);
+}
+/**
+* The command is the first token that is neither a flag nor the value of a
+* global flag that takes one (`--config x`, `--cwd x`), so `vi18n --cwd app
+* extract` and `vi18n extract --cwd app` mean the same.
+*/
+function findCommand(argv) {
+	for (let i = 0; i < argv.length; i++) {
+		const token = argv[i];
+		if (token === "--") return null;
+		if (token === "--config" || token === "--cwd") {
+			i++;
+			continue;
+		}
+		if (!token.startsWith("-")) return {
+			index: i,
+			name: token
+		};
+	}
+	return null;
+}
+function parseCommandLine(argv, cwd) {
+	const found = findCommand(argv);
+	const json = argv.includes("--json");
+	if (found === null) {
+		const rest = tryParse(argv, GLOBAL, false);
+		if ("error" in rest) return {
+			kind: "usage",
+			command: null,
+			message: rest.error,
+			json
+		};
+		if (rest.values.version === true) return {
+			kind: "version",
+			command: null,
+			json
+		};
+		if (rest.values.help === true) return {
+			kind: "help",
+			command: null,
+			json
+		};
+		return {
+			kind: "usage",
+			command: null,
+			message: `missing command; expected one of ${COMMANDS.join(", ")}`,
+			json
+		};
+	}
+	if (!isCommand(found.name)) return {
+		kind: "usage",
+		command: null,
+		message: `unknown command "${found.name}"; expected one of ${COMMANDS.join(", ")}`,
+		json
+	};
+	const command = found.name;
+	const parsed = tryParse([...argv.slice(0, found.index), ...argv.slice(found.index + 1)], {
+		...GLOBAL,
+		...OPTIONS[command]
+	}, POSITIONAL.has(command));
+	if ("error" in parsed) return {
+		kind: "usage",
+		command,
+		message: parsed.error,
+		json
+	};
+	const { values, positionals } = parsed;
+	if (values.version === true) return {
+		kind: "version",
+		command,
+		json
+	};
+	if (values.help === true) return {
+		kind: "help",
+		command,
+		json
+	};
+	const global = {
+		config: str(values.config),
+		json: values.json === true,
+		cwd: resolve(cwd, str(values.cwd) ?? ".")
+	};
+	try {
+		return {
+			kind: "run",
+			...commandFlags(command, values, positionals, global)
+		};
+	} catch (error) {
+		if (error instanceof UsageError) return {
+			kind: "usage",
+			command,
+			message: error.message,
+			json: global.json
+		};
+		throw error;
+	}
+}
+function tryParse(args, options, allowPositionals) {
+	try {
+		const { values, positionals } = parseArgs({
+			args: [...args],
+			options,
+			strict: true,
+			allowPositionals
+		});
+		return {
+			values,
+			positionals
+		};
+	} catch (error) {
+		return { error: error instanceof Error ? error.message : String(error) };
+	}
+}
+function str(value) {
+	return typeof value === "string" ? value : null;
+}
+function bool(value) {
+	return value === true;
+}
+function list(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((item) => typeof item === "string");
+}
+function oneOf(flag, value, allowed) {
+	if (value === null) return null;
+	if (allowed.includes(value)) return value;
+	throw new UsageError(`--${flag} must be one of ${allowed.join(", ")}, not "${value}"`);
+}
+function commandFlags(command, values, positionals, global) {
+	switch (command) {
+		case "init": {
+			const locales = (str(values.locales) ?? "").split(",").map((locale) => locale.trim()).filter((locale) => locale !== "");
+			return {
+				command,
+				global,
+				flags: {
+					yes: bool(values.yes),
+					format: oneOf("format", str(values.format), ["po", "json"]),
+					locales,
+					sourceLocale: str(values["source-locale"]),
+					rich: bool(values.rich)
+				}
+			};
+		}
+		case "extract": {
+			const flags = {
+				check: bool(values.check),
+				watch: bool(values.watch),
+				yes: bool(values.yes),
+				vite: bool(values.vite)
+			};
+			if (flags.check && flags.watch) throw new UsageError("--check and --watch cannot be combined");
+			if (flags.vite && flags.watch) throw new UsageError("--vite and --watch cannot be combined; vite dev keeps the catalogs current");
+			return {
+				command,
+				global,
+				flags
+			};
+		}
+		case "check": {
+			const categories = [];
+			for (const positional of positionals) {
+				const category = oneOf("category", positional, CATEGORIES);
+				if (category !== null && !categories.includes(category)) categories.push(category);
+			}
+			const format = oneOf("format", str(values.format), [
+				"text",
+				"github",
+				"json"
+			]) ?? "text";
+			const flags = {
+				categories,
+				ci: bool(values.ci),
+				format: global.json ? "json" : format
+			};
+			if (flags.format === "json") global.json = true;
+			return {
+				command,
+				global,
+				flags
+			};
+		}
+		case "status": return {
+			command,
+			global,
+			flags: { locales: list(values.locale) }
+		};
+		case "compile": {
+			const flags = {
+				out: str(values.out),
+				assets: str(values.assets),
+				strict: bool(values.strict),
+				pseudo: bool(values.pseudo),
+				check: bool(values.check)
+			};
+			if (flags.check && flags.out === null) throw new UsageError("--check needs --out <dir>: the directory to compare");
+			if (flags.assets !== null && flags.out === null) throw new UsageError("--assets needs --out <dir>: the directory for config.json, sources.json and catalogs.js");
+			return {
+				command,
+				global,
+				flags
+			};
+		}
+		case "translate": {
+			const provider = oneOf("provider", str(values.provider), PROVIDER_PRESETS);
+			const model = str(values.model);
+			if (provider !== null && provider !== "gemini" && model === null) throw new UsageError(`--provider ${provider} needs --model <id>`);
+			const rawCost = str(values["max-cost"]);
+			let maxCost = null;
+			if (rawCost !== null) {
+				maxCost = rawCost.trim() === "" ? NaN : Number(rawCost);
+				if (!Number.isFinite(maxCost) || maxCost < 0) throw new UsageError(`--max-cost must be a non-negative number of USD, not "${rawCost}"`);
+			}
+			return {
+				command,
+				global,
+				flags: {
+					locales: list(values.locale),
+					model,
+					retranslate: oneOf("retranslate", str(values.retranslate), ["ai", "all"]),
+					provider,
+					tier: oneOf("tier", str(values.tier), [
+						"standard",
+						"flex",
+						"batch"
+					]) ?? "standard",
+					dryRun: bool(values["dry-run"]),
+					maxCost
+				}
+			};
+		}
+		case "migrate": {
+			const from = oneOf("from", str(values.from), MIGRATIONS);
+			if (from === null) throw new UsageError(`--from is required (${MIGRATIONS.join(", ")})`);
+			const catalogs = [];
+			for (const raw of list(values.catalog)) {
+				const eq = raw.indexOf("=");
+				if (eq === -1) catalogs.push({
+					locale: null,
+					file: raw
+				});
+				else {
+					const locale = raw.slice(0, eq).trim();
+					const file = raw.slice(eq + 1).trim();
+					if (locale === "" || file === "") throw new UsageError(`--catalog ${raw}: expected <file> or <locale>=<file>`);
+					catalogs.push({
+						locale,
+						file
+					});
+				}
+			}
+			const keepIds = bool(values["keep-ids"]);
+			if (from === "saas-i18n") {
+				if (keepIds) throw new UsageError("--keep-ids is for the libraries: saas-i18n keys always become manual ids");
+				if (catalogs.length === 0) throw new UsageError("--catalog <file> is required: the default locale's key catalogue");
+				for (const entry of catalogs.slice(1)) if (entry.locale === null) throw new UsageError(`--catalog ${entry.file}: only the first --catalog may omit the locale (<locale>=<file>)`);
+			}
+			return {
+				command,
+				global,
+				flags: {
+					from,
+					catalogs,
+					keepIds,
+					write: bool(values.write)
+				}
+			};
+		}
+		case "sitemap": {
+			const flags = {
+				routes: positionals,
+				routesFile: str(values.routes),
+				baseUrl: str(values["base-url"]),
+				out: str(values.out),
+				check: bool(values.check)
+			};
+			if (flags.check && flags.out === null) throw new UsageError("--check needs --out <file>: the sitemap to compare");
+			return {
+				command,
+				global,
+				flags
+			};
+		}
+		case "export": {
+			const format = oneOf("format", str(values.format), EXCHANGE_FORMATS);
+			if (format === null) throw new UsageError(`--format is required: one of ${EXCHANGE_FORMATS.join(", ")}`);
+			return {
+				command,
+				global,
+				flags: {
+					format,
+					locales: list(values.locale),
+					out: str(values.out),
+					missing: bool(values.missing),
+					ai: bool(values.ai)
+				}
+			};
+		}
+		case "import": {
+			if (positionals.length === 0) throw new UsageError("name the file(s) to import");
+			const flags = {
+				format: oneOf("format", str(values.format), EXCHANGE_FORMATS),
+				locale: str(values.locale),
+				dryRun: bool(values["dry-run"]),
+				files: positionals
+			};
+			if (flags.locale !== null && positionals.length > 1) throw new UsageError("--locale applies to one file; import the others separately");
+			return {
+				command,
+				global,
+				flags
+			};
+		}
+		case "restore": {
+			const from = str(values.from);
+			if (from === null || from.trim() === "") throw new UsageError("--from <git-rev> is required: the revision to restore from");
+			if (from.startsWith("-")) throw new UsageError(`--from ${from}: not a revision`);
+			return {
+				command,
+				global,
+				flags: {
+					from,
+					locales: list(values.locale),
+					dryRun: bool(values["dry-run"])
+				}
+			};
+		}
+		case "which": {
+			const query = positionals.join(" ");
+			if (query.trim() === "") throw new UsageError("name an id, the start of one, or source text");
+			return {
+				command,
+				global,
+				flags: { query }
+			};
+		}
+		case "merge-driver": {
+			if (positionals.length < 3 || positionals.length > 4) throw new UsageError("expected <base> <ours> <theirs> [<path>], as git passes %O %A %B %P");
+			const [base, ours, theirs, path] = positionals;
+			return {
+				command,
+				global,
+				flags: {
+					base,
+					ours,
+					theirs,
+					path: path ?? null
+				}
+			};
+		}
+		case "lsp":
+		case "mcp":
+			if (global.json) throw new UsageError(`--json does not apply: vi18n ${command} speaks its protocol on stdio`);
+			if (command === "mcp") return {
+				command,
+				global,
+				flags: {}
+			};
+			return {
+				command,
+				global,
+				flags: { stdio: true }
+			};
+	}
+}
+const GLOBAL_HELP = `Global flags:
+  --config <path>   vi18n.config.ts to use (default: searched upward from the cwd)
+  --cwd <dir>       run as if started in <dir>
+  --json            print one JSON object (the command's result) on stdout
+  --help, --version`;
+const COMMAND_HELP = {
+	init: `vi18n init [--yes] [--format po|json] [--locales en,de] [--source-locale en] [--rich]
+  Write vi18n.config.ts, add the plugin to vite.config.*, create the catalogs and vi18n.gen.ts.
+  --rich copies a <T> rich-text component for Vue and Svelte into the project (also when configured).`,
+	extract: `vi18n extract [--check] [--watch] [--yes] [--vite]
+  Sync the catalogs with the code. --check writes nothing and fails on drift; --watch only adds;
+  --yes allows clearing or deleting more translations than the safety limit.
+  --vite transforms each file through the project's Vite config and plugins instead of reading it,
+  for plugins that change code before vi18n sees it (auto-imports, macros).`,
+	check: `vi18n check [missing] [placeholders] [syntax] [--ci] [--format text|github|json]
+  Validate catalogs against the code. --ci fails on warnings of the selected categories too.`,
+	status: `vi18n status [--json] [--locale <l>]…
+  Translation progress per locale, and per bundle when a build report exists.`,
+	compile: `vi18n compile [--out <dir>] [--assets <dir>] [--strict] [--pseudo] [--check]
+  Compiled JSON per locale plus sources.json and config.json, for code not built by Vite.
+  --assets puts the catalogs into a static-assets directory (vi18n/<version>/<locale>/catalog.json)
+  and writes <out>/catalogs.js, which reads them through the Workers ASSETS binding.
+  --check writes nothing and fails when a file is out of date.`,
+	translate: `vi18n translate [--locale <l>]… [--provider gemini|openai|openrouter|ollama] [--model <id>] [--tier standard|flex|batch] [--retranslate ai|all] [--dry-run] [--max-cost <usd>]
+  AI-translate the referenced messages that have no translation.
+  --provider overrides ai.provider (all but gemini need --model); --tier flex|batch (Gemini) costs half.`,
+	migrate: `vi18n migrate --from i18next|react-intl|lingui|vue-i18n|saas-i18n [--catalog [<locale>=]<file|dir>]… [--keep-ids] [--write]
+  Rewrite another library's calls into t()/msg()/rich() and its catalogs into vi18n's;
+  prints the plan without --write. --keep-ids keeps every key a developer chose as a manual id.`,
+	sitemap: `vi18n sitemap [<route>…] [--routes <file>] [--base-url <url>] [--out <file>] [--check]
+  Write sitemap.xml: every route in every locale, with hreflang alternates and x-default.
+  --base-url is the site's origin and base path (not needed when routing.domains has every locale);
+  --routes reads route paths from a file; without --out the sitemap goes to stdout.`,
+	export: `vi18n export --format po|json|flat|xliff2|arb|csv [--locale <l>]… [--out <dir>] [--missing] [--ai]
+  Write each locale's catalog in an exchange format for a TMS or translators. --missing keeps the
+  entries without a translation that would ship, --ai the AI translations; without --out, one
+  locale goes to stdout.`,
+	import: `vi18n import [--format po|json|flat|xliff2|arb|csv] [--locale <l>] [--dry-run] <file>…
+  Take translations from exchange files into the catalogs, only where the row's source is the
+  entry's exact source; reports what changed and what was skipped. --dry-run writes nothing.`,
+	restore: `vi18n restore --from <git-rev> [--locale <l>]… [--dry-run]
+  Fill empty entries from that revision's catalogs by exact source text or manual id.`,
+	which: `vi18n which <id|prefix|text>
+  Print a message's id, source text, call sites and catalog entries.`,
+	"merge-driver": `vi18n merge-driver <base> <ours> <theirs> [<path>]
+  Git merge driver for catalogs (%O %A %B %P): merges entry by entry and leaves conflict
+  markers only where both sides changed one translation differently.`,
+	lsp: `vi18n lsp [--stdio]
+  Language server for editors: hovers with every locale's translation, diagnostics for missing
+  and invalid translations, go to the catalog entry. Speaks LSP on stdin/stdout.`,
+	mcp: `vi18n mcp
+  Model Context Protocol server for agents: status, check, extract and compile checks, translate
+  --dry-run, and reading and writing one translation. Speaks MCP on stdin/stdout.`
+};
+function helpText(command, version) {
+	if (command !== null) return `${COMMAND_HELP[command]}\n\n${GLOBAL_HELP}\n`;
+	return `vi18n ${version}\n\nUsage:\n${COMMANDS.map((name) => "  " + COMMAND_HELP[name].split("\n")[0]).join("\n")}\n\n${GLOBAL_HELP}\n`;
+}
+//#endregion
+//#region src/cli/run.ts
+/**
+* The `vi18n` binary minus the process (INTERNALS §2.14, §3.5): parse argv,
+* run one command, map failures to exit codes, print the `--json` envelope.
+* Tests call `run` in-process with recording `CliIo`s; `bin.ts` wires the
+* real process to it.
+*/
+async function run(argv, io) {
+	const parsed = parseCommandLine(argv, io.cwd);
+	switch (parsed.kind) {
+		case "version":
+		case "help": {
+			const text = parsed.kind === "version" ? VERSION + "\n" : helpText(parsed.command, VERSION);
+			if (parsed.json && parsed.command !== null) createOutput(io, "json").finish(parsed.command, EXIT.ok, parsed.kind === "version" ? { version: VERSION } : { help: text });
+			else io.stdout(text);
+			return EXIT.ok;
+		}
+		case "usage": {
+			const out = createOutput(io, parsed.json ? "json" : "text");
+			out.addSecret(io.env[DEFAULT_CONFIG.ai.apiKeyEnv]);
+			io.stderr(out.redact(`vi18n: ${parsed.message}\n${parsed.command === null ? "Run vi18n --help for usage.\n" : `Run vi18n ${parsed.command} --help for usage.\n`}`));
+			if (parsed.command !== null) out.finish(parsed.command, EXIT.usage, { usage: parsed.message });
+			return EXIT.usage;
+		}
+	}
+	const commandIo = {
+		...io,
+		cwd: parsed.global.cwd
+	};
+	const out = createOutput(commandIo, parsed.global.json ? "json" : parsed.command === "check" ? parsed.flags.format : "text");
+	out.addSecret(io.env[DEFAULT_CONFIG.ai.apiKeyEnv]);
+	const ctx = {
+		io: commandIo,
+		out,
+		global: parsed.global
+	};
+	let exitCode;
+	let data = null;
+	try {
+		let result;
+		switch (parsed.command) {
+			case "init":
+				result = await (await import("./init-C2ScuW6a.js")).init(ctx, parsed.flags);
+				break;
+			case "extract":
+				result = await (await import("./extract-C3S8btx0.js")).extract(ctx, parsed.flags);
+				break;
+			case "check":
+				result = await (await import("./check-HsmmpJZg.js")).check(ctx, parsed.flags);
+				break;
+			case "status":
+				result = await (await import("./status-zr4jY59Y.js")).status(ctx, parsed.flags);
+				break;
+			case "compile":
+				result = await (await import("./compile-BaDh0cHG.js")).compile(ctx, parsed.flags);
+				break;
+			case "translate":
+				result = await (await import("./translate-CQnJfLjO.js")).translate(ctx, parsed.flags);
+				break;
+			case "migrate":
+				result = await (await import("./migrate-rCQuOGsf.js")).migrate(ctx, parsed.flags);
+				break;
+			case "sitemap":
+				result = await (await import("./sitemap-DJXzKoza.js")).sitemap(ctx, parsed.flags);
+				break;
+			case "export":
+				result = await (await import("./export-C9Sy6UWv.js")).exportCatalogs(ctx, parsed.flags);
+				break;
+			case "import":
+				result = await (await import("./import-nANvQutw.js")).importCatalogs(ctx, parsed.flags);
+				break;
+			case "restore":
+				result = await (await import("./restore-CiYv-jxS.js")).restore(ctx, parsed.flags);
+				break;
+			case "which":
+				result = await (await import("./which-BOemZ5Q8.js")).which(ctx, parsed.flags);
+				break;
+			case "merge-driver":
+				result = await (await import("./merge-driver-BTX87aVm.js")).mergeDriver(ctx, parsed.flags);
+				break;
+			case "lsp":
+				result = await (await import("./lsp-RMMMc88P.js")).lsp(ctx, parsed.flags);
+				break;
+			case "mcp": result = await (await import("./mcp-CHVwBoRP.js")).mcp(ctx, parsed.flags);
+		}
+		exitCode = result.exitCode;
+		data = result.data;
+	} catch (error) {
+		if (error instanceof CliExit) {
+			out.report(error.diagnostics);
+			exitCode = error.exitCode;
+			data = error.data;
+		} else if (isDiagnosticError(error)) {
+			out.report([error.diagnostic]);
+			exitCode = error.diagnostic.code.startsWith("config-") ? EXIT.usage : EXIT.failure;
+		} else {
+			const message = error instanceof Error ? error.stack ?? error.message : String(error);
+			io.stderr(out.redact(`vi18n ${parsed.command}: ${message}\n`));
+			exitCode = EXIT.failure;
+		}
+	}
+	out.finish(parsed.command, exitCode, data);
+	return exitCode;
+}
+//#endregion
+export { run as t };