@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/openai-CTaMDcl-.js

@@ -0,0 +1,346 @@
+import { a as diagnosticError } from "./types-D3QGM8XO.js";
+/** Longest wait between retries, whatever the server asks for. */
+const MAX_DELAY_MS = 6e4;
+/** Error bodies are quoted in messages; past this they are noise. */
+const MAX_DETAIL = 300;
+/**
+* One request, rate limits waited out: on a rate limit, `onRateLimit` hears
+* of it, then the request is sent again after the server's delay (else
+* 2ⁿ s, at most {@link MAX_DELAY_MS}), up to {@link RATE_LIMIT_RETRIES}
+* times. Returns the first answer that is not a rate limit; a network
+* failure is an `ai-provider-error`, an abort is rethrown as it is.
+*/
+async function exchange(options) {
+	const { signal, key } = options;
+	for (let attempt = 0;; attempt++) {
+		signal?.throwIfAborted();
+		let response;
+		try {
+			response = await options.fetch(options.url, {
+				...options.init,
+				...signal === void 0 ? {} : { signal }
+			});
+		} catch (error) {
+			if (signal?.aborted === true || isAbort(error)) throw error;
+			throw providerError(`${options.label}: request failed: ${errorText(error)}`, key);
+		}
+		const text = await response.text();
+		const answer = {
+			status: response.status,
+			ok: response.ok,
+			headers: response.headers,
+			text,
+			json: parseJson(text)
+		};
+		if (answer.ok || !options.isRateLimit(answer)) return answer;
+		if (attempt >= 5) throw providerError(`${options.label} is still rate-limited after 5 retries (HTTP ${answer.status}); ${options.advice}: ${detail(answer, key)}`, key);
+		const asked = options.serverDelay(answer);
+		options.onRateLimit?.(asked);
+		await sleep(Math.min(asked ?? 1e3 * 2 ** attempt, MAX_DELAY_MS), signal);
+	}
+}
+/** The user content of a request: the items as data. */
+function requestText(request) {
+	return JSON.stringify({
+		sourceLocale: request.sourceLocale,
+		targetLocale: request.targetLocale,
+		items: request.items
+	});
+}
+/**
+* The `{ items: [{ id, translation }] }` an answer text holds. Strict: the
+* whole text is the JSON, or one fenced block holding only it (models
+* without structured output wrap their answer so). Anything else yields no
+* items, so the pipeline retries every item instead of failing the batch.
+*/
+function answerItems(text) {
+	const trimmed = text.trim();
+	const fenced = /^```(?:json)?[ \t]*\n([\s\S]*)\n```$/.exec(trimmed);
+	const items = field(parseJson(fenced === null ? trimmed : fenced[1]), "items");
+	const out = [];
+	if (!Array.isArray(items)) return out;
+	for (const item of items) {
+		const id = field(item, "id");
+		const translation = field(item, "translation");
+		if (typeof id === "string" && typeof translation === "string") out.push({
+			id,
+			translation
+		});
+	}
+	return out;
+}
+function field(value, name) {
+	return typeof value === "object" && value !== null ? value[name] : void 0;
+}
+function count(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function parseJson(text) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
+}
+/**
+* The server's error text, shortened. The key is redacted before the cut: a
+* cut through an echoed key would leave a prefix that `redact` no longer
+* recognises.
+*/
+function detail(answer, key) {
+	const message = field(field(answer.json, "error"), "message");
+	const flat = redact(typeof message === "string" ? message : answer.text, key).replace(/\s+/g, " ").trim();
+	return flat.length > MAX_DETAIL ? `${flat.slice(0, MAX_DETAIL)}…` : flat || "(empty body)";
+}
+/** `Retry-After` in seconds (an HTTP date is not worth parsing for a wait this short). */
+function retryAfterDelay(headers) {
+	const value = headers.get("retry-after");
+	if (value === null || !/^\d+$/.test(value.trim())) return null;
+	return Number(value) * 1e3;
+}
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted === true) {
+			reject(signal.reason);
+			return;
+		}
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(signal?.reason);
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function isAbort(error) {
+	return error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError");
+}
+function errorText(error) {
+	if (error instanceof Error) {
+		const cause = error.cause;
+		return cause instanceof Error ? `${error.message} (${cause.message})` : error.message;
+	}
+	return String(error);
+}
+/** Servers echo requests in errors; the key must never reach a terminal or a log. */
+function redact(text, secret) {
+	return secret === "" ? text : text.split(secret).join("***");
+}
+function providerError(message, key) {
+	return diagnosticError({
+		code: "ai-provider-error",
+		severity: "error",
+		message: redact(message, key)
+	});
+}
+/** The key in `env[name]`, or null when it is unset or blank. */
+function readKey(env, name) {
+	const key = (env ?? globalThis.process?.env ?? {})[name];
+	return key === void 0 || key.trim() === "" ? null : key;
+}
+const OPENAI_KEY_ENV = "OPENAI_API_KEY";
+/** `--provider` names: the built-in Gemini provider and the presets below. */
+const PROVIDER_PRESETS = [
+	"gemini",
+	"openai",
+	"openrouter",
+	"ollama"
+];
+/**
+* OpenRouter's key variable is named here, which is the explicit
+* `apiKeyEnv` for its host; Ollama runs locally and gets no key.
+*/
+const PRESETS = {
+	openai: {},
+	openrouter: {
+		baseURL: "https://openrouter.ai/api/v1",
+		apiKeyEnv: "OPENROUTER_API_KEY"
+	},
+	ollama: { baseURL: "http://localhost:11434/v1" }
+};
+/** `vi18n translate --provider openai|openrouter|ollama --model <id>`. */
+function openaiPreset(name, options) {
+	return openaiCompatible({
+		...PRESETS[name],
+		...options
+	});
+}
+const FORMATS = [
+	"json_schema",
+	"json_object",
+	"text"
+];
+function openaiCompatible(options) {
+	if (typeof options?.model !== "string" || options.model.trim() === "") throw diagnosticError({
+		code: "config-invalid",
+		severity: "error",
+		message: "openaiCompatible() needs a model, e.g. { model: \"gpt-5-mini\" }"
+	});
+	const model = options.model;
+	const base = (options.baseURL ?? "https://api.openai.com/v1").replace(/\/+$/, "");
+	let origin;
+	try {
+		origin = new URL(base).origin;
+	} catch {
+		throw diagnosticError({
+			code: "config-invalid",
+			severity: "error",
+			message: `openaiCompatible({ baseURL: ${JSON.stringify(base)} }) is not a URL`
+		});
+	}
+	const apiKeyEnv = options.apiKeyEnv ?? (origin === new URL("https://api.openai.com/v1").origin ? OPENAI_KEY_ENV : null);
+	const url = `${base}/chat/completions`;
+	const label = `${model} (${origin})`;
+	const missingKey = () => apiKeyEnv !== null && readKey(options.env, apiKeyEnv) === null ? {
+		code: "ai-missing-key",
+		severity: "error",
+		message: `Set ${apiKeyEnv} to the API key of ${origin} to translate with ${model}`
+	} : null;
+	let format = FORMATS.indexOf(options.responseFormat ?? "json_schema");
+	let temperature = true;
+	return {
+		name: "openai-compatible",
+		model,
+		apiKeyEnv,
+		async translate(request, callOptions) {
+			const problem = missingKey();
+			if (problem !== null) throw diagnosticError(problem);
+			const key = apiKeyEnv === null ? "" : readKey(options.env, apiKeyEnv);
+			const headers = { "content-type": "application/json" };
+			if (key !== "") headers.authorization = `Bearer ${key}`;
+			for (;;) {
+				const sentFormat = format;
+				const sentTemperature = temperature;
+				const answer = await exchange({
+					fetch: options.fetch ?? globalThis.fetch,
+					url,
+					init: {
+						method: "POST",
+						headers,
+						body: JSON.stringify(requestBody(request, model, FORMATS[sentFormat], sentTemperature))
+					},
+					key,
+					label,
+					signal: callOptions?.signal,
+					onRateLimit: callOptions?.onRateLimit,
+					isRateLimit: (answer) => answer.status === 429 && !quotaExhausted(answer.json),
+					serverDelay: (answer) => retryAfterMsDelay(answer.headers),
+					advice: "lower ai.concurrency or wait for the rate limit to reset"
+				});
+				if (answer.ok) return readAnswer(answer.json);
+				if (answer.status === 400 || answer.status === 404) {
+					const refused = refusedParameter(answer);
+					if ((refused === "response_format" || refused === "unnamed") && sentFormat < FORMATS.length - 1) {
+						format = Math.max(format, sentFormat + 1);
+						continue;
+					}
+					if ((refused === "temperature" || refused === "unnamed") && sentTemperature) {
+						temperature = false;
+						continue;
+					}
+				}
+				throw providerError(failureMessage(answer, label, key, apiKeyEnv, origin), key);
+			}
+		},
+		estimateCost(usage) {
+			const prices = options.prices;
+			if (prices === void 0) return NaN;
+			return (usage.inputTokens * prices.input + usage.outputTokens * prices.output) / 1e6;
+		},
+		missingKey,
+		withModel(next) {
+			return openaiCompatible({
+				...options,
+				model: next
+			});
+		}
+	};
+}
+function requestBody(request, model, format, temperature) {
+	const body = {
+		model,
+		messages: [{
+			role: "system",
+			content: request.system
+		}, {
+			role: "user",
+			content: requestText(request)
+		}]
+	};
+	if (temperature) body.temperature = 0;
+	if (format === "json_schema") body.response_format = {
+		type: "json_schema",
+		json_schema: {
+			name: "translations",
+			strict: true,
+			schema: strictSchema(request.responseSchema)
+		}
+	};
+	else if (format === "json_object") body.response_format = { type: "json_object" };
+	return body;
+}
+/**
+* OpenAI's strict mode wants every object closed (`additionalProperties:
+* false`) and every property required; the response schema already
+* requires all of its properties, so only the closing is added.
+*/
+function strictSchema(schema) {
+	const out = {};
+	for (const [key, value] of Object.entries(schema)) if (key === "properties" && typeof value === "object" && value !== null) out[key] = Object.fromEntries(Object.entries(value).map(([name, inner]) => [name, strictSchema(inner)]));
+	else if (key === "items" && typeof value === "object" && value !== null) out[key] = strictSchema(value);
+	else out[key] = value;
+	if (out.type === "object" && out.additionalProperties === void 0) out.additionalProperties = false;
+	return out;
+}
+/**
+* `choices[0].message.content`, parsed strictly; a refusal or an empty
+* message yields no items, so the pipeline retries them.
+*/
+function readAnswer(json) {
+	const result = { items: [] };
+	const usage = field(json, "usage");
+	if (usage !== void 0) result.usage = {
+		inputTokens: count(field(usage, "prompt_tokens")),
+		outputTokens: count(field(usage, "completion_tokens"))
+	};
+	const choices = field(json, "choices");
+	const content = field(field(Array.isArray(choices) ? choices[0] : void 0, "message"), "content");
+	if (typeof content === "string") result.items = answerItems(content);
+	return result;
+}
+/** A 429 that waiting cannot fix: the account is out of credit. */
+function quotaExhausted(json) {
+	const error = field(json, "error");
+	return field(error, "code") === "insufficient_quota" || field(error, "type") === "insufficient_quota";
+}
+/** OpenAI's `retry-after-ms`, else the standard `Retry-After`. */
+function retryAfterMsDelay(headers) {
+	const ms = headers.get("retry-after-ms");
+	if (ms !== null && /^\d+(?:\.\d+)?$/.test(ms.trim())) return Math.ceil(Number(ms));
+	return retryAfterDelay(headers);
+}
+/**
+* Which optional parameter an answer objects to, as OpenAI-style servers
+* word it; `unnamed` when it objects to some parameter without naming one,
+* and the structured output goes first, then the temperature.
+*/
+function refusedParameter(answer) {
+	const error = field(answer.json, "error");
+	const param = field(error, "param");
+	const message = field(error, "message");
+	const text = `${typeof param === "string" ? param : ""} ${typeof message === "string" ? message : answer.text}`;
+	if (/response_format|json_schema|json_object|structured output/i.test(text)) return "response_format";
+	if (/temperature/i.test(text)) return "temperature";
+	if (/requested parameters|unsupported parameter/i.test(text)) return "unnamed";
+	return null;
+}
+function failureMessage(answer, label, key, apiKeyEnv, origin) {
+	const base = `${label} answered HTTP ${answer.status}: ${detail(answer, key)}`;
+	if ((answer.status === 401 || answer.status === 403) && apiKeyEnv === null) return `${base}; no key was sent: set apiKeyEnv to the variable holding the key of ${origin} (a key goes to a host other than OpenAI's only when apiKeyEnv names it)`;
+	return base;
+}
+//#endregion
+export { answerItems as a, exchange as c, readKey as d, requestText as f, MAX_DELAY_MS as i, field as l, sleep as m, openaiCompatible as n, count as o, retryAfterDelay as p, openaiPreset as r, detail as s, PROVIDER_PRESETS as t, providerError as u };

