@ariestools/cli-kit-yargs 1.0.0

package/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

package/README.md

@@ -0,0 +1,25 @@
+# @ariestools/cli-kit-yargs
+
+Yargs adapter for reusable actor command-line applications.
+
+The package keeps Yargs out of `@ariestools/cli-kit` while routing parser help, version, validation errors, asynchronous failures, and exits through the core `ProcessHost` boundary. This makes a configured CLI safe to exercise with a recording host instead of allowing Yargs to write to the ambient console or terminate the test process.
+
+Use `environmentToYargsConfig` when an application owns config-file loading and wants to replace Yargs' process-global `.env()` lookup with an explicitly supplied environment. The resulting flat dotted object preserves Yargs' environment key normalization and can be passed to `.config()` before parsing:
+
+```ts
+await runYargsApplication({
+  host,
+  configure: parser => parser
+    .config(environmentToYargsConfig(host.environment, 'XL1'))
+    .scriptName('xl1')
+    .command(commands)
+    .help()
+    .version(version),
+})
+```
+
+This conversion preserves command-line-over-environment precedence, but it is not a general substitute for `.env()` in applications that also use Yargs-native config-file options: Yargs ranks config objects below config files, and treats a top-level `extends` key in a config object specially. Such applications should resolve those precedence and reserved-key rules before passing the object to `.config()`.
+
+## License
+
+LGPL-3.0-only

package/dist/node/environmentToYargsConfig.d.ts

@@ -0,0 +1,8 @@
+export type CliEnvironment = Readonly<Record<string, string | undefined>>;
+/**
+ * Converts a prefixed environment into the flat dotted config shape accepted
+ * by Yargs. Values remain strings so Yargs applies its normal option typing and
+ * coercion after command-line arguments have taken precedence.
+ */
+export declare function environmentToYargsConfig(environment: CliEnvironment, prefix: string): Record<string, string | undefined>;
+//# sourceMappingURL=environmentToYargsConfig.d.ts.map

package/dist/node/environmentToYargsConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environmentToYargsConfig.d.ts","sourceRoot":"","sources":["../../src/environmentToYargsConfig.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAA;AA8BzE;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,cAAc,EAC3B,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAWpC"}

package/dist/node/index.d.ts

@@ -0,0 +1,3 @@
+export * from './environmentToYargsConfig.ts';
+export * from './runYargsApplication.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/node/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAA;AAC7C,cAAc,0BAA0B,CAAA"}

package/dist/node/index.mjs

@@ -0,0 +1,96 @@
+// src/environmentToYargsConfig.ts
+function camelCaseEnvironmentSegment(value) {
+  const isCamelCase = value !== value.toLowerCase() && value !== value.toUpperCase();
+  const normalized = isCamelCase ? value : value.toLowerCase();
+  if (!normalized.includes("-") && !normalized.includes("_")) return normalized;
+  let result = "";
+  let isNextCharacterUpper = false;
+  const leadingHyphens = /^-+/.exec(normalized);
+  const start = leadingHyphens?.[0].length ?? 0;
+  for (let index = start; index < normalized.length; index++) {
+    let character = normalized.charAt(index);
+    if (isNextCharacterUpper) {
+      isNextCharacterUpper = false;
+      character = character.toUpperCase();
+    }
+    if (index !== 0 && (character === "-" || character === "_")) {
+      isNextCharacterUpper = true;
+    } else if (character !== "-" && character !== "_") {
+      result += character;
+    }
+  }
+  return result;
+}
+function environmentToYargsConfig(environment, prefix) {
+  const config = {};
+  for (const [environmentName, environmentValue] of Object.entries(environment)) {
+    if (!environmentName.startsWith(prefix)) continue;
+    const keys = environmentName.split("__").map((key, index) => {
+      return camelCaseEnvironmentSegment(index === 0 ? key.slice(prefix.length) : key);
+    });
+    const configKey = keys.join(".");
+    if (!Object.hasOwn(config, configKey)) config[configKey] = environmentValue;
+  }
+  return config;
+}
+
+// src/runYargsApplication.ts
+import {
+  exitProcess,
+  ProcessExitError
+} from "@ariestools/cli-kit";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+async function invokeFailureHandler(handler, error) {
+  try {
+    await handler?.(error);
+    return { hasError: false };
+  } catch (failureHandlerError) {
+    return { error: failureHandlerError, hasError: true };
+  }
+}
+function reportFailureHandlerError(host, result) {
+  if (result.hasError) host.io.error("Error handling application failure:", result.error);
+}
+async function runYargsApplication({
+  configure,
+  host,
+  onFailure
+}) {
+  const applicationArguments = hideBin([...host.argv]);
+  const parser = configure(yargs(applicationArguments));
+  const captured = { error: void 0, output: "" };
+  try {
+    await parser.parseAsync(applicationArguments, {}, (error, _argv, output) => {
+      captured.error = error ?? void 0;
+      captured.output = output;
+    });
+  } catch (error) {
+    if (error instanceof ProcessExitError) throw error;
+    const failureHandlerResult = await invokeFailureHandler(onFailure, error);
+    host.io.error(await parser.getHelp());
+    host.io.error();
+    host.io.error(error);
+    reportFailureHandlerError(host, failureHandlerResult);
+    exitProcess(host, 1);
+  }
+  if (captured.error !== void 0) {
+    const failureHandlerResult = await invokeFailureHandler(onFailure, captured.error);
+    if (captured.output.length > 0) {
+      host.io.error(captured.output);
+    } else {
+      host.io.error(captured.error);
+    }
+    reportFailureHandlerError(host, failureHandlerResult);
+    exitProcess(host, 1);
+  }
+  if (captured.output.length > 0) {
+    host.io.log(captured.output);
+    exitProcess(host, 0);
+  }
+}
+export {
+  environmentToYargsConfig,
+  runYargsApplication
+};
+//# sourceMappingURL=index.mjs.map

