@verbaly/compiler 0.24.0 → 0.26.0

package/README.md

@@ -50,11 +50,11 @@ Catalogs are **flat JSON**: most TMS platforms (Crowdin, Lokalise, Phrase, …)
 
 ```bash
 npx verbaly export                    # verbaly-export/<locale>.xlf (XLIFF 2.0, source + target per unit)
-npx verbaly export --format csv       # spreadsheet-friendly: key,source,target
+npx verbaly export --format csv       # spreadsheet-friendly: key,source,target,location
 npx verbaly import verbaly-export/es.xlf   # fill the catalog back
 ```
 
-`export` writes one file per target locale with the source text alongside the current translation (`--missing` exports only the untranslated entries). `import` reads XLIFF 2.0/1.2 or CSV back and **validates every entry like `translate` does**: a translation that drops a `{param}`, a variant block or an `<em>` tag is rejected and reported, so a translator's typo can't break your UI. Existing translations are kept unless `--overwrite`; `--dry-run` previews everything.
+`export` writes one file per target locale with the source text alongside the current translation (`--missing` exports only the untranslated entries). Every entry carries **where the text lives in your source** (XLIFF `location` notes, a `location` column in CSV), so translators and TMS tools see the context instead of guessing it. `import` reads XLIFF 2.0/1.2 or CSV back and **validates every entry like `translate` does**: a translation that drops a `{param}`, a variant block or an `<em>` tag is rejected and reported, so a translator's typo can't break your UI. Existing translations are kept unless `--overwrite`; `--dry-run` previews everything.
 
 ## 📱 Mobile resources
 

package/dist/cli.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
+import { basename, dirname, join, relative, resolve } from "node:path";
 import { parseArgs } from "node:util";
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, watch, writeFileSync } from "node:fs";
-import { basename, dirname, join, relative, resolve } from "node:path";
-import { RICH_TAGS, createVerbaly, normalizeLink, parse, parseTags, safeAttribute } from "verbaly";
+import { RICH_TAGS, createVerbaly, localeDirection, normalizeLink, parse, parseTags, safeAttribute } from "verbaly";
 import { pathToFileURL } from "node:url";
 import { glob } from "tinyglobby";
 import { parse as parse$1 } from "@babel/parser";
 import { createHash } from "node:crypto";
 import MagicString from "magic-string";