package/dist/output-DsaHKHEt.js

@@ -0,0 +1,164 @@
+import { t as VERSION } from "./version-BlyLGlOa.js";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { existsSync } from "node:fs";
+//#region src/cli/output.ts
+/**
+* Everything the CLI prints (INTERNALS §2.14): results on stdout, diagnostics
+* on stderr as `file:line:col  severity  code  message`, GitHub workflow
+* annotations, or one `--json` envelope and nothing else on stdout. Every
+* string goes through redaction, so a provider key that a server echoed into
+* an error never reaches a terminal, a CI log or an agent.
+*/
+/**
+* Secrets shorter than this are not redacted: replacing every occurrence of
+* a one- or two-character value would garble the whole output while hiding
+* nothing a real API key looks like.
+*/
+const MIN_SECRET = 4;
+function createOutput(io, format) {
+	const secrets = /* @__PURE__ */ new Set();
+	const diagnostics = [];
+	let root = io.cwd;
+	let gitRoot;
+	const redact = (text) => {
+		let out = text;
+		for (const secret of secrets) {
+			if (out.includes(secret)) out = out.split(secret).join("***");
+			const escaped = JSON.stringify(secret).slice(1, -1);
+			if (escaped !== secret && out.includes(escaped)) out = out.split(escaped).join("***");
+		}
+		return out;
+	};
+	const absolute = (file) => isAbsolute(file) ? file : resolve(root, file);
+	const display = (file) => {
+		const rel = relative(io.cwd, absolute(file));
+		return (rel === "" ? "." : rel).split(sep).join("/");
+	};
+	const repoPath = (file) => {
+		if (gitRoot === void 0) gitRoot = findGitRoot(io.cwd);
+		const abs = absolute(file);
+		const rel = relative(gitRoot ?? io.cwd, abs);
+		return (rel.startsWith("..") || isAbsolute(rel) ? abs : rel).split(sep).join("/");
+	};
+	const print = (diagnostic) => {
+		if (format === "json") return;
+		if (format === "github") {
+			io.stdout(redact(githubLine(diagnostic, repoPath)) + "\n");
+			return;
+		}
+		io.stderr(redact(textLine(diagnostic, display)) + "\n");
+	};
+	return {
+		format,
+		diagnostics,
+		setRoot(value) {
+			root = value;
+		},
+		addSecret(value) {
+			if (value === void 0) return;
+			const trimmed = value.trim();
+			if (trimmed.length >= MIN_SECRET) secrets.add(trimmed);
+			if (value.length >= MIN_SECRET) secrets.add(value);
+		},
+		redact,
+		report(list) {
+			for (const diagnostic of list) {
+				diagnostics.push(diagnostic);
+				print(diagnostic);
+			}
+		},
+		result(text) {
+			if (format !== "json") io.stdout(redact(text.endsWith("\n") ? text : text + "\n"));
+		},
+		note(text) {
+			if (format !== "json") io.stderr(redact(text.endsWith("\n") ? text : text + "\n"));
+		},
+		finish(command, exitCode, data) {
+			if (format !== "json") return;
+			const envelope = {
+				command,
+				ok: exitCode === 0,
+				exitCode,
+				diagnostics,
+				data,
+				version: VERSION
+			};
+			io.stdout(redact(JSON.stringify(envelope, null, 2)) + "\n");
+		},
+		display
+	};
+}
+/** `file:line:col  severity  code  message`; the location falls back to the locale. */
+function textLine(diagnostic, display) {
+	let location;
+	if (diagnostic.file !== void 0 && diagnostic.file !== "") {
+		location = display(diagnostic.file);
+		if (diagnostic.line !== void 0 && diagnostic.line > 0) {
+			location += `:${diagnostic.line}`;
+			if (diagnostic.column !== void 0 && diagnostic.column > 0) location += `:${diagnostic.column}`;
+		}
+	} else location = diagnostic.locale ?? "vi18n";
+	return `${location}  ${diagnostic.severity}  ${diagnostic.code}  ${diagnostic.message}`;
+}
+const LEVEL = {
+	error: "error",
+	warning: "warning",
+	info: "notice"
+};
+/** GitHub's escaping for a workflow command's message. */
+function escapeData(text) {
+	return text.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
+}
+/** Property values additionally escape the separators of the property list. */
+function escapeProperty(text) {
+	return escapeData(text).replace(/:/g, "%3A").replace(/,/g, "%2C");
+}
+function githubLine(diagnostic, repoPath) {
+	const props = [];
+	if (diagnostic.file !== void 0 && diagnostic.file !== "") {
+		props.push(`file=${escapeProperty(repoPath(diagnostic.file))}`);
+		if (diagnostic.line !== void 0 && diagnostic.line > 0) {
+			props.push(`line=${diagnostic.line}`);
+			if (diagnostic.column !== void 0 && diagnostic.column > 0) props.push(`col=${diagnostic.column}`);
+		}
+	}
+	props.push(`title=${escapeProperty(`vi18n(${diagnostic.code})`)}`);
+	const message = diagnostic.locale !== void 0 && !diagnostic.message.includes(diagnostic.locale) ? `${diagnostic.locale}: ${diagnostic.message}` : diagnostic.message;
+	return `::${LEVEL[diagnostic.severity]} ${props.join(",")}::${escapeData(message)}`;
+}
+/** The nearest directory upward with a `.git` entry (a directory, or a file in worktrees). */
+function findGitRoot(from) {
+	for (let dir = resolve(from);; dir = dirname(dir)) {
+		if (existsSync(join(dir, ".git"))) return dir;
+		if (dirname(dir) === dir) return null;
+	}
+}
+/** A fixed-width table for text output; numbers right-aligned. */
+function table(header, rows) {
+	const cells = [header, ...rows].map((row) => row.map(String));
+	const widths = header.map((_, i) => Math.max(...cells.map((row) => (row[i] ?? "").length)));
+	return cells.map((row, r) => row.map((cell, i) => {
+		const width = widths[i];
+		return r > 0 && typeof rows[r - 1]?.[i] === "number" || r === 0 && i > 0 ? cell.padStart(width) : cell.padEnd(width);
+	}).join("  ").trimEnd()).join("\n");
+}
+/** Posix path of `file` relative to `root` (absolute when outside it), as diagnostics store paths. */
+function rootRelative(root, file) {
+	const rel = relative(root, file);
+	if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) return file.split(sep).join("/");
+	return rel.split(sep).join("/");
+}
+function countBySeverity(list) {
+	const counts = {
+		error: 0,
+		warning: 0,
+		info: 0
+	};
+	for (const diagnostic of list) counts[diagnostic.severity]++;
+	return counts;
+}
+function plural(count, one, many = one + "s") {
+	return `${count} ${count === 1 ? one : many}`;
+}
+//#endregion
+export { table as a, rootRelative as i, createOutput as n, plural as r, countBySeverity as t };

