@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/status-DZArW5aE.js

@@ -0,0 +1,149 @@
+import { s as catalogPath } from "./library-D5CWvTQs.js";
+import { a as table, i as rootRelative } from "./output-DsaHKHEt.js";
+import { t as EXIT } from "./types-wSh9fCBY.js";
+import { a as loadCatalogs, c as ownStatus, d as referencedMessages, f as scan, i as hasErrors, l as percent, o as loadProject, p as targetLocales } from "./project-Dwx7iPm6.js";
+import { dirname, join, relative } from "node:path";
+import { readFile, stat } from "node:fs/promises";
+//#region src/cli/commands/status.ts
+/**
+* `vi18n status [--json] [--locale l]…` (INTERNALS §2.14, PLAN §5.19): per
+* target locale, how many referenced messages (code plus `keep` ids) its own
+* catalog translates, by people or AI; per bundle from the last client build
+* report when there is one. `--json` lists the entries counted as missing
+* because they are invalid or fuzzy, for agents to fix.
+*/
+/** The client environment's report (INTERNALS §2.9.8); server builds plan no bundles. */
+const REPORT = join("vi18n", "report-client.json");
+async function status(ctx, flags) {
+	const project = await loadProject(ctx);
+	const { config } = project;
+	const locales = targetLocales(config, flags.locales);
+	const scanned = await scan(project);
+	const loaded = await loadCatalogs(project);
+	ctx.out.report(loaded.diagnostics.filter((d) => d.severity === "error"));
+	const referenced = referencedMessages(project, scanned.messages, loaded.set);
+	ctx.out.report(referenced.diagnostics);
+	const data = {
+		sourceLocale: config.sourceLocale,
+		locales: [],
+		invalid: []
+	};
+	for (const locale of locales) {
+		const catalog = loaded.set.get(locale);
+		const own = ownStatus(project, locale, catalog, referenced.identities);
+		data.locales.push({
+			locale,
+			total: own.total,
+			translated: own.translated,
+			ai: own.ai,
+			missing: own.missing,
+			percent: percent(own.translated + own.ai, own.total)
+		});
+		const file = rootRelative(config.root, catalog?.path ?? catalogPath(config, locale));
+		for (const item of own.invalid) data.invalid.push({
+			locale,
+			id: item.id,
+			reason: item.reason,
+			file,
+			line: item.line
+		});
+	}
+	const report = await readReport(ctx, project);
+	if (report !== null) {
+		const bundles = [];
+		for (const locale of locales) {
+			const coverage = report.coverage[locale];
+			if (coverage === void 0) continue;
+			for (const key of Object.keys(coverage).sort()) {
+				const c = coverage[key];
+				bundles.push({
+					key,
+					locale,
+					total: c.total,
+					translated: c.translated,
+					ai: c.ai,
+					missing: c.missing,
+					percent: percent(c.translated + c.ai, c.total)
+				});
+			}
+		}
+		data.bundles = bundles;
+	}
+	const row = (r) => [
+		r.locale,
+		r.total,
+		r.translated,
+		r.ai,
+		r.missing,
+		r.percent
+	];
+	ctx.out.result(table([
+		"locale",
+		"total",
+		"translated",
+		"ai",
+		"missing",
+		"%"
+	], data.locales.map(row)));
+	if (data.bundles !== void 0 && data.bundles.length > 0) {
+		ctx.out.result("");
+		ctx.out.result(table([
+			"bundle",
+			"locale",
+			"total",
+			"translated",
+			"ai",
+			"missing",
+			"%"
+		], data.bundles.map((r) => [r.key, ...row(r)])));
+	}
+	if (data.invalid.length > 0) ctx.out.result(`\n${data.invalid.length} entries are counted as missing because they are invalid or fuzzy; run vi18n check for details`);
+	return {
+		exitCode: hasErrors(ctx.out.diagnostics) ? EXIT.failure : EXIT.ok,
+		data
+	};
+}
+/**
+* The newest `report-client.json` under a Vite cache directory the project
+* can have: Vite's default `node_modules/.vite` of the config root, or of
+* any directory between an include entry and the root (an app inside a
+* workspace whose config sits at the repository root). The CLI cannot load
+* the Vite config, so a custom `cacheDir` is not seen. A report built with
+* another id scheme describes other ids and is ignored.
+*/
+async function readReport(ctx, project) {
+	const { config, codec } = project;
+	const dirs = /* @__PURE__ */ new Set([config.root]);
+	for (const entry of config.project.include) for (let dir = dirname(entry);; dir = dirname(dir)) {
+		const rel = relative(config.root, dir);
+		if (rel.startsWith("..") || dir === dirname(dir)) break;
+		dirs.add(dir);
+		if (rel === "") break;
+	}
+	let best = null;
+	for (const dir of dirs) {
+		const file = join(dir, "node_modules", ".vite", REPORT);
+		try {
+			const info = await stat(file);
+			if (best === null || info.mtimeMs > best.mtime) best = {
+				file,
+				mtime: info.mtimeMs
+			};
+		} catch {}
+	}
+	if (best === null) return null;
+	try {
+		const report = JSON.parse(await readFile(best.file, "utf8"));
+		if (report.version !== 1 || typeof report.coverage !== "object" || report.coverage === null) return null;
+		if (report.idScheme !== codec.idScheme) {
+			ctx.out.note(`vi18n: ignoring ${ctx.out.display(best.file)}: built with ${report.idScheme}, not ${codec.idScheme}; rebuild for per-bundle numbers`);
+			return null;
+		}
+		return report;
+	} catch {
+		ctx.out.note(`vi18n: ignoring ${ctx.out.display(best.file)}: not a vi18n build report`);
+		return null;
+	}
+}
+//#endregion
+export { status };