+import "picomatch";
 //#region src/catalog.ts
 function catalogPath(cfg, locale) {
 	return join(cfg.dir, `${locale}.json`);
@@ -98,6 +99,57 @@ function formatCheckResult(result) {
 function truncate(text, max) {
 	return text.length > max ? text.slice(0, max - 1) + "…" : text;
 }
+function githubCheckAnnotations(result, registry, root) {
+	const messages = registry.messages();
+	const contents = /* @__PURE__ */ new Map();
+	const readSource = (file) => {
+		if (!contents.has(file)) try {
+			contents.set(file, readFileSync(file, "utf8"));
+		} catch {
+			contents.set(file, void 0);
+		}
+		return contents.get(file);
+	};
+	const lines = [];
+	const byKey = /* @__PURE__ */ new Map();
+	for (const entry of result.missing) {
+		const grouped = byKey.get(entry.key);
+		if (grouped) grouped.locales.push(entry.locale);
+		else byKey.set(entry.key, {
+			...entry,
+			locales: [entry.locale]
+		});
+	}
+	for (const entry of byKey.values()) {
+		const origin = messages.get(entry.key);
+		const hint = entry.source ? `: "${truncate(entry.source, 60)}"` : "";
+		const text = escapeData(`missing [${entry.locales.join(", ")}] ${entry.key}${hint}`);
+		if (origin) {
+			const file = relative(root, origin.file).replaceAll("\\", "/");
+			const content = readSource(origin.file);
+			const line = content === void 0 ? void 0 : lineAt(content, origin.start);
+			lines.push(`::error file=${escapeProperty(file)}${line ? `,line=${line}` : ""}::${text}`);
+		} else lines.push(`::error::${text}`);
+	}
+	for (const entry of result.unknown) {
+		const text = escapeData(`unknown key "${entry.key}" (not in any catalog)`);
+		const file = entry.files[0];
+		lines.push(file ? `::error file=${escapeProperty(relative(root, file).replaceAll("\\", "/"))}::${text}` : `::error::${text}`);
+	}
+	return lines;
+}
+function lineAt(content, offset) {
+	let line = 1;
+	const end = Math.min(offset, content.length);
+	for (let i = 0; i < end; i++) if (content[i] === "\n") line += 1;
+	return line;
+}
+function escapeData(text) {
+	return text.replaceAll("%", "%25").replaceAll("\r", "%0D").replaceAll("\n", "%0A");
+}
+function escapeProperty(text) {
+	return escapeData(text).replaceAll(":", "%3A").replaceAll(",", "%2C");
+}
 //#endregion
 //#region src/params.ts
 const PLURAL_KEYS = /* @__PURE__ */ new Set([
@@ -199,12 +251,13 @@ declare module 'virtual:verbaly/locale/*' {
 }
 `;
 }
-function writeDts(cfg, catalog) {
-	const file = join(cfg.root, "verbaly.d.ts");
+function writeDts(cfg, catalog, file) {
+	file ??= join(cfg.root, "verbaly.d.ts");
 	const content = generateDts(catalog);
 	try {
 		if (readFileSync(file, "utf8") === content) return;
 	} catch {}
+	mkdirSync(dirname(file), { recursive: true });
 	writeFileSync(file, content);
 }
 //#endregion
@@ -341,8 +394,9 @@ function resolveConfig(config = {}) {
 		dir,
 		sourceLocale,
 		locales: [...locales],
-		include: config.include ?? ["{src,app}/**/*.{js,jsx,ts,tsx,mjs,mts,svelte,vue}"],
+		include: config.include ?? ["{src,app}/**/*.{js,jsx,ts,tsx,mjs,mts,svelte,vue,astro}"],
 		exclude: config.exclude ?? ["**/node_modules/**", "**/dist/**"],
+		dts: typeof config.dts === "string" ? resolve(root, config.dts) : config.dts,
 		translate: config.translate ?? {},
 		render: config.render ?? {}
 	};
@@ -427,6 +481,15 @@ var MessageRegistry = class {
 		}
 		return out;
 	}
+	origins() {
+		const out = this.usedKeys();
+		for (const analysis of this.files.values()) for (const msg of analysis.tagged) {
+			const files = out.get(msg.key) ?? [];
+			if (!files.includes(msg.file)) files.push(msg.file);
+			out.set(msg.key, files);
+		}
+		return out;
+	}
 };
 //#endregion
 //#region src/key.ts
@@ -696,13 +759,14 @@ function isNode(value) {
 }
 //#endregion
 //#region src/sfc.ts
-const SFC_FILE_RE = /\.(?:svelte|vue)$/;
+const SFC_FILE_RE = /\.(?:svelte|vue|astro)$/;
 function analyzeFile(code, file) {
 	return SFC_FILE_RE.test(file) ? analyzeSfc(code, file) : analyze(code, file);
 }
 const SCRIPT_RE = /(<script\b[^>]*>)([\s\S]*?)(<\/script\s*>)/gi;
 const STYLE_RE = /<style\b[^>]*>[\s\S]*?<\/style\s*>/gi;
 const COMMENT_RE = /<!--[\s\S]*?-->/g;
+const FRONTMATTER_RE = /^(\uFEFF?\s*---\r?\n)([\s\S]*?)\r?\n---(?=\r?\n|$)/;
 const CANDIDATE_SVELTE = /(?<![\w$])\$?t(?=[`(]|\.id\()/g;
 const CANDIDATE_VUE = /(?<![\w$])t(?=[`(]|\.id\()/g;
 function analyzeSfc(code, file) {
@@ -710,12 +774,14 @@ function analyzeSfc(code, file) {
 	const options = svelte ? { tNames: ["t", "$t"] } : void 0;
 	const tagged = [];
 	const usedKeys = [];
+	const frontmatter = file.endsWith(".astro") ? FRONTMATTER_RE.exec(code) : null;
+	if (frontmatter?.[2]) merge(analyzeSegment(frontmatter[2], file, options), frontmatter[1].length, false);
 	for (const match of code.matchAll(SCRIPT_RE)) {
 		const content = match[2];
 		if (!content) continue;
 		merge(analyzeSegment(content, file, options), match.index + match[1].length, false);
 	}
-	const markup = blank(blank(blank(code, SCRIPT_RE), STYLE_RE), COMMENT_RE);
+	const markup = blank(blank(blank(frontmatter ? " ".repeat(frontmatter[0].length) + code.slice(frontmatter[0].length) : code, SCRIPT_RE), STYLE_RE), COMMENT_RE);
 	const candidates = svelte ? CANDIDATE_SVELTE : CANDIDATE_VUE;
 	let consumedTo = 0;
 	for (const match of markup.matchAll(candidates)) {
@@ -845,6 +911,7 @@ function pruneCatalogs(cfg, catalogs, registry) {
 //#endregion
 //#region src/init.ts
 const BUNDLERS = [
+	"astro",
 	"vite",
 	"webpack",
 	"rollup",
@@ -898,7 +965,8 @@ function init(options = {}) {
 	}
 	const bundler = detectBundler(root);
 	const next = [];
-	if (bundler === "vite") next.push("install the plugin: pnpm add -D @verbaly/vite", "add verbaly() to the plugins in vite.config");
+	if (bundler === "astro") next.push("install the integration: pnpm add -D @verbaly/astro", "add verbaly() to the integrations in astro.config");
+	else if (bundler === "vite") next.push("install the plugin: pnpm add -D @verbaly/vite", "add verbaly() to the plugins in vite.config");
 	else if (bundler) next.push("install the plugin: pnpm add -D @verbaly/unplugin", `add the verbaly ${bundler} plugin to your build config`);
 	else next.push("run \"verbaly extract\" after writing your first t`…` message");
 	return {
@@ -971,8 +1039,8 @@ async function doctor(cfg) {
 	else if (wired) ok("plugin", `${deps["@verbaly/vite"] ? "@verbaly/vite" : "@verbaly/unplugin"} installed for ${bundler}`);
 	else if (bundler === "vite") warn("plugin", "vite detected but @verbaly/vite is not installed", "pnpm add -D @verbaly/vite and add verbaly() to the plugins in vite.config");
 	else warn("plugin", `${bundler} detected but @verbaly/unplugin is not installed`, `pnpm add -D @verbaly/unplugin and add the verbaly ${bundler} plugin to your build config`);
-	if (source) {
-		const dtsPath = join(cfg.root, "verbaly.d.ts");
+	if (source && cfg.dts !== false) {
+		const dtsPath = cfg.dts ?? join(cfg.root, "verbaly.d.ts");
 		if (!existsSync(dtsPath)) warn("types", "verbaly.d.ts has not been generated", "run `npx verbaly extract`");
 		else if (readFileSync(dtsPath, "utf8") !== generateDts(source)) warn("types", "verbaly.d.ts is stale", "run `npx verbaly extract`");
 		else ok("types", "verbaly.d.ts is up to date");
@@ -1128,7 +1196,8 @@ function exportCatalogs(cfg, catalogs, options = {}) {
 		const all = Object.keys(source).filter((key) => source[key]).sort().map((key) => ({
 			key,
 			source: source[key],
-			target: catalog[key] ?? ""
+			target: catalog[key] ?? "",
+			location: options.origins?.[key]
 		}));
 		const untranslated = all.filter((entry) => !entry.target);
 		const entries = options.missing ? untranslated : all;
@@ -1224,8 +1293,13 @@ function parseExchangeFile(file, localeOverride) {
 	throw new Error(`[verbaly] ${file}: unsupported format, expected .xlf, .xliff or .csv.`);
 }
 function toXliff(sourceLocale, locale, entries) {
-	const units = entries.map(({ key, source, target }) => [
+	const units = entries.map(({ key, source, target, location }) => [
 		`    <unit id="${escapeXml(key)}">`,
+		...location?.length ? [
+			"      <notes>",
+			...location.map((file) => `        <note category="location">${escapeXml(file)}</note>`),
+			"      </notes>"
+		] : [],
 		`      <segment state="${target ? "translated" : "initial"}">`,
 		`        <source>${escapeXml(source)}</source>`,
 		`        <target>${escapeXml(target)}</target>`,
@@ -1275,8 +1349,8 @@ function unescapeXml(text) {
 }
 function toCsv(entries) {
 	return [
-		"key,source,target",
-		...entries.map(({ key, source, target }) => `${csvField(key)},${csvField(source)},${csvField(target)}`),
+		"key,source,target,location",
+		...entries.map(({ key, source, target, location }) => `${csvField(key)},${csvField(source)},${csvField(target)},${csvField(location?.join("; ") ?? "")}`),
 		""
 	].join("\r\n");
 }
@@ -1378,6 +1452,7 @@ function renderHtml(html, options) {
 		const chunkStart = m.index + 1 + rawName.length;
 		if (tagName === "html" && options.setLang !== false) {
 			setAttribute(ms, html, chunkStart, openEnd, attrChunk, "lang", options.locale);
+			setAttribute(ms, html, chunkStart, openEnd, attrChunk, "dir", localeDirection(options.locale));
 			continue;
 		}
 		const attrs = parseAttrs(attrChunk);
@@ -1628,7 +1703,7 @@ function formatStatusResult(result) {
 	}
 	return lines.join("\n");
 }
-const SOURCE_FILE_RE = /\.(?:[cm]?[jt]sx?|svelte|vue)$/;
+const SOURCE_FILE_RE = /\.(?:[cm]?[jt]sx?|svelte|vue|astro)$/;
 //#endregion
 //#region src/watch.ts
 function watchProject(cfg, run, options = {}) {
@@ -1671,12 +1746,225 @@ function watchProject(cfg, run, options = {}) {
 	};
 }
 //#endregion
+//#region src/wrap.ts
+const WRAP_ATTRS = /* @__PURE__ */ new Set([
+	"title",
+	"alt",
+	"placeholder",
+	"aria-label"
+]);
+const T_NAMES = /* @__PURE__ */ new Set(["t"]);
+const LETTER = /\p{L}/u;
+async function wrapProject(cfg, options = {}) {
+	const files = (await glob(cfg.include, {
+		cwd: cfg.root,
+		ignore: cfg.exclude,
+		absolute: true
+	})).filter((file) => /\.[jt]sx$/.test(file));
+	const result = {
+		files: files.length,
+		changed: [],
+		wrapped: [],
+		skipped: []
+	};
+	for (const file of files) {
+		const code = readFileSync(file, "utf8");
+		const label = relative(cfg.root, file).replaceAll("\\", "/");
+		const out = wrapCode(code, label);
+		result.wrapped.push(...out.wrapped);
+		result.skipped.push(...out.skipped);
+		if (out.code !== void 0) {
+			result.changed.push(label);
+			if (options.write) writeFileSync(file, out.code);
+		}
+	}
+	return result;
+}
+function wrapCode(code, file) {
+	const wrapped = [];
+	const skipped = [];
+	let ast;
+	try {
+		ast = parse$1(code, {
+			sourceType: "module",
+			errorRecovery: true,
+			plugins: ["typescript", "jsx"]
+		}).program;
+	} catch {
+		return {
+			wrapped,
+			skipped
+		};
+	}
+	const s = new MagicString(code);
+	const visited = /* @__PURE__ */ new Set();
+	let changed = false;
+	walk(ast, (node) => {
+		if (node.type !== "JSXElement" && node.type !== "JSXFragment") return;
+		if (visited.has(node)) return;
+		processElement(node);
+	});
+	return changed ? {
+		code: s.toString(),
+		wrapped,
+		skipped
+	} : {
+		wrapped,
+		skipped
+	};
+	function processElement(node) {
+		visited.add(node);
+		if (node.type === "JSXElement") {
+			const opening = node.openingElement;
+			const name = opening.name;
+			if (name.type === "JSXIdentifier" && name.name === "Trans") return markSubtree(node);
+			if (hasVerbalyAttr(opening)) return markSubtree(node);
+			wrapAttributes(opening);
+		}
+		const children = node.children ?? [];
+		const hasElementChild = children.some((c) => c.type === "JSXElement" || c.type === "JSXFragment");
+		const hasText = children.some((c) => c.type === "JSXText" && LETTER.test(c.value) || c.type === "JSXExpressionContainer" && c.expression.type === "StringLiteral" && LETTER.test(c.expression.value));
+		if (hasElementChild && hasText) {
+			skip(node, snippet(children), "mixed text and markup: wrap by hand or use <Trans>");
+			return markSubtree(node);
+		}
+		if (hasText) {
+			wrapSegment(node, children);
+			return markSubtree(node);
+		}
+		for (const child of children) if (child.type === "JSXElement" || child.type === "JSXFragment") processElement(child);
+	}
+	function wrapSegment(parent, children) {
+		const meaningful = children.filter((c) => c.type === "JSXText" && c.value.trim() !== "" || c.type === "JSXExpressionContainer" && c.expression.type !== "JSXEmptyExpression");
+		if (meaningful.length === 0) return;
+		const first = meaningful[0];
+		const last = meaningful[meaningful.length - 1];
+		let template = "";
+		let report = "";
+		for (let i = children.indexOf(first); i <= children.indexOf(last); i++) {
+			const child = children[i];
+			if (child.type === "JSXText") {
+				let value = cleanJsxText(child.value);
+				if (child === first) value = value.trimStart();
+				if (child === last) value = value.trimEnd();
+				template += escapeTemplate(value);
+				report += value;
+			} else if (child.type === "JSXExpressionContainer") {
+				const expr = child.expression;
+				if (expr.type === "JSXEmptyExpression") continue;
+				if (usesT(expr)) {
+					skip(parent, snippet(children), "already uses t: finish it by hand");
+					return;
+				}
+				if (containsJsx(expr)) {
+					skip(parent, snippet(children), "an expression renders markup: wrap by hand or use <Trans>");
+					markSubtree(child);
+					return;
+				}
+				if (expr.type === "StringLiteral") {
+					template += escapeTemplate(expr.value);
+					report += expr.value;
+				} else {
+					const source = code.slice(expr.start, expr.end);
+					template += "${" + source + "}";
+					report += "${" + source + "}";
+				}
+			} else return;
+		}
+		if (!LETTER.test(report)) return;
+		const start = first.type === "JSXText" ? first.start + leadingWs(first.value) : first.start;
+		const end = last.type === "JSXText" ? last.end - trailingWs(last.value) : last.end;
+		s.overwrite(start, end, "{t`" + template + "`}");
+		changed = true;
+		wrapped.push({
+			file,
+			line: line(first),
+			text: report,
+			kind: "text"
+		});
+	}
+	function wrapAttributes(opening) {
+		for (const attr of opening.attributes) {
+			if (attr.type !== "JSXAttribute") continue;
+			const name = attr.name;
+			if (name.type !== "JSXIdentifier" || !WRAP_ATTRS.has(name.name)) continue;
+			const value = attr.value;
+			if (value?.type !== "StringLiteral") continue;
+			const raw = value.value;
+			if (!LETTER.test(raw)) continue;
+			s.overwrite(value.start, value.end, "{t`" + escapeTemplate(raw) + "`}");
+			changed = true;
+			wrapped.push({
+				file,
+				line: line(value),
+				text: raw,
+				kind: "attribute",
+				attribute: name.name
+			});
+		}
+	}
+	function skip(node, text, reason) {
+		skipped.push({
+			file,
+			line: line(node),
+			text,
+			reason
+		});
+	}
+	function snippet(children) {
+		const start = children[0]?.start ?? 0;
+		const end = children[children.length - 1]?.end ?? start;
+		const text = code.slice(start, end).replace(/\s+/g, " ").trim();
+		return text.length > 60 ? text.slice(0, 59) + "…" : text;
+	}
+	function markSubtree(node) {
+		walk(node, (n) => {
+			if (n.type === "JSXElement" || n.type === "JSXFragment") visited.add(n);
+		});
+	}
+}
+function hasVerbalyAttr(opening) {
+	return opening.attributes.some((attr) => {
+		if (attr.type !== "JSXAttribute") return false;
+		const name = attr.name;
+		return name.type === "JSXIdentifier" && name.name.startsWith("data-verbaly");
+	});
+}
+function usesT(node) {
+	let found = false;
+	walk(node, (n) => {
+		if (n.type === "TaggedTemplateExpression" && isTReference(n.tag, T_NAMES)) found = true;
+		if (n.type === "CallExpression" && isTReference(n.callee, T_NAMES)) found = true;
+	});
+	return found;
+}
+function containsJsx(node) {
+	let found = false;
+	walk(node, (n) => {
+		if (n.type === "JSXElement" || n.type === "JSXFragment") found = true;
+	});
+	return found;
+}
+function escapeTemplate(text) {
+	return text.replace(/[\\`]/g, "\\$&").replace(/\$\{/g, "\\${");
+}
+function leadingWs(text) {
+	return text.length - text.trimStart().length;
+}
+function trailingWs(text) {
+	return text.length - text.trimEnd().length;
+}
+function line(node) {
+	return node.loc?.start?.line ?? 1;
+}
+//#endregion
 //#region src/run.ts
 const HELP = `verbaly · i18n compiler
 
 Usage:
   verbaly init       scaffold config + locale catalogs (detects your bundler)
   verbaly doctor     diagnose the setup (config, catalogs, plugin, types, keys)
+  verbaly wrap       find hardcoded JSX text and wrap it in t\`…\` (report; --write applies)
   verbaly extract    scan sources, update catalogs and types
   verbaly status     translation coverage per locale, at a glance
   verbaly check      verify translations are complete (CI)
@@ -1693,6 +1981,9 @@ Options:
   --locales <csv>    extra locales; for translate: target locales to fill
   --prune            drop keys no longer referenced (extract)
   --watch            keep extracting as source files change (extract)
+  --write            apply the rewrites instead of only reporting (wrap)
+  --json             machine-readable output (status)
+  --reporter <name>  failure format: text (default) or github annotations (check)
   --model <id>       model override for the claude provider (translate)
   --dry-run          list what would happen, write nothing (translate, import, extract)
   --format <f>       export format: xliff (default), csv, android-xml or ios-strings (export)
@@ -1720,6 +2011,9 @@ async function runCli(args = process.argv.slice(2)) {
 			locales: { type: "string" },
 			prune: { type: "boolean" },
 			watch: { type: "boolean" },
+			write: { type: "boolean" },
+			json: { type: "boolean" },
+			reporter: { type: "string" },
 			model: { type: "string" },
 			locale: { type: "string" },
 			site: { type: "string" },
@@ -1802,7 +2096,7 @@ async function runCli(args = process.argv.slice(2)) {
 			const { added } = syncCatalogs(cfg, catalogs, registry);
 			if (!dryRun) {
 				for (const locale of cfg.locales) writeCatalog(cfg, locale, catalogs[locale] ?? {});
-				writeDts(cfg, catalogs[cfg.sourceLocale] ?? {});
+				if (cfg.dts !== false) writeDts(cfg, catalogs[cfg.sourceLocale] ?? {}, cfg.dts);
 			}
 			const total = registry.messages().size;
 			console.log(`[verbaly] ${total} messages · locales: ${cfg.locales.join(", ")}${dryRun ? " (dry run, nothing written)" : ""}`);
@@ -1815,19 +2109,49 @@ async function runCli(args = process.argv.slice(2)) {
 		}
 		return;
 	}
+	if (command === "wrap") {
+		const result = await wrapProject(cfg, { write: values.write });
+		if (result.wrapped.length === 0 && result.skipped.length === 0) {
+			console.log(`[verbaly] nothing to wrap (${result.files} files scanned) ✓`);
+			return;
+		}
+		const verb = values.write ? "wrapped" : "would wrap";
+		const note = values.write ? "" : " (report only, use --write to apply)";
+		console.log(`[verbaly] ${verb} ${result.wrapped.length} texts in ${result.changed.length} files${note}`);
+		for (const entry of result.wrapped) {
+			const attr = entry.kind === "attribute" ? `${entry.attribute} → ` : "";
+			console.log(`  ${entry.file}:${entry.line}  ${attr}"${entry.text}"`);
+		}
+		if (result.skipped.length > 0) {
+			console.log("  needs a human:");
+			for (const entry of result.skipped) console.log(`  ${entry.file}:${entry.line}  "${entry.text}" (${entry.reason})`);
+		}
+		if (values.write && result.changed.length > 0) console.log("  next: make t available where TS complains (React: const t = useT()), then run verbaly extract");
+		return;
+	}
 	if (command === "status") {
 		const registry = await extractProject(cfg);
-		console.log(formatStatusResult(status(cfg, loadCatalogs(cfg), registry)));
+		const result = status(cfg, loadCatalogs(cfg), registry);
+		console.log(values.json ? JSON.stringify(result) : formatStatusResult(result));
 		return;
 	}
 	if (command === "check") {
+		const reporter = values.reporter ?? "text";
+		if (reporter !== "text" && reporter !== "github") {
+			console.error(`[verbaly] unknown reporter "${values.reporter}", use text or github`);
+			process.exitCode = 1;
+			return;
+		}
 		const registry = await extractProject(cfg);
 		const result = check(cfg, loadCatalogs(cfg), registry);
 		if (result.ok) {
 			console.log("[verbaly] all translations complete ✓");
 			return;
 		}
-		console.error(`[verbaly] check failed\n${formatCheckResult(result)}`);
+		if (reporter === "github") {
+			for (const line of githubCheckAnnotations(result, registry, cfg.root)) console.error(line);
+			console.error(`[verbaly] check failed: ${result.missing.length} missing, ${result.unknown.length} unknown`);
+		} else console.error(`[verbaly] check failed\n${formatCheckResult(result)}`);
 		process.exitCode = 1;
 		return;
 	}
@@ -1876,7 +2200,8 @@ async function runCli(args = process.argv.slice(2)) {
 			locales: values.locales?.split(","),
 			format,
 			out: values.out,
-			missing: values.missing
+			missing: values.missing,
+			origins: isMobileFormat(format) ? void 0 : await collectOrigins(cfg)
 		});
 		if (result.files.length === 0) {
 			console.log("[verbaly] no target locales to export (add locales to your config)");
@@ -1950,8 +2275,9 @@ const COMMAND_FLAGS = {
 		"dry-run",
 		"watch"
 	],
-	status: [],
-	check: [],
+	wrap: ["write"],
+	status: ["json"],
+	check: ["reporter"],
 	translate: ["model", "dry-run"],
 	export: [
 		"format",
@@ -1982,6 +2308,12 @@ function rejectStrayFlags(command, values) {
 	process.exitCode = 1;
 	return true;
 }
+async function collectOrigins(cfg) {
+	const registry = await extractProject(cfg);
+	const origins = {};
+	for (const [key, files] of registry.origins()) origins[key] = files.map((file) => relative(cfg.root, file).replaceAll("\\", "/"));
+	return origins;
+}
 async function resolveProvider(cfg, model) {
 	const configured = cfg.translate.provider;
 	if (typeof configured === "function") return configured;