package/dist/parse.d.ts

@@ -0,0 +1,62 @@
+import { a as Message, b as Values, s as MessageRef } from "./types-DsdWBG0b.js";
+//#region src/parse/index.d.ts
+interface ParseOptions {
+  /**
+   * `"auto"` (default): ICU MessageFormat, or MessageFormat 2 when the text
+   * is an MF2 complex message (it starts with `.input`, `.local`, `.match`
+   * or `{{`). `"mf2"` reads simple MF2 messages too; `"icu"` never reads MF2.
+   */
+  readonly syntax?: "auto" | "icu" | "mf2";
+  /**
+   * The text this one translates. The message is then checked as a
+   * translation (the same arguments and tags, as `vi18n check` requires), and
+   * renders the source while it has errors.
+   */
+  readonly source?: string;
+  /** The text's locale: adds the plural-category warnings, which depend on it. */
+  readonly locale?: string;
+}
+/** A problem found in a message: errors keep it from rendering, warnings do not. */
+interface ParseIssue {
+  /** A vi18n diagnostic code, such as `icu-syntax` or `icu-argument-mismatch`. */
+  readonly code: string;
+  readonly severity: "error" | "warning";
+  readonly message: string;
+  /** 1-based position in the text (after NFC and LF normalisation), when known. */
+  readonly line?: number;
+  readonly column?: number;
+}
+/**
+ * What `parse()` returns: `t()`, `rich()`, `richHtml()`, `richParts()` and
+ * `format()` render it. Plain data, so it survives `JSON.stringify` and
+ * `structuredClone`: parse on the server, render on the client without the
+ * parser.
+ */
+interface ParsedMessage extends MessageRef<[values?: Values]> {
+  /** Never a catalog id: `t()` renders `ir` without looking anything up. */
+  readonly id: "";
+  /** The text as given. */
+  readonly message: string;
+  /** What renders: the compiled message, or the fallback while it has errors. */
+  readonly ir: Message;
+  readonly errors: readonly ParseIssue[];
+  readonly warnings: readonly ParseIssue[];
+}
+/**
+ * Parses and validates `message`. Never throws: errors are in `errors`, and
+ * the result still renders (see the module comment).
+ */
+export declare function parse(message: string, options?: ParseOptions): ParsedMessage;
+/**
+ * Renders `message` as plain text (tags render their children): in the
+ * current locale, as `t(parse(message), values)` does, or in `locale` with
+ * the current time zone.
+ */
+export declare function format(message: string | ParsedMessage, values?: Values, locale?: string): string;
+/**
+ * Calls `handler` with every message `parse()` finds errors in, once per
+ * text and options while it is cached; returns the unsubscribe function.
+ */
+export declare function onParseError(handler: (message: ParsedMessage) => void): () => void;
+//#endregion
+export type { ParseIssue, ParseOptions, ParsedMessage };