@fal-works/sagmal 0.1.0 → 0.2.0

package/README.md

@@ -1,11 +1,31 @@
 # @fal-works/sagmal
 
-Command-line translation tool powered by the DeepL API.
+CLI translation tool powered by the [DeepL API](https://developers.deepl.com/).
 
-> "sagmal" comes from the German "Sag mal" ("say" or "tell me").
+> “sagmal” comes from the German “Sag mal,” which means “say” or “tell me.”
 
 Note: This is an early-stage project, primarily developed for personal use.
 
+
+## In Short
+
+```text
+C:\> sagmal Oh mein Gott!   # Input any text after the command
+Oh my God!                  # Output (translated)
+```
+
+
+## Key Features
+
+- Simple CLI for instant text translation
+- Language selection via colon syntax (e.g., `de:`, `:en`), similar to [translate-shell](https://github.com/soimort/translate-shell)
+- Usually you don't need to quote the input text (unless it contains special characters or something)
+- Optionally copy results to the clipboard
+- Supports config files for persistent preferences, with JSON schema validation
+- Automatic fallback to a secondary target language
+- Works on Windows (and possibly other platforms, but I haven't tried them)
+
+
 ## Quick Start
 
 Save your DeepL API key in a `.env` file located either in the current directory or your home directory.  
@@ -27,12 +47,12 @@ Or, if you have installed it globally:
 sagmal <text-to-translate>
 ```
 
-Then you will see the translated text in your terminal.
+The translated text will then appear in your terminal.
 
 
-## Specifying Languages
+## Language Options
 
-You can specify language options at the **first** or **last** position of your input using colon (`:`) syntax.
+You can specify language options at the **first** or **last** position of your input text using colon (`:`) syntax.
 
 The format is `[from]:[to]`.
 
@@ -49,32 +69,52 @@ Hallo Welt de:             # from German
 Oh mon Dieu :en            # to English
 私は大丈夫です ja:vi        # from Japanese to Vietnamese
 
-# Language options at both positions (confliction should be avoided)
+# Language options at both positions (avoid conflicts)
 ja: 私は大丈夫です :vi      # from Japanese to Vietnamese
 ```
 
-
 ### Language Defaults
 
-- If you don't specify a source language in the CLI or config file, the DeepL API will detect it automatically.
-- If you don't specify a target language in either place, it will default to `en-US`.
+- If you do not specify a source language in the CLI or config file, the DeepL API will detect it automatically.
+- If you do not specify a target language in the CLI or config file, it will default to `en-US`.
+
+
+## Other Options
 
+- `-c`, `--copy` : Copy translated text to clipboard (if available)
+- `-h`, `--help` : Show help message
 
-## Configuration
+
+## Static Configuration
+
+### Configuration File
 
 You can configure the tool by creating a `.sagmalrc.json` file in either your home directory or the current directory.
 
+For editor validation and autocompletion, add the JSON schema reference at the top of your config file:
+
+```json
+{
+  "$schema": "https://fal-works.github.io/sagmal/sagmalrc/v0.x.x/schema.json"
+}
+```
+
 The configuration file must be in JSON format and can include:
 
-- `deepL.sourceLang`: The default source language code.
-- `deepL.targetLang`: The default target language code.
+- `copyToClipboard`: Automatically copy translated text to clipboard.
+- `deepL.sourceLang`: The default [source language code](https://developers.deepl.com/docs/getting-started/supported-languages).
+- `deepL.targetLang`: The default [target language code](https://developers.deepl.com/docs/getting-started/supported-languages#translation-source-languages).
+- `deepL.targetLang2`: The secondary default target language code. See [Secondary Default Target Language](#secondary-default-target-language) for details.
 - `deepL.options`: [Text translation options](https://github.com/deeplcom/deepl-node?tab=readme-ov-file#text-translation-options) that will be passed to the DeepL API.
 
 ```json
 {
+  "$schema": "https://fal-works.github.io/sagmal/sagmalrc/v0.x.x/schema.json",
+  "copyToClipboard": true,
   "deepL": {
     "sourceLang": "ja",
-    "targetLang": "vi",
+    "targetLang": "en-US",
+    "targetLang2": "ja",
     "options": {
       "formality": "less",
       "context": "Always translate technical terms to English",
@@ -85,26 +125,27 @@ The configuration file must be in JSON format and can include:
 }
 ```
 
+### Secondary Default Target Language
 
-## Help message
-
-If no text is provided, or if the first argument is `--help` or `-h`, the tool will display a help message.
+The `targetLang2` option provides automatic fallback when sagmal assumes
+no meaningful translation occurred due to matching source and target languages.
+This commonly happens when you input English text and the default target language is also English.
 
-```text
-Usage:
-  sagmal [languages] <text>
-  sagmal <text> [languages]
-  sagmal [language] <text> [language]
-Examples:
-  sagmal Bonjour tout le monde
-  sagmal de: Hallo Welt!
-  sagmal :it It's not a bug, it's a feature
-  sagmal fr:ar Je pense, donc je suis
-  sagmal I have made a terrible mistake :ja
-  sagmal 404 Motivation Not Found en:de
-  sagmal ja: 私は大丈夫です :zh-HANT
+**Example:**
+```bash
+# Config: { "deepL": { "targetLang2": "de" } }
+sagmal Hello world
+# → Detects English → Targets "de" instead of English → "Hallo Welt"
 ```
 
+**Conditions:**
+- Target language not explicitly specified via CLI (`:en`, `de:`, etc.)
+- `targetLang2` configured in `.sagmalrc.json`
+- Detected source language matches resolved target language
+- Input and output text are unchanged
+
+**Note:** Simplified language matching is used (e.g., `en` matches `en-US`, but `en-US` does not match `en-GB`), which may not be accurate in all cases.
+
 
 ## References
 

package/dist/bin.js

@@ -1,23 +1,23 @@
 #!/usr/bin/env node
 import { DeepLClient, DeepLError } from "deepl-node";
+import { parseArgs } from "node:util";
+import { spawn } from "node:child_process";
+import { homedir, platform } from "node:os";
 import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
 import dotenv from "dotenv";
 
 //#region src/cli-language-parser.ts
 /**
 * Parses colon-separated language options from a command line argument.
-* Returns null if argument doesn't contain colon.
+* Returns null if argument doesn't contain exactly one colon.
 */
 function parseCliLanguageOption(arg) {
-	if (!arg.includes(":")) return null;
-	const colonIndex = arg.indexOf(":");
-	const beforeColon = arg.substring(0, colonIndex);
-	const afterColon = arg.substring(colonIndex + 1);
+	const parts = arg.split(":");
+	if (parts.length !== 2) return null;
 	return {
-		sourceLang: beforeColon || null,
-		targetLang: afterColon || null
+		sourceLang: parts[0] || null,
+		targetLang: parts[1] || null
 	};
 }
 
@@ -49,16 +49,36 @@ function stringifyError(error) {
 //#endregion
 //#region src/cli-parser.ts
 /**
-* Checks if CLI arguments contain help option.
+* Parses all CLI arguments including options and positionals.
 */
-function hasHelpOption(args) {
-	return args.length === 0 || args[0] === "--help" || args[0] === "-h";
+function parseCliArguments() {
+	const { values, positionals } = parseArgs({
+		options: {
+			help: {
+				type: "boolean",
+				short: "h"
+			},
+			copy: {
+				type: "boolean",
+				short: "c"
+			}
+		},
+		allowPositionals: true
+	});
+	const shouldShowHelp = values.help || positionals.length === 0;
+	const shouldCopyToClipboard = values.copy ?? false;
+	const positionalResult = parseCliPositionals(positionals);
+	return {
+		...positionalResult,
+		shouldShowHelp,
+		shouldCopyToClipboard
+	};
 }
 /**
-* Parses CLI arguments to extract language options and text parts.
+* Parses CLI positional arguments to extract language options and text parts.
 * Handles language options at both first and last positions.
 */
-function parseCliArguments(args) {
+function parseCliPositionals(args) {
 	if (args.length === 0) return {
 		languageOptions: {
 			first: null,
@@ -82,6 +102,49 @@ function parseCliArguments(args) {
 	};
 }
 
+//#endregion
+//#region src/clipboard.ts
+/**
+* @returns The command to use for clipboard operations based on the platform,
+*   or null if not supported.
+*/
+function getClipboardCommand() {
+	const platform$1 = platform();
+	if (platform$1 === "win32") return "clip";
+	if (platform$1 === "darwin") return "pbcopy";
+	return null;
+}
+/**
+* Internal function to copy text to clipboard without error handling.
+* May throw errors that need to be handled by the caller.
+*
+* @param text Text to copy to clipboard.
+*/
+async function copyToClipboardInternal(text) {
+	const command = getClipboardCommand();
+	if (!command) return;
+	return new Promise((resolve, reject) => {
+		const proc = spawn(command);
+		proc.on("error", reject);
+		proc.stdin.write(text, "utf8", (err) => {
+			if (err) return reject(err);
+			proc.stdin.end(resolve);
+		});
+	});
+}
+/**
+* Copy text to the system clipboard.
+* Errors are silently suppressed - clipboard copy failures are non-fatal.
+* No effect on unsupported platforms or if no clipboard command is available.
+*
+* @param text Text to copy to clipboard.
+*/
+async function copyToClipboard(text) {
+	try {
+		await copyToClipboardInternal(text);
+	} catch (_error) {}
+}
+
 //#endregion
 //#region src/config-loader.ts
 /**
@@ -91,11 +154,11 @@ function parseCliArguments(args) {
 * @returns File content as string
 * @throws SagmalError if file cannot be read
 */
-function readConfigFileContent(path) {
+function readFileContent(path) {
 	try {
 		return readFileSync(path, "utf-8");
 	} catch (error) {
-		throw new SagmalError(`Cannot read config file: ${path}\n  ${stringifyError(error)}`);
+		throw new SagmalError(`Cannot read file: ${path}\n  ${stringifyError(error)}`);
 	}
 }
 /**
@@ -106,22 +169,22 @@ function readConfigFileContent(path) {
 * @returns Parsed JSON data
 * @throws SagmalError if JSON is invalid
 */
-function parseConfigJson(content, path) {
+function parseJson(content, path) {
 	try {
 		return JSON.parse(content);
 	} catch (error) {
-		throw new SagmalError(`Invalid JSON in config file: ${path}\n  ${stringifyError(error)}`);
+		throw new SagmalError(`Invalid JSON: ${path}\n  ${stringifyError(error)}`);
 	}
 }
 /**
-* Validates and types parsed config data.
+* Validates and types parsed `.sagmalrc` data.
 *
 * @param parsed - Parsed JSON data
 * @param path - File path for error messages
 * @returns Typed config object
 * @throws SagmalError if data is not a valid config object
 */
-function validateConfigData(parsed, path) {
+function validateSagmalRc(parsed, path) {
 	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new SagmalError(`Invalid config file: ${path}\n  must be an object, not ${Array.isArray(parsed) ? "array" : typeof parsed}`);
 	return parsed;
 }
@@ -134,24 +197,24 @@ function validateConfigData(parsed, path) {
 * @returns Parsed object or undefined if file doesn't exist
 * @throws SagmalError if file cannot be read, JSON is malformed, or data is not an object
 */
-function loadConfigFile(path) {
+function loadSagmalRc(path) {
 	if (!existsSync(path)) return void 0;
-	const content = readConfigFileContent(path);
-	const parsed = parseConfigJson(content, path);
-	return validateConfigData(parsed, path);
+	const content = readFileContent(path);
+	const parsed = parseJson(content, path);
+	return validateSagmalRc(parsed, path);
 }
 /**
 * Loads configuration files from home and current directories.
 *
 * @returns Configuration inputs (no merging applied, uses empty objects as defaults)
 */
-function loadConfigInputs() {
+function loadSagmalRcInputs() {
 	const homeDir = homedir();
-	const homeConfig = loadConfigFile(join(homeDir, ".sagmalrc.json"));
-	const localConfig = loadConfigFile(join(process.cwd(), ".sagmalrc.json"));
+	const homeConfig = loadSagmalRc(join(homeDir, ".sagmalrc.json"));
+	const localConfig = loadSagmalRc(join(process.cwd(), ".sagmalrc.json"));
 	return {
-		homeConfig: homeConfig ?? {},
-		localConfig: localConfig ?? {}
+		home: homeConfig ?? {},
+		local: localConfig ?? {}
 	};
 }
 
@@ -200,9 +263,18 @@ function getApiKey() {
 function showHelp() {
 	const msg = `
 Usage:
-  sagmal [languages] <text>
-Examples:
-  sagmal Bonjour tout le monde
+  sagmal [options] [languages] <text>
+  sagmal [options] <text> [languages]
+  sagmal [options] [language] <text> [language]
+
+Options:
+  -c, --copy          Copy translated text to clipboard
+  -h, --help          Show this help message
+
+Example:
+  sagmal おしまいだ
+
+Examples with language options:
   sagmal de: Hallo Welt!
   sagmal :it It's not a bug, it's a feature
   sagmal I have made a terrible mistake :ja
@@ -216,9 +288,74 @@ Examples:
 //#endregion
 //#region src/parameter-resolver.ts
 /**
+* Normalizes target language string, converting 'en' (case-insensitive) to 'en-US'.
+*/
+function normalizeTargetLanguage(lang) {
+	return lang.toLowerCase() === "en" ? "en-US" : lang;
+}
+/**
+* Coalesces a property from two parameter layers, with higher priority taking precedence.
+*/
+function coalesceProperty(target, lower, higher, key) {
+	if (higher[key] !== void 0) target[key] = higher[key];
+	else if (lower[key] !== void 0) target[key] = lower[key];
+}
+/**
+* Merges two parameter layers with the second layer taking priority.
+*
+* @param lower - Lower priority layer
+* @param higher - Higher priority layer (overrides lower)
+* @returns Merged parameter layer
+*/
+function mergeParameterLayers(lower, higher) {
+	const result = { translationOptions: {
+		...lower.translationOptions,
+		...higher.translationOptions
+	} };
+	coalesceProperty(result, lower, higher, "sourceLanguage");
+	coalesceProperty(result, lower, higher, "targetLanguage");
+	coalesceProperty(result, lower, higher, "targetLanguageSecond");
+	coalesceProperty(result, lower, higher, "shouldCopyToClipboard");
+	return result;
+}
+/**
+* Creates the default parameter layer.
+*/
+function createDefaultLayer() {
+	return {
+		sourceLanguage: null,
+		targetLanguage: "en-US",
+		targetLanguageSecond: null,
+		translationOptions: {},
+		shouldCopyToClipboard: false
+	};
+}
+/**
+* Creates parameter layer from config object.
+*/
+function createConfigLayer(config) {
+	const result = { translationOptions: config.deepL?.options ?? {} };
+	if (config.deepL?.sourceLang) result.sourceLanguage = config.deepL.sourceLang;
+	if (config.deepL?.targetLang) result.targetLanguage = normalizeTargetLanguage(config.deepL.targetLang);
+	if (config.deepL?.targetLang2) result.targetLanguageSecond = normalizeTargetLanguage(config.deepL.targetLang2);
+	if (config.copyToClipboard !== void 0) result.shouldCopyToClipboard = config.copyToClipboard;
+	return result;
+}
+/**
+* Creates parameter layer from CLI arguments.
+*/
+function createCliLayer(mergedCliLanguages, cliCopyFlag) {
+	const result = { translationOptions: {} };
+	if (mergedCliLanguages.sourceLang) result.sourceLanguage = mergedCliLanguages.sourceLang;
+	if (mergedCliLanguages.targetLang) result.targetLanguage = normalizeTargetLanguage(mergedCliLanguages.targetLang);
+	if (cliCopyFlag) result.shouldCopyToClipboard = true;
+	return result;
+}
+/**
 * Merges multiple CLI language options with conflict detection.
 */
-function mergeCliLanguageOptions(firstLang, lastLang) {
+function mergeCliLanguageOptions(cliLanguages) {
+	const { first: firstLang, last: lastLang } = cliLanguages;
 	const firstSource = firstLang?.sourceLang ?? null;
 	const firstTarget = firstLang?.targetLang ?? null;
 	const lastSource = lastLang?.sourceLang ?? null;
@@ -231,79 +368,85 @@ function mergeCliLanguageOptions(firstLang, lastLang) {
 	};
 }
 /**
-* Resolves source language with cascading priority.
-* Priority order: CLI → local config → home config → null (auto-detect)
-*/
-function resolveSourceLanguage(cliLanguages, configInputs) {
-	let src = null;
-	src ??= cliLanguages.sourceLang;
-	src ??= configInputs.localConfig.deepL?.sourceLang;
-	src ??= configInputs.homeConfig.deepL?.sourceLang;
-	src ??= null;
-	return src;
-}
-/**
-* Resolves target language with cascading priority.
-* Priority order: CLI → local config → home config → 'en-US' (default)
-* Also normalizes 'en' to 'en-US'.
-*/
-function resolveTargetLanguage(cliLanguages, configInputs) {
-	let target = null;
-	target ??= cliLanguages.targetLang;
-	target ??= configInputs.localConfig.deepL?.targetLang;
-	target ??= configInputs.homeConfig.deepL?.targetLang;
-	target ??= "en-US";
-	if (target.toLowerCase() === "en") target = "en-US";
-	return target;
-}
-/**
-* Merges DeepL API options from config files.
-* Local config options override home config options.
-* Validates that no internal-only fields are present.
+* Applies post-processing to the merged parameter layer.
+* Handles normalization, validation, and type conversion.
 */
-function mergeTranslationOptions(configInputs) {
-	const homeOptions = configInputs.homeConfig.deepL?.options;
-	const localOptions = configInputs.localConfig.deepL?.options;
-	if (homeOptions && "__path" in homeOptions) throw new SagmalError("Invalid config: '__path' is an internal-only field and cannot be used in configuration");
-	if (localOptions && "__path" in localOptions) throw new SagmalError("Invalid config: '__path' is an internal-only field and cannot be used in configuration");
+function applyPostProcessing(resolved, sagmalRcInputs) {
+	const homeOptions = sagmalRcInputs.home.deepL?.options;
+	const localOptions = sagmalRcInputs.local.deepL?.options;
+	if (homeOptions && "__path" in homeOptions) throw new SagmalError("Invalid .sagmalrc in the home directory: '__path' is an internal-only field and cannot be used in configuration");
+	if (localOptions && "__path" in localOptions) throw new SagmalError("Invalid .sagmalrc in the current directory: '__path' is an internal-only field and cannot be used in configuration");
 	return {
-		...homeOptions,
-		...localOptions
+		sourceLanguage: resolved.sourceLanguage ?? null,
+		targetLanguage: resolved.targetLanguage ?? "en-US",
+		targetLanguageSecond: resolved.targetLanguageSecond ?? null,
+		isTargetLanguageFromCli: false,
+		translationOptions: resolved.translationOptions ?? {},
+		shouldCopyToClipboard: resolved.shouldCopyToClipboard ?? false
 	};
 }
 /**
 * Centralized parameter resolution with complete cascading logic.
 *
 * Resolution priority (later overrides earlier):
-* 1. Default values (source: null/auto-detect, target: 'en-US')
+* 1. Default values (source: null/auto-detect, target: 'en-US', copyToClipboard: false)
 * 2. Home directory config
 * 3. Local directory config
-* 4. CLI language arguments
+* 4. CLI language arguments and flags
 *
 * Special handling:
 * - 'en' (case-insensitive) is normalized to 'en-US'
 * - DeepL options are merged (local overrides home)
+* - Clipboard copy follows CLI flag → local config → home config → false
 *
-* @param cliLanguages - Parsed CLI language arguments (always provided, uses default object if no language specified)
-* @param configInputs - Configuration inputs from files (always provided, uses empty objects as defaults)
+* @param cliLanguages - CLI language options from both positions
+* @param sagmalRcInputs - Configuration inputs from files (always provided, uses empty objects as defaults)
+* @param cliCopyFlag - CLI copy flag from parsed arguments
 * @returns Fully resolved parameters ready for translation
 */
-function resolveParameters(firstCliLanguages, lastCliLanguages, configInputs) {
-	const mergedCliLanguages = mergeCliLanguageOptions(firstCliLanguages, lastCliLanguages);
-	const sourceLanguage = resolveSourceLanguage(mergedCliLanguages, configInputs);
-	const targetLanguage = resolveTargetLanguage(mergedCliLanguages, configInputs);
-	const translationOptions = mergeTranslationOptions(configInputs);
-	return {
-		sourceLanguage,
-		targetLanguage,
-		translationOptions
-	};
+function resolveParameters(cliLanguages, sagmalRcInputs, cliCopyFlag) {
+	const mergedCliLanguages = mergeCliLanguageOptions(cliLanguages);
+	const defaultLayer = createDefaultLayer();
+	const homeLayer = createConfigLayer(sagmalRcInputs.home);
+	const localLayer = createConfigLayer(sagmalRcInputs.local);
+	const cliLayer = createCliLayer(mergedCliLanguages, cliCopyFlag);
+	let resolved = defaultLayer;
+	resolved = mergeParameterLayers(resolved, homeLayer);
+	resolved = mergeParameterLayers(resolved, localLayer);
+	resolved = mergeParameterLayers(resolved, cliLayer);
+	const finalResult = applyPostProcessing(resolved, sagmalRcInputs);
+	finalResult.isTargetLanguageFromCli = mergedCliLanguages.targetLang != null;
+	return finalResult;
 }
 
 //#endregion
 //#region package.json
 var name = "@fal-works/sagmal";
-var version = "0.1.0";
+var version = "0.2.0";
+
+//#endregion
+//#region src/language-code.ts
+/**
+* Determines if two language codes likely represent the same language using simplified matching logic.
+* If language subtags match, treats missing regional subtag as "generic".
+*
+* Examples:
+* - 'en' vs 'en-US' -> true (generic vs regional), although not accurate
+* - 'en-US' vs 'en-GB' -> false (both regional, different)
+*/
+function areLikelySameLanguageCodes(lang1, lang2) {
+	const parts1 = lang1.split("-");
+	const parts2 = lang2.split("-");
+	const maxLength = Math.max(parts1.length, parts2.length);
+	for (let i = 0; i < maxLength; i++) {
+		const part1 = parts1[i];
+		const part2 = parts2[i];
+		if (part1 && part2) {
+			if (part1.toLowerCase() !== part2.toLowerCase()) return false;
+		} else break;
+	}
+	return true;
+}
 
 //#endregion
 //#region src/translator.ts
@@ -315,7 +458,32 @@ const clientOptions = { appInfo: {
 	appVersion: version
 } };
 /**
+* Determines if the translation likely didn't a meaningful translation.
+* Uses simplified language matching logic and text comparison.
+*/
+function isLikelySameLanguageTranslation(inputText, translationResult, targetLanguage) {
+	const languageCodesEquivalent = areLikelySameLanguageCodes(translationResult.detectedSourceLang, targetLanguage);
+	const textUnchanged = inputText.trim() === translationResult.text.trim();
+	return languageCodesEquivalent && textUnchanged;
+}
+/**
+* Determines the fallback target language to use, if any.
+*
+* @param inputText - Original input text
+* @param params - Resolved translation parameters
+* @param translationResult - Result from initial translation attempt
+* @returns Fallback target language if conditions are met, null otherwise
+*/
+function getFallbackTargetLanguage(inputText, params, translationResult) {
+	if (!params.isTargetLanguageFromCli && params.targetLanguageSecond != null && isLikelySameLanguageTranslation(inputText, translationResult, params.targetLanguage)) return params.targetLanguageSecond;
+	return null;
+}
+/**
 * Translates text using the DeepL API with fully resolved parameters.
+* Implements smart fallback to secondary default target language when:
+* - Target language was not explicitly specified via CLI
+* - Secondary default target language is configured
+* - Detected source language is the same as (or similar to) resolved target language
 *
 * @param apiKey - DeepL API key
 * @param text - Text to translate
@@ -325,29 +493,34 @@ const clientOptions = { appInfo: {
 async function translate(apiKey, text, params) {
 	const client = new DeepLClient(apiKey, clientOptions);
 	const result = await client.translateText(text, params.sourceLanguage, params.targetLanguage, params.translationOptions);
+	const fallbackTargetLanguage = getFallbackTargetLanguage(text, params, result);
+	if (fallbackTargetLanguage != null) {
+		const fallbackResult = await client.translateText(text, params.sourceLanguage, fallbackTargetLanguage, params.translationOptions);
+		return fallbackResult.text;
+	}
 	return result.text;
 }
 
 //#endregion
 //#region src/bin.ts
 async function main() {
-	const args = process.argv.slice(2);
-	if (hasHelpOption(args)) {
+	const parseResult = parseCliArguments();
+	if (parseResult.shouldShowHelp) {
 		showHelp();
 		process.exit(0);
 	}
 	loadEnvironment();
 	const apiKey = getApiKey();
-	const configInputs = loadConfigInputs();
-	const parseResult = parseCliArguments(args);
+	const sagmalRcInputs = loadSagmalRcInputs();
 	const text = parseResult.text;
 	if (text.length === 0) {
 		showHelp();
 		process.exit(0);
 	}
-	const resolvedParams = resolveParameters(parseResult.languageOptions.first, parseResult.languageOptions.last, configInputs);
+	const resolvedParams = resolveParameters(parseResult.languageOptions, sagmalRcInputs, parseResult.shouldCopyToClipboard);
 	const translatedText = await translate(apiKey, text, resolvedParams);
 	console.log(translatedText);
+	if (resolvedParams.shouldCopyToClipboard) await copyToClipboard(translatedText);
 }
 main().catch((error) => {
 	if (error instanceof SagmalError) console.error(error.name, ">", error.message);

package/package.json

@@ -1,10 +1,10 @@
 {
 	"name": "@fal-works/sagmal",
-	"version": "0.1.0",
+	"version": "0.2.0",
 	"description": "CLI for text translation using DeepL API",
 	"type": "module",
 	"bin": {
-		"sagmal": "./dist/bin.js"
+		"sagmal": "dist/bin.js"
 	},
 	"sideEffects": false,
 	"files": [
@@ -13,12 +13,15 @@
 	"scripts": {
 		"setup": "deps-docs",
 		"build": "tsdown",
+		"test": "npm run test:unit && npm run test:integration",
+		"test:unit": "node --test src/**/*.test.ts",
+		"test:integration": "node --test test/**/*.test.ts",
 		"lint": "biome check",
 		"lint:fix": "biome check --fix",
 		"check:types": "tsc --noEmit -p tsconfig.json",
 		"check": "npm run check:types && npm run lint",
 		"fix": "npm run check:types && npm run lint:fix",
-		"prepublishOnly": "npm run check"
+		"prepublishOnly": "npm run check && npm test"
 	},
 	"keywords": [
 		"translation"