package/dist/stdio-CVaJfxA7.js

@@ -0,0 +1,29 @@
+import { format } from "node:util";
+//#region src/cli/stdio.ts
+/**
+* For the commands that speak a protocol on stdout (`lsp`, `mcp`): one stray
+* `console.log` (from a config module, a framework compiler, Vite) would be
+* read by the client as a malformed message, so while they run the console
+* writes to stderr, which editors and agents show as the server's log.
+*/
+function protocolConsole(output) {
+	if (output !== process.stdout) return () => {};
+	const { log, info, debug } = console;
+	const toStderr = (...args) => {
+		process.stderr.write(format(...args) + "\n");
+	};
+	Object.assign(console, {
+		log: toStderr,
+		info: toStderr,
+		debug: toStderr
+	});
+	return () => {
+		Object.assign(console, {
+			log,
+			info,
+			debug
+		});
+	};
+}
+//#endregion
+export { protocolConsole as t };

package/dist/stdio-FPOKQAgu.js

@@ -0,0 +1,95 @@
+import { y as JSONRPCMessageSchema } from "./types-DtvQ7UdD.js";
+import process from "node:process";
+/**
+* Buffers a continuous stdio stream into discrete JSON-RPC messages.
+*/
+var ReadBuffer = class {
+	constructor(options) {
+		this._maxBufferSize = options?.maxBufferSize ?? 10485760;
+	}
+	append(chunk) {
+		if ((this._buffer?.length ?? 0) + chunk.length > this._maxBufferSize) {
+			this.clear();
+			throw new Error(`ReadBuffer exceeded maximum size of ${this._maxBufferSize} bytes`);
+		}
+		this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
+	}
+	readMessage() {
+		if (!this._buffer) return null;
+		const index = this._buffer.indexOf("\n");
+		if (index === -1) return null;
+		const line = this._buffer.toString("utf8", 0, index).replace(/\r$/, "");
+		this._buffer = this._buffer.subarray(index + 1);
+		return deserializeMessage(line);
+	}
+	clear() {
+		this._buffer = void 0;
+	}
+};
+function deserializeMessage(line) {
+	return JSONRPCMessageSchema.parse(JSON.parse(line));
+}
+function serializeMessage(message) {
+	return JSON.stringify(message) + "\n";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.32.1_supports-color@10.2.2_zod@4.6.7/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
+/**
+* Server transport for stdio: this communicates with an MCP client by reading from the current process' stdin and writing to stdout.
+*
+* This transport is only available in Node.js environments.
+*/
+var StdioServerTransport = class {
+	constructor(_stdin = process.stdin, _stdout = process.stdout, options) {
+		this._stdin = _stdin;
+		this._stdout = _stdout;
+		this._started = false;
+		this._ondata = (chunk) => {
+			try {
+				this._readBuffer.append(chunk);
+				this.processReadBuffer();
+			} catch (error) {
+				this.onerror?.(error);
+				this.close().catch(() => {});
+			}
+		};
+		this._onerror = (error) => {
+			this.onerror?.(error);
+		};
+		this._readBuffer = new ReadBuffer({ maxBufferSize: options?.maxBufferSize });
+	}
+	/**
+	* Starts listening for messages on stdin.
+	*/
+	async start() {
+		if (this._started) throw new Error("StdioServerTransport already started! If using Server class, note that connect() calls start() automatically.");
+		this._started = true;
+		this._stdin.on("data", this._ondata);
+		this._stdin.on("error", this._onerror);
+	}
+	processReadBuffer() {
+		while (true) try {
+			const message = this._readBuffer.readMessage();
+			if (message === null) break;
+			this.onmessage?.(message);
+		} catch (error) {
+			this.onerror?.(error);
+		}
+	}
+	async close() {
+		this._stdin.off("data", this._ondata);
+		this._stdin.off("error", this._onerror);
+		if (this._stdin.listenerCount("data") === 0) this._stdin.pause();
+		this._readBuffer.clear();
+		this.onclose?.();
+	}
+	send(message) {
+		return new Promise((resolve) => {
+			const json = serializeMessage(message);
+			if (this._stdout.write(json)) resolve();
+			else this._stdout.once("drain", resolve);
+		});
+	}
+};
+//#endregion
+export { StdioServerTransport };