@vertana/cli 0.1.0-dev.1

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright 2025 Hong Minhee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,667 @@
+#!/usr/bin/env node
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let node_process = require("node:process");
+node_process = __toESM(node_process);
+let _logtape_logtape = require("@logtape/logtape");
+let _optique_core_message = require("@optique/core/message");
+let _optique_logtape = require("@optique/logtape");
+let _optique_run = require("@optique/run");
+let _optique_core_constructs = require("@optique/core/constructs");
+let _optique_core_modifiers = require("@optique/core/modifiers");
+let _optique_core_primitives = require("@optique/core/primitives");
+let _optique_core_valueparser = require("@optique/core/valueparser");
+let _optique_run_valueparser = require("@optique/run/valueparser");
+let node_fs = require("node:fs");
+let _napi_rs_keyring = require("@napi-rs/keyring");
+let node_os = require("node:os");
+let node_path = require("node:path");
+let _vertana_facade = require("@vertana/facade");
+let node_stream = require("node:stream");
+
+//#region src/glossary.ts
+/**
+* Creates a ValueParser for glossary entries in "TERM=TRANSLATION" format.
+*
+* @returns A ValueParser that parses glossary entry strings.
+*
+* @example
+* ```typescript
+* const parser = glossaryEntry();
+* const result = parser.parse("LLM=Large Language Model");
+* // result.value === { original: "LLM", translated: "Large Language Model" }
+* ```
+*/
+function glossaryEntry() {
+	return {
+		metavar: "TERM=TRANSLATION",
+		parse(input) {
+			const index = input.indexOf("=");
+			if (index === -1) return {
+				success: false,
+				error: _optique_core_message.message`Invalid format. Expected ${(0, _optique_core_message.metavar)("TERM")}${(0, _optique_core_message.text)("=")}${(0, _optique_core_message.metavar)("TRANSLATION")}.`
+			};
+			if (index === 0) return {
+				success: false,
+				error: _optique_core_message.message`${(0, _optique_core_message.metavar)("TERM")} cannot be empty.`
+			};
+			const original = input.slice(0, index);
+			const translated = input.slice(index + 1);
+			if (translated === "") return {
+				success: false,
+				error: _optique_core_message.message`${(0, _optique_core_message.metavar)("TRANSLATION")} cannot be empty.`
+			};
+			return {
+				success: true,
+				value: {
+					original,
+					translated
+				}
+			};
+		},
+		format(value) {
+			return `${value.original}=${value.translated}`;
+		}
+	};
+}
+/**
+* Loads a glossary from a JSON file.
+*
+* @param filePath The path to the glossary JSON file.
+* @returns The parsed glossary.
+* @throws {SyntaxError} If the file is not valid JSON.
+* @throws {TypeError} If the JSON structure is invalid.
+*/
+function loadGlossaryFile(filePath) {
+	const content = (0, node_fs.readFileSync)(filePath, "utf-8");
+	const parsed = JSON.parse(content);
+	if (!Array.isArray(parsed)) throw new TypeError(`Invalid glossary file: expected an array, got ${typeof parsed}.`);
+	const entries = [];
+	for (let i = 0; i < parsed.length; i++) {
+		const item = parsed[i];
+		if (typeof item !== "object" || item === null) throw new TypeError(`Invalid glossary entry at index ${i}: expected an object.`);
+		const entry = item;
+		if (typeof entry.original !== "string" || entry.original === "") throw new TypeError(`Invalid glossary entry at index ${i}: "original" must be a non-empty string.`);
+		if (typeof entry.translated !== "string" || entry.translated === "") throw new TypeError(`Invalid glossary entry at index ${i}: "translated" must be a non-empty string.`);
+		const glossaryEntry$1 = {
+			original: entry.original,
+			translated: entry.translated
+		};
+		if (typeof entry.context === "string" && entry.context !== "") glossaryEntry$1.context = entry.context;
+		entries.push(glossaryEntry$1);
+	}
+	return entries;
+}
+/**
+* Merges multiple glossaries into one.
+* Later entries take precedence over earlier ones for the same original term.
+*
+* @param glossaries The glossaries to merge.
+* @returns The merged glossary.
+*/
+function mergeGlossaries(...glossaries) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const glossary of glossaries) for (const entry of glossary) merged.set(entry.original, entry);
+	return Array.from(merged.values());
+}
+
+//#endregion
+//#region src/config/types.ts
+/**
+* The default configuration.
+*/
+const defaultConfig = {};
+/**
+* List of supported provider names.
+*/
+const providerNames = [
+	"openai",
+	"anthropic",
+	"google"
+];
+/**
+* Environment variable names for API keys by provider.
+*/
+const providerEnvVars = {
+	openai: "OPENAI_API_KEY",
+	anthropic: "ANTHROPIC_API_KEY",
+	google: "GOOGLE_GENERATIVE_AI_API_KEY"
+};
+/**
+* Checks if a string is a valid provider name.
+*
+* @param provider The string to check.
+* @returns True if the string is a valid provider name.
+*/
+function isProviderName(provider) {
+	return provider === "openai" || provider === "anthropic" || provider === "google";
+}
+
+//#endregion
+//#region src/config/keyring.ts
+const SERVICE_NAME = "vertana";
+/**
+* Gets the API key for a provider.
+* First checks the keyring, then falls back to environment variables.
+*
+* @param provider The provider name.
+* @returns The API key, or undefined if not found.
+*/
+function getApiKey(provider) {
+	try {
+		const password = new _napi_rs_keyring.Entry(SERVICE_NAME, provider).getPassword();
+		if (password != null && password !== "") return password;
+	} catch {}
+	const envVar = providerEnvVars[provider];
+	const envValue = node_process.default.env[envVar];
+	if (envValue != null && envValue !== "") return envValue;
+}
+/**
+* Sets the API key for a provider in the keyring.
+*
+* @param provider The provider name.
+* @param apiKey The API key to store.
+* @throws {Error} If the keyring is not available.
+*/
+function setApiKey(provider, apiKey) {
+	new _napi_rs_keyring.Entry(SERVICE_NAME, provider).setPassword(apiKey);
+}
+/**
+* Masks an API key for display.
+*
+* @param apiKey The API key to mask.
+* @returns The masked API key (e.g., "sk-...xxxx").
+*/
+function maskApiKey(apiKey) {
+	if (apiKey.length <= 8) return "****";
+	return `${apiKey.slice(0, 3)}...${apiKey.slice(-4)}`;
+}
+/**
+* Gets the masked API key for a provider (for display purposes).
+*
+* @param provider The provider name.
+* @returns The masked API key, or undefined if not found.
+*/
+function getMaskedApiKey(provider) {
+	const apiKey = getApiKey(provider);
+	if (apiKey == null) return;
+	return maskApiKey(apiKey);
+}
+
+//#endregion
+//#region src/config/loader.ts
+/**
+* Gets the configuration directory path following XDG Base Directory specification.
+*
+* @returns The configuration directory path.
+*/
+function getConfigDir() {
+	const xdgConfig = node_process.default.env.XDG_CONFIG_HOME;
+	if (xdgConfig != null && xdgConfig !== "") return (0, node_path.join)(xdgConfig, "vertana");
+	if (node_process.default.platform === "win32") {
+		const appData = node_process.default.env.APPDATA;
+		if (appData != null && appData !== "") return (0, node_path.join)(appData, "vertana");
+	}
+	return (0, node_path.join)((0, node_os.homedir)(), ".config", "vertana");
+}
+/**
+* Gets the configuration file path.
+*
+* @returns The configuration file path.
+*/
+function getConfigPath() {
+	return (0, node_path.join)(getConfigDir(), "config.json");
+}
+/**
+* Loads the configuration from the config file.
+*
+* @returns The loaded configuration, or the default configuration if the file
+*          does not exist.
+*/
+function loadConfig() {
+	const configPath = getConfigPath();
+	if (!(0, node_fs.existsSync)(configPath)) return { ...defaultConfig };
+	try {
+		const content = (0, node_fs.readFileSync)(configPath, "utf-8");
+		const parsed = JSON.parse(content);
+		if (typeof parsed !== "object" || parsed === null) return { ...defaultConfig };
+		const config = parsed;
+		return { model: typeof config.model === "string" ? config.model : void 0 };
+	} catch {
+		return { ...defaultConfig };
+	}
+}
+/**
+* Saves the configuration to the config file.
+*
+* @param config The configuration to save.
+*/
+function saveConfig(config) {
+	const configDir = getConfigDir();
+	const configPath = getConfigPath();
+	if (!(0, node_fs.existsSync)(configDir)) (0, node_fs.mkdirSync)(configDir, { recursive: true });
+	(0, node_fs.writeFileSync)(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+/**
+* Updates a specific configuration value.
+*
+* @param key The configuration key to update.
+* @param value The new value.
+*/
+function updateConfig(key, value) {
+	saveConfig({
+		...loadConfig(),
+		[key]: value
+	});
+}
+
+//#endregion
+//#region src/model.ts
+/**
+* Parses a model code into provider and model ID.
+*
+* @param code The model code in "provider:model" format.
+* @returns The parsed provider and model ID.
+* @throws {SyntaxError} If the model code format is invalid.
+* @throws {TypeError} If the provider is not supported.
+*
+* @example
+* ```typescript
+* const { provider, modelId } = parseModelCode("openai:gpt-4o");
+* // provider === "openai", modelId === "gpt-4o"
+* ```
+*/
+function parseModelCode(code) {
+	const colonIndex = code.indexOf(":");
+	if (colonIndex === -1) throw new SyntaxError(`Invalid model code format: "${code}". Expected format: "provider:model" (e.g., "openai:gpt-4o").`);
+	const provider = code.slice(0, colonIndex);
+	const modelId = code.slice(colonIndex + 1);
+	if (modelId === "") throw new SyntaxError(`Invalid model code format: "${code}". Model ID cannot be empty.`);
+	if (!isProviderName(provider)) throw new TypeError(`Unsupported provider: "${provider}". Supported providers: ${providerNames.map((p) => `"${p}"`).join(", ")}.`);
+	return {
+		provider,
+		modelId
+	};
+}
+/**
+* Creates a ValueParser for model codes.
+* Model codes are in the format "provider:model" (e.g., "openai:gpt-4o").
+*
+* @returns A ValueParser for model codes.
+*/
+function modelCode() {
+	return {
+		metavar: "PROVIDER:MODEL",
+		parse(input) {
+			const colonIndex = input.indexOf(":");
+			if (colonIndex === -1) return {
+				success: false,
+				error: _optique_core_message.message`Invalid model code format. Expected ${(0, _optique_core_message.metavar)("PROVIDER")}${(0, _optique_core_message.text)(":")}${(0, _optique_core_message.metavar)("MODEL")} (e.g., ${(0, _optique_core_message.commandLine)("openai:gpt-4o")}).`
+			};
+			const provider = input.slice(0, colonIndex);
+			const modelId = input.slice(colonIndex + 1);
+			if (modelId === "") return {
+				success: false,
+				error: _optique_core_message.message`${(0, _optique_core_message.metavar)("MODEL")} cannot be empty.`
+			};
+			if (!isProviderName(provider)) {
+				let providerList = [];
+				for (let i = 0; i < providerNames.length; i++) {
+					if (i > 0) providerList = [...providerList, ..._optique_core_message.message`, `];
+					providerList = [...providerList, ..._optique_core_message.message`${providerNames[i]}`];
+				}
+				return {
+					success: false,
+					error: _optique_core_message.message`Unsupported provider: ${provider}. Supported providers: ${providerList}.`
+				};
+			}
+			return {
+				success: true,
+				value: {
+					provider,
+					modelId
+				}
+			};
+		},
+		format(value) {
+			return `${value.provider}:${value.modelId}`;
+		}
+	};
+}
+/**
+* Creates a language model from a model code.
+* Uses the API key from the keyring or environment variables.
+*
+* @param code The model code (e.g., "openai:gpt-4o").
+* @returns The language model instance.
+* @throws {SyntaxError} If the model code format is invalid.
+* @throws {TypeError} If the provider is not supported.
+* @throws {Error} If the API key is not configured.
+*
+* @example
+* ```typescript
+* const model = await createModel("openai:gpt-4o");
+* ```
+*/
+async function createModel(code) {
+	const { provider, modelId } = parseModelCode(code);
+	const apiKey = getApiKey(provider);
+	if (apiKey == null) throw new Error(`API key not configured for provider "${provider}". Run "vertana config api-key ${provider} <key>" to set it.`);
+	switch (provider) {
+		case "openai": {
+			const { createOpenAI } = await import("@ai-sdk/openai");
+			return createOpenAI({ apiKey })(modelId);
+		}
+		case "anthropic": {
+			const { createAnthropic } = await import("@ai-sdk/anthropic");
+			return createAnthropic({ apiKey })(modelId);
+		}
+		case "google": {
+			const { createGoogleGenerativeAI } = await import("@ai-sdk/google");
+			return createGoogleGenerativeAI({ apiKey })(modelId);
+		}
+	}
+}
+
+//#endregion
+//#region src/cli.ts
+/**
+* Global options shared across all subcommands.
+*/
+const globalOptions = (0, _optique_core_constructs.object)({ logging: (0, _optique_logtape.loggingOptions)({ level: "verbosity" }) });
+/**
+* Parser for the "translate" subcommand.
+*/
+const translateCommand = (0, _optique_core_primitives.command)("translate", (0, _optique_core_constructs.object)({
+	command: (0, _optique_core_primitives.constant)("translate"),
+	target: (0, _optique_core_primitives.option)("-t", "--target", (0, _optique_core_valueparser.string)({ metavar: "LANG" })),
+	source: (0, _optique_core_modifiers.optional)((0, _optique_core_primitives.option)("-s", "--source", (0, _optique_core_valueparser.string)({ metavar: "LANG" }))),
+	mediaType: (0, _optique_core_modifiers.withDefault)((0, _optique_core_primitives.option)("-T", "--type", (0, _optique_core_valueparser.choice)([
+		"text/plain",
+		"text/markdown",
+		"text/html"
+	])), "text/plain"),
+	tone: (0, _optique_core_modifiers.optional)((0, _optique_core_primitives.option)("--tone", (0, _optique_core_valueparser.choice)([
+		"formal",
+		"informal",
+		"technical",
+		"casual",
+		"professional",
+		"literary",
+		"journalistic"
+	]))),
+	domain: (0, _optique_core_modifiers.optional)((0, _optique_core_primitives.option)("--domain", (0, _optique_core_valueparser.string)())),
+	glossary: (0, _optique_core_modifiers.multiple)((0, _optique_core_primitives.option)("-g", "--glossary", glossaryEntry())),
+	glossaryFile: (0, _optique_core_modifiers.optional)((0, _optique_core_primitives.option)("--glossary-file", (0, _optique_run_valueparser.path)({
+		mustExist: true,
+		type: "file"
+	}))),
+	output: (0, _optique_core_modifiers.optional)((0, _optique_core_primitives.option)("-o", "--output", (0, _optique_run_valueparser.path)({ metavar: "FILE" }))),
+	input: (0, _optique_core_modifiers.optional)((0, _optique_core_primitives.argument)((0, _optique_run_valueparser.path)({ metavar: "FILE" })))
+}));
+/**
+* Parser for the "config model" subcommand.
+*/
+const configModelCommand = (0, _optique_core_primitives.command)("model", (0, _optique_core_constructs.object)({
+	subcommand: (0, _optique_core_primitives.constant)("model"),
+	value: (0, _optique_core_modifiers.optional)((0, _optique_core_primitives.argument)(modelCode()))
+}));
+/**
+* Parser for the "config api-key" subcommand.
+*/
+const configApiKeyCommand = (0, _optique_core_primitives.command)("api-key", (0, _optique_core_constructs.object)({
+	subcommand: (0, _optique_core_primitives.constant)("api-key"),
+	provider: (0, _optique_core_primitives.argument)((0, _optique_core_valueparser.choice)([
+		"openai",
+		"anthropic",
+		"google"
+	], { metavar: "PROVIDER" })),
+	key: (0, _optique_core_modifiers.optional)((0, _optique_core_primitives.argument)((0, _optique_core_valueparser.string)({ metavar: "KEY" })))
+}));
+/**
+* Parser for the "config" subcommand with nested subcommands.
+*/
+const configCommand = (0, _optique_core_primitives.command)("config", (0, _optique_core_constructs.object)({
+	command: (0, _optique_core_primitives.constant)("config"),
+	action: (0, _optique_core_constructs.or)(configModelCommand, configApiKeyCommand)
+}));
+/**
+* The main CLI parser combining all subcommands.
+*/
+const parser = (0, _optique_core_constructs.merge)(globalOptions, (0, _optique_core_constructs.or)(translateCommand, configCommand));
+
+//#endregion
+//#region src/commands/config.ts
+/**
+* Executes the config command.
+*
+* @param result The parsed config command result.
+*/
+function executeConfig(result) {
+	const { action } = result;
+	switch (action.subcommand) {
+		case "model":
+			handleModelConfig(action.value);
+			break;
+		case "api-key":
+			handleApiKeyConfig(action.provider, action.key);
+			break;
+	}
+}
+/**
+* Formats a parsed model code back to string.
+*
+* @param model The parsed model code.
+* @returns The model code string in "provider:model" format.
+*/
+function formatModelCode(model) {
+	return `${model.provider}:${model.modelId}`;
+}
+/**
+* Handles the "config model" subcommand.
+*
+* @param value The model value to set, or undefined to get the current value.
+*/
+function handleModelConfig(value) {
+	if (value == null) {
+		const config = loadConfig();
+		if (config.model == null) {
+			(0, _optique_run.print)(_optique_core_message.message`No model configured.`);
+			(0, _optique_run.print)(_optique_core_message.message`Use ${(0, _optique_core_message.commandLine)("vertana config model")} ${(0, _optique_core_message.metavar)("PROVIDER:MODEL")} to set one.`);
+		} else (0, _optique_run.print)(_optique_core_message.message`${(0, _optique_core_message.text)(config.model)}`);
+	} else {
+		const code = formatModelCode(value);
+		updateConfig("model", code);
+		(0, _optique_run.print)(_optique_core_message.message`Model set to: ${(0, _optique_core_message.text)(code)}`);
+	}
+}
+/**
+* Handles the "config api-key" subcommand.
+*
+* @param provider The provider name.
+* @param key The API key to set, or undefined to get the current value.
+*/
+function handleApiKeyConfig(provider, key) {
+	if (key == null) {
+		const masked = getMaskedApiKey(provider);
+		if (masked == null) {
+			(0, _optique_run.print)(_optique_core_message.message`No API key configured for ${(0, _optique_core_message.text)(provider)}.`);
+			(0, _optique_run.print)(_optique_core_message.message`Use ${(0, _optique_core_message.commandLine)(`vertana config api-key ${provider}`)} ${(0, _optique_core_message.metavar)("KEY")} to set one.`);
+		} else (0, _optique_run.print)(_optique_core_message.message`${(0, _optique_core_message.text)(masked)}`);
+	} else {
+		setApiKey(provider, key);
+		(0, _optique_run.print)(_optique_core_message.message`API key for ${(0, _optique_core_message.text)(provider)} has been saved.`);
+	}
+}
+
+//#endregion
+//#region src/input.ts
+/**
+* Reads input from a file or stdin.
+*
+* @param filePath The file path to read from, or undefined to read from stdin.
+* @returns The input text.
+*/
+async function readInput(filePath) {
+	if (filePath != null) return (0, node_fs.readFileSync)(filePath, "utf-8");
+	return await readStdin();
+}
+/**
+* Reads all input from stdin.
+*
+* @returns The stdin content as a string.
+*/
+async function readStdin() {
+	const stream = await getStdinStream();
+	const decoder = new TextDecoder();
+	const chunks = [];
+	for await (const chunk of stream) chunks.push(decoder.decode(chunk, { stream: true }));
+	chunks.push(decoder.decode());
+	return chunks.join("");
+}
+/**
+* Gets the stdin stream as a ReadableStream.
+* Works across Deno, Node.js, and Bun.
+*
+* @returns The stdin ReadableStream.
+*/
+async function getStdinStream() {
+	if (typeof Deno !== "undefined" && Deno?.stdin?.readable != null) return Deno.stdin.readable;
+	const { stdin } = await import("node:process");
+	return node_stream.Readable.toWeb(stdin);
+}
+
+//#endregion
+//#region src/commands/translate.ts
+/**
+* Executes the translate command.
+*
+* @param result The parsed translate command result.
+*/
+async function executeTranslate(result) {
+	const config = loadConfig();
+	if (config.model == null) {
+		(0, _optique_run.printError)(_optique_core_message.message`No model configured.`, { exitCode: 1 });
+		(0, _optique_run.print)(_optique_core_message.message`Run ${(0, _optique_core_message.commandLine)("vertana config model")} ${(0, _optique_core_message.metavar)("PROVIDER:MODEL")} to set one.`);
+		return;
+	}
+	const model = await createModel(config.model);
+	const inputText = await readInput(result.input);
+	if (inputText.trim() === "") {
+		(0, _optique_run.printError)(_optique_core_message.message`No input text provided.`, { exitCode: 1 });
+		return;
+	}
+	const glossary = buildGlossary(result.glossary, result.glossaryFile);
+	const translation = await (0, _vertana_facade.translate)(model, result.target, inputText, {
+		sourceLanguage: result.source,
+		mediaType: result.mediaType,
+		tone: result.tone,
+		domain: result.domain,
+		glossary: glossary.length > 0 ? glossary : void 0
+	});
+	if (result.output != null) try {
+		(0, node_fs.writeFileSync)(result.output, translation.text + "\n", "utf-8");
+		(0, _optique_run.print)(_optique_core_message.message`Translation saved to: ${(0, _optique_core_message.text)(result.output)}`);
+	} catch (e) {
+		const errorMessage = e instanceof Error ? e.message : String(e);
+		(0, _optique_run.printError)(_optique_core_message.message`Failed to write to file: ${result.output} — ${(0, _optique_core_message.text)(errorMessage)}`, { exitCode: 1 });
+	}
+	else console.log(translation.text);
+}
+/**
+* Builds a glossary from CLI options and an optional file.
+*
+* @param cliEntries Glossary entries from -g/--glossary options.
+* @param filePath Path to a glossary JSON file.
+* @returns The merged glossary.
+*/
+function buildGlossary(cliEntries, filePath) {
+	const glossaries = [];
+	if (filePath != null) try {
+		const fileGlossary = loadGlossaryFile(filePath);
+		glossaries.push(fileGlossary);
+	} catch (e) {
+		(0, _optique_run.printError)(_optique_core_message.message`Failed to load glossary file: ${filePath} — ${(0, _optique_core_message.text)(e instanceof Error ? e.message : String(e))}`, { exitCode: 1 });
+		return [];
+	}
+	if (cliEntries.length > 0) glossaries.push(cliEntries);
+	return mergeGlossaries(...glossaries);
+}
+
+//#endregion
+//#region src/index.ts
+/**
+* The CLI entry point.
+*/
+async function main() {
+	const result = (0, _optique_run.run)(parser, {
+		programName: "vertana",
+		brief: _optique_core_message.message`LLM-powered translation CLI`,
+		description: _optique_core_message.message`Translate text using large language models with support for
+multiple providers (OpenAI, Anthropic, Google) and various options
+for customizing the translation output.`,
+		footer: _optique_core_message.message`Examples:
+
+  ${(0, _optique_core_message.commandLine)("vertana translate -t ko input.txt")}
+
+  ${(0, _optique_core_message.commandLine)("vertana translate -t ko -o output.txt input.txt")}
+
+  ${(0, _optique_core_message.commandLine)("echo \"Hello\" | vertana translate -t ko")}
+
+  ${(0, _optique_core_message.commandLine)("vertana config model openai:gpt-4o")}
+
+  ${(0, _optique_core_message.commandLine)("vertana config api-key openai sk-...")}`,
+		help: "both",
+		version: "0.1.0",
+		aboveError: "usage"
+	});
+	await (0, _logtape_logtape.configure)(await (0, _optique_logtape.createLoggingConfig)(result.logging));
+	await executeCommand(result);
+}
+/**
+* Executes the parsed CLI command.
+*
+* @param result The parsed CLI result.
+*/
+async function executeCommand(result) {
+	switch (result.command) {
+		case "translate":
+			await executeTranslate(result);
+			break;
+		case "config":
+			executeConfig(result);
+			break;
+	}
+}
+if ("main" in {} && {}.main || typeof node_process.default !== "undefined" && node_process.default.argv[1]?.endsWith("index.ts") || typeof node_process.default !== "undefined" && node_process.default.argv[1]?.endsWith("index.js") || typeof node_process.default !== "undefined" && node_process.default.argv[1]?.endsWith("index.mjs") || typeof node_process.default !== "undefined" && node_process.default.argv[1]?.endsWith("index.cjs")) main().catch((error) => {
+	if (error instanceof Error) (0, _optique_run.printError)(_optique_core_message.message`${(0, _optique_core_message.text)(error.message)}`, { exitCode: 1 });
+	else (0, _optique_run.printError)(_optique_core_message.message`An unexpected error occurred.`, { exitCode: 1 });
+});
+
+//#endregion
+exports.main = main;

package/dist/index.d.cts

@@ -0,0 +1,8 @@
+
+//#region src/index.d.ts
+/**
+ * The CLI entry point.
+ */
+declare function main(): Promise<void>;
+//#endregion
+export { main };