package/dist/node/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/environmentToYargsConfig.ts", "../../src/runYargsApplication.ts"],
+  "sourcesContent": ["export type CliEnvironment = Readonly<Record<string, string | undefined>>\n\n/**\n * Matches the segment normalization used by yargs-parser for environment keys.\n * Keeping this local avoids coupling the adapter to an unexported parser helper.\n */\nfunction camelCaseEnvironmentSegment(value: string): string {\n  const isCamelCase = value !== value.toLowerCase() && value !== value.toUpperCase()\n  const normalized = isCamelCase ? value : value.toLowerCase()\n  if (!normalized.includes('-') && !normalized.includes('_')) return normalized\n\n  let result = ''\n  let isNextCharacterUpper = false\n  const leadingHyphens = /^-+/.exec(normalized)\n  const start = leadingHyphens?.[0].length ?? 0\n  for (let index = start; index < normalized.length; index++) {\n    let character = normalized.charAt(index)\n    if (isNextCharacterUpper) {\n      isNextCharacterUpper = false\n      character = character.toUpperCase()\n    }\n    if (index !== 0 && (character === '-' || character === '_')) {\n      isNextCharacterUpper = true\n    } else if (character !== '-' && character !== '_') {\n      result += character\n    }\n  }\n  return result\n}\n\n/**\n * Converts a prefixed environment into the flat dotted config shape accepted\n * by Yargs. Values remain strings so Yargs applies its normal option typing and\n * coercion after command-line arguments have taken precedence.\n */\nexport function environmentToYargsConfig(\n  environment: CliEnvironment,\n  prefix: string,\n): Record<string, string | undefined> {\n  const config: Record<string, string | undefined> = {}\n  for (const [environmentName, environmentValue] of Object.entries(environment)) {\n    if (!environmentName.startsWith(prefix)) continue\n    const keys = environmentName.split('__').map((key, index) => {\n      return camelCaseEnvironmentSegment(index === 0 ? key.slice(prefix.length) : key)\n    })\n    const configKey = keys.join('.')\n    if (!Object.hasOwn(config, configKey)) config[configKey] = environmentValue\n  }\n  return config\n}\n", "import {\n  exitProcess, ProcessExitError, type ProcessHost,\n} from '@ariestools/cli-kit'\nimport type { Argv } from 'yargs'\nimport yargs from 'yargs'\nimport { hideBin } from 'yargs/helpers'\n\nexport interface RunYargsApplicationOptions {\n  readonly configure: (parser: Argv) => Argv\n  readonly host: ProcessHost\n  readonly onFailure?: (error: unknown) => Promise<void> | void\n}\n\ninterface CapturedParseOutput {\n  error: Error | undefined\n  output: string\n}\n\ninterface FailureHandlerResult {\n  readonly error?: unknown\n  readonly hasError: boolean\n}\n\nasync function invokeFailureHandler(\n  handler: RunYargsApplicationOptions['onFailure'],\n  error: unknown,\n): Promise<FailureHandlerResult> {\n  try {\n    await handler?.(error)\n    return { hasError: false }\n  } catch (failureHandlerError) {\n    return { error: failureHandlerError, hasError: true }\n  }\n}\n\nfunction reportFailureHandlerError(host: ProcessHost, result: FailureHandlerResult): void {\n  if (result.hasError) host.io.error('Error handling application failure:', result.error)\n}\n\n/**\n * Runs a configured Yargs app through the supplied process boundary.\n * Yargs' parse callback prevents its default console and process.exit calls;\n * the adapter then routes the equivalent output and exit through ProcessHost.\n */\nexport async function runYargsApplication({\n  configure,\n  host,\n  onFailure,\n}: RunYargsApplicationOptions): Promise<void> {\n  const applicationArguments = hideBin([...host.argv])\n  const parser = configure(yargs(applicationArguments))\n  const captured: CapturedParseOutput = { error: undefined, output: '' }\n\n  try {\n    await parser.parseAsync(applicationArguments, {}, (error, _argv, output) => {\n      // Yargs 18 reports `null` on success at runtime despite @types/yargs\n      // declaring this callback value as `Error | undefined`.\n      captured.error = error ?? undefined\n      captured.output = output\n    })\n  } catch (error) {\n    if (error instanceof ProcessExitError) throw error\n    const failureHandlerResult = await invokeFailureHandler(onFailure, error)\n    host.io.error(await parser.getHelp())\n    host.io.error()\n    host.io.error(error)\n    reportFailureHandlerError(host, failureHandlerResult)\n    exitProcess(host, 1)\n  }\n\n  if (captured.error !== undefined) {\n    const failureHandlerResult = await invokeFailureHandler(onFailure, captured.error)\n    if (captured.output.length > 0) {\n      host.io.error(captured.output)\n    } else {\n      host.io.error(captured.error)\n    }\n    reportFailureHandlerError(host, failureHandlerResult)\n    exitProcess(host, 1)\n  }\n\n  if (captured.output.length > 0) {\n    host.io.log(captured.output)\n    exitProcess(host, 0)\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/node/runYargsApplication.d.ts

@@ -0,0 +1,14 @@
+import { type ProcessHost } from '@ariestools/cli-kit';
+import type { Argv } from 'yargs';
+export interface RunYargsApplicationOptions {
+    readonly configure: (parser: Argv) => Argv;
+    readonly host: ProcessHost;
+    readonly onFailure?: (error: unknown) => Promise<void> | void;
+}
+/**
+ * Runs a configured Yargs app through the supplied process boundary.
+ * Yargs' parse callback prevents its default console and process.exit calls;
+ * the adapter then routes the equivalent output and exit through ProcessHost.
+ */
+export declare function runYargsApplication({ configure, host, onFailure, }: RunYargsApplicationOptions): Promise<void>;
+//# sourceMappingURL=runYargsApplication.d.ts.map

package/dist/node/runYargsApplication.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runYargsApplication.d.ts","sourceRoot":"","sources":["../../src/runYargsApplication.ts"],"names":[],"mappings":"AAAA,OAAO,EAC0B,KAAK,WAAW,EAChD,MAAM,qBAAqB,CAAA;AAC5B,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAA;AAIjC,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,IAAI,KAAK,IAAI,CAAA;IAC1C,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;CAC9D;AA4BD;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,EACxC,SAAS,EACT,IAAI,EACJ,SAAS,GACV,EAAE,0BAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CAqC5C"}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@ariestools/cli-kit-yargs",
+  "version": "1.0.0",
+  "description": "Yargs adapter for reusable actor command-line applications",
+  "keywords": [
+    "ariestools",
+    "cli",
+    "yargs",
+    "typescript",
+    "esm"
+  ],
+  "homepage": "https://ariestools.ai",
+  "bugs": {
+    "url": "https://github.com/ariestools/cli-kit/issues",
+    "email": "support@ariestools.ai"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ariestools/cli-kit.git",
+    "directory": "packages/cli-kit-yargs"
+  },
+  "license": "LGPL-3.0-only",
+  "author": {
+    "name": "Arie Trouw",
+    "email": "support@ariestools.ai",
+    "url": "https://ariestools.ai"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/node/index.d.ts",
+      "default": "./dist/node/index.mjs"
+    },
+    "./package.json": "./package.json",
+    "./README.md": "./README.md"
+  },
+  "files": [
+    "dist",
+    "!**/*.bench.*",
+    "!**/*.spec.*",
+    "!**/*.test.*",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@types/yargs": "~17.0.35",
+    "yargs": "~18.0.0",
+    "@ariestools/cli-kit": "~1.0.0"
+  },
+  "devDependencies": {
+    "@ariestools/toolchain": "~8.7.21",
+    "@ariestools/tsconfig": "~8.7.21",
+    "eslint": "~10.7.0",
+    "typescript": "~6.0.3",
+    "vite": "~8.1.5",
+    "vitest": "~4.1.10",
+    "eslint-import-resolver-typescript": "~4.4.5"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "engineStrict": true,
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:ci": "vitest run"
+  }
+}