@karmaniverous/get-dotenv 5.0.0-2 → 5.1.0

package/README.md

@@ -1,14 +1,12 @@
-# get-dotenv
-
-## Requirements
-
-- Node.js >= 20 (this repository pins 22.19.0 for CI/reproducibility)
+> **_Load, expand, and compose environment variables from a deterministic dotenv cascade, then execute commands under that context. Use `get-dotenv` as a library, a CLI, or a plugin-first host to build dotenv-aware tooling with cross‑platform shell control, CI‑friendly capture, and clear diagnostics._**
 
-## API Reference
-Generated API documentation is hosted at:
-- https://docs.karmanivero.us/get-dotenv
+# get-dotenv
 
-The site is built with TypeDoc from the source code in this repository.
+[![npm version](https://img.shields.io/npm/v/@karmaniverous/get-dotenv.svg)](https://www.npmjs.com/package/@karmaniverous/get-dotenv)
+![Node Current](https://img.shields.io/node/v/@karmaniverous/get-dotenv) <!-- TYPEDOC_EXCLUDE -->
+[![docs](https://img.shields.io/badge/docs-website-blue)](https://docs.karmanivero.us/get-dotenv)
+[![changelog](https://img.shields.io/badge/changelog-latest-blue.svg)](https://github.com/karmaniverous/get-dotenv/tree/main/CHANGELOG.md)<!-- /TYPEDOC_EXCLUDE -->
+[![license](https://img.shields.io/badge/license-BSD--3--Clause-blue.svg)](https://github.com/karmaniverous/get-dotenv/tree/main/LICENSE.md)
 
 Load environment variables with a cascade of environment-aware dotenv files. You can:
 
@@ -44,6 +42,18 @@ You can always use `getdotenv` directly on the command line, but its REAL power
 
 When you plug your own [`commander`](https://www.npmjs.com/package/commander) CLI commands into the `getdotenv` base, they will execute within all of the environmental context created above!
 
+## Requirements
+
+- Node.js >= 20 (this repository pins 22.19.0 for CI/reproducibility)
+
+## API Reference
+
+Generated API documentation is hosted at:
+
+- https://docs.karmanivero.us/get-dotenv
+
+The site is built with TypeDoc from the source code in this repository.
+
 ## Testing
 
 This project uses Vitest with the V8 coverage provider. Run:
@@ -60,8 +70,7 @@ npm install @karmaniverous/get-dotenv
 
 ## Scaffold
 
-You can scaffold config files and a host-based CLI skeleton using the built-in
-init command. Templates are shipped with the package and copied verbatim.
+You can scaffold config files and a host-based CLI skeleton using the built-in init command. Templates are shipped with the package and copied verbatim.
 
 Examples:
 
@@ -83,20 +92,13 @@ npx getdotenv init ./apps/toolbox \
 
 Collision flow (when a destination file exists):
 
-- Interactive prompt: [o]verwrite, [e]xample, [s]kip, or their “all” variants
-  [O]/[E]/[S].
-- Non-interactive detection:
-  - Treated as `--yes` (Skip All) unless `--force` is provided (Overwrite All).
-  - Considered non-interactive when stdin or stdout is not a TTY OR when a
-    CI-like environment variable is present (`CI`, `GITHUB_ACTIONS`,
-    `BUILDKITE`, `TEAMCITY_VERSION`, `TF_BUILD`).
-- Precedence:
-  - `--force` > `--yes` > auto-detect (non-interactive => Skip All).
+- Interactive prompt: [o]verwrite, [e]xample, [s]kip, or their “all” variants [O]/[E]/[S].
+- Non-interactive detection: Treated as `--yes` (Skip All) unless `--force` is provided (Overwrite All). Considered non-interactive when stdin or stdout is not a TTY OR when a CI-like environment variable is present (`CI`, `GITHUB_ACTIONS`, `BUILDKITE`, `TEAMCITY_VERSION`, `TF_BUILD`).
+- Precedence: `--force` > `--yes` > auto-detect (non-interactive => Skip All).
 - Options overview:
   - `--config-format <json|yaml|js|ts>`
   - `--with-local` to generate `.local` alongside public config (JSON/YAML)
-  - `--cli-name <string>` for token substitution (`__CLI_NAME__`) in the CLI
-    skeleton
+  - `--cli-name <string>` for token substitution (`__CLI_NAME__`) in the CLI skeleton
   - `--force` to overwrite all; `--yes` to skip all
 
 Notes:
@@ -106,14 +108,15 @@ Notes:
 
 ## Usage
 
-````js
+```js
 import { getDotenv } from '@karmaniverous/get-dotenv';
 
-const dotenv = await getDotenv(options);```
+const dotenv = await getDotenv(options);
+```
 
 Options can be passed programmatically or set in a `getdotenv.config.json` file in your project root directory. The same file also sets default options for the `getdotenv` CLI or any child CLI you spawn from it.
 
-See the [child CLI example repo](https://github.com/karmaniverous/get-dotenv-child#configuration) for an extensiive discussion of the various config options and how & where to set them.
+See the [child CLI example repo](https://github.com/karmaniverous/get-dotenv-child#configuration) for an extensive discussion of the various config options and how & where to set them.
 
 ## Dynamic Processing
 
@@ -126,10 +129,10 @@ export default {
   SOME_DYNAMIC_VARIABLE: (dotenv) => someLogic(dotenv),
   ANOTHER_DYNAMIC_VARIABLE: (dotenv) =>
     someOtherLogic(dotenv.SOME_DYNAMIC_VARIABLE),
-  ONE_MORE_TIME: ({ DESTRUCTRED_VARIABLE, ANOTHER_DYNAMIC_VARIABLE }) =>
-    DESTRUCTRED_VARIABLE + ANOTHER_DYNAMIC_VARIABLE,
+  ONE_MORE_TIME: ({ DESTRUCTURED_VARIABLE, ANOTHER_DYNAMIC_VARIABLE }) =>
+    DESTRUCTURED_VARIABLE + ANOTHER_DYNAMIC_VARIABLE,
 };
-````
+```
 
 If the value corresponding to a key is a function, it will be executed with the current state of `dotenv` as its single argument and the result applied back to the `dotenv` object. Otherwise, the value will just be applied back to `dotenv`. (Although if you're going to do that then you might as well just create a public global variable in the first place.)
 
@@ -146,9 +149,7 @@ export default {
 };
 ```
 
-If `esbuild` is not installed and a direct import fails, get-dotenv attempts a
-simple fallback for single-file `.ts` modules without imports; otherwise it will
-throw with clear guidance to install `esbuild`.
+If `esbuild` is not installed and a direct import fails, get-dotenv attempts a simple fallback for single-file `.ts` modules without imports; otherwise it will throw with clear guidance to install `esbuild`.
 
 Programmatic users can skip files entirely and pass dynamic variables directly:
 
@@ -175,8 +176,7 @@ Notes:
   - Install `esbuild` (`npm i -D esbuild`).
 
 - “Unable to load dynamic TypeScript file …”:
-  - Install `esbuild`. A simple transpile fallback exists only for trivial
-    single-file modules; any imports in `dynamic.ts` require `esbuild` bundling.
+  - Install `esbuild`. A simple transpile fallback exists only for trivial single-file modules; any imports in `dynamic.ts` require `esbuild` bundling.
 
 ## Command Line Interface
 
@@ -218,7 +218,8 @@ You can also use `getdotenv` from the command line:
 #   --dynamic-path <string>             dynamic variables path (.js or .ts; .ts is auto-compiled when esbuild is available, otherwise precompile)
 #   --paths <string>                    dotenv-expanded delimited list of paths to dotenv directory (default: "./")
 #   --paths-delimiter <string>          paths delimiter string (default: " ")
-#   --paths-delimiter-pattern <string>  paths delimiter regex pattern#   --private-token <string>            dotenv-expanded token indicating private variables (default: "local")
+#   --paths-delimiter-pattern <string>  paths delimiter regex pattern
+#   --private-token <string>            dotenv-expanded token indicating private variables (default: "local")
 #   --vars-delimiter <string>           vars delimiter string (default: " ")
 #   --vars-delimiter-pattern <string>   vars delimiter regex pattern
 #   --vars-assignor <string>            vars assignment operator string (default: "=")
@@ -277,7 +278,7 @@ Note that `batch` executes its commands in sequence, rather than in parallel!
 
 To understand why, imagine running `npm install` in a dozen repos from the same command line. The visual feedback would be impossible to follow, and if something broke you'd have a really hard time figuring out why.
 
-Instead, everything runs in sequence, and you get a clear record of exactly what heppened and where. Also worth noting that many complex processes are resource hogs: you would not _want_ to run a dozen Serverless deployments at once!
+Instead, everything runs in sequence, and you get a clear record of exactly what happened and where. Also worth noting that many complex processes are resource hogs: you would not _want_ to run a dozen Serverless deployments at once!
 
 Meanwhile, [this issue](https://github.com/karmaniverous/get-dotenv/issues/7) documents the parallel-processing option requirement. Feel free to submit a PR!
 
@@ -285,9 +286,7 @@ Meanwhile, [this issue](https://github.com/karmaniverous/get-dotenv/issues/7) do
 
 ### Authoring npm scripts and the `-c`/`--cmd` alias
 
-When you run commands via `npm run`, flags after `--` are forwarded to your script
-and may be applied to the inner shell command instead of `getdotenv` unless you
-structure your script carefully.
+When you run commands via `npm run`, flags after `--` are forwarded to your script and may be applied to the inner shell command instead of `getdotenv` unless you structure your script carefully.
 
 - Anti-pattern:
 
@@ -301,22 +300,17 @@ structure your script carefully.
   ```json
   { "scripts": { "script": "getdotenv -c 'echo $APP_SETTING'" } }
   ```
-  Now `npm run script -- -e dev` applies `-e` to `getdotenv`, which loads and expands
-  variables before executing the inner command.
+  Now `npm run script -- -e dev` applies `-e` to `getdotenv`, which loads and expands variables before executing the inner command.
 
 Notes:
 
 - `-c`/`--cmd` is an alias of the `cmd` subcommand; do not use both in a single invocation.
-- On POSIX shells, prefer single quotes to prevent the outer shell from expanding `$VAR`
-  before Node sees it. On PowerShell, single quotes are also literal.
-- Script-level shell overrides (`scripts[name].shell`) still take precedence over the global
-  `--shell`.
+- On POSIX shells, prefer single quotes to prevent the outer shell from expanding `$VAR` before Node sees it. On PowerShell, single quotes are also literal.
+- Script-level shell overrides (`scripts[name].shell`) still take precedence over the global `--shell`.
 
 Important:
 
-- When using the parent alias `--cmd` with a Node eval payload, quote the entire
-  payload as a single token so Commander does not treat `-e/--eval` as
-  getdotenv’s `-e, --env` flag.
+- When using the parent alias `--cmd` with a Node eval payload, quote the entire payload as a single token so Commander does not treat `-e/--eval` as getdotenv’s `-e, --env` flag.
   - POSIX example:
     ```
     getdotenv --cmd 'node -e "console.log(process.env.APP_SETTING ?? \"\")"'
@@ -325,23 +319,19 @@ Important:
     ```
     getdotenv --cmd 'node -e "console.log(process.env.APP_SETTING ?? \"\")"'
     ```
-- If you do not need to pass additional parent flags after the command, you can
-  prefer the subcommand form instead:
+- If you do not need to pass additional parent flags after the command, you can prefer the subcommand form instead:
   ```
   getdotenv --shell-off cmd node -e "console.log(process.env.APP_SETTING ?? '')"
   ```
 
 Diagnostics and CI capture:
 
-- To capture child stdout/stderr deterministically (e.g., in CI), either set
-  the environment variable `GETDOTENV_STDIO=pipe` or pass `--capture`. Outputs
-  are buffered and re-emitted after completion.
+- To capture child stdout/stderr deterministically (e.g., in CI), either set the environment variable `GETDOTENV_STDIO=pipe` or pass `--capture`. Outputs are buffered and re-emitted after completion.
 - For debugging environment composition, use:
   ```
   getdotenv --trace [keys...] cmd node -e "0"
   ```
-  When provided without keys, `--trace` emits a concise origin line for every
-  key (parent | dotenv | unset) to stderr before the child process launches.
+  When provided without keys, `--trace` emits a concise origin line for every key (parent | dotenv | unset) to stderr before the child process launches.
 
 ---
 
@@ -349,21 +339,17 @@ Diagnostics and CI capture:
 
 - [Cascade and precedence](./guides/cascade.md)
 - [Shell execution behavior and quoting](./guides/shell.md)
+- [Config files and overlays](./guides/config.md)
+- [Plugin-first host and plugins](./guides/plugins.md)
 
 The guides are also included in the [hosted API docs](https://docs.karmanivero.us/get-dotenv).
 
----
-
 ## Generated CLI
 
-This package still supports generating a standalone CLI for your projects.
-For most use cases we recommend the new plugin-first host because it resolves
-dotenv context once per invocation, supports composable plugins, and provides
-better subprocess control and diagnostics. If you prefer a thin, fixed
-command surface with defaults baked into config, the generated CLI can be a
-good fit.
+This package still supports generating a standalone CLI for your projects. For most use cases we recommend the new plugin-first host because it resolves dotenv context once per invocation, supports composable plugins, and provides better subprocess control and diagnostics. If you prefer a thin, fixed command surface with defaults baked into config, the generated CLI can be a good fit.
+
+See the [Generated CLI guide](https://docs.karmanivero.us/get-dotenv/guides/generated-cli) for details
 
-See the Generated CLI guide for details:
-https://docs.karmanivero.us/get-dotenv/guides/generated-cli
+---
 
 See more great templates & tools on [my GitHub Profile](https://github.com/karmaniverous)!

package/dist/cliHost.cjs

@@ -3,9 +3,9 @@
 var commander = require('commander');
 var fs = require('fs-extra');
 var packageDirectory = require('package-directory');
+var url = require('url');
 var path = require('path');
 var zod = require('zod');
-var url = require('url');
 var YAML = require('yaml');
 var nanoid = require('nanoid');
 var dotenv = require('dotenv');
@@ -984,6 +984,8 @@ const computeContext = async (customOptions, plugins, hostMetaUrl) => {
 
 const HOST_META_URL = (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cliHost.cjs', document.baseURI).href));
 const CTX_SYMBOL = Symbol('GetDotenvCli.ctx');
+const OPTS_SYMBOL = Symbol('GetDotenvCli.options');
+const HELP_HEADER_SYMBOL = Symbol('GetDotenvCli.helpHeader');
 /**
  * Plugin-first CLI host for get-dotenv. Extends Commander.Command.
  *
@@ -1000,15 +1002,33 @@ class GetDotenvCli extends commander.Command {
     _plugins = [];
     /** One-time installation guard */
     _installed = false;
+    /** Optional header line to prepend in help output */
+    [HELP_HEADER_SYMBOL];
     constructor(alias = 'getdotenv') {
         super(alias);
         // Ensure subcommands that use passThroughOptions can be attached safely.
         // Commander requires parent commands to enable positional options when a
         // child uses passThroughOptions.
         this.enablePositionalOptions();
+        // Configure grouped help: show only base options in default "Options";
+        // append App/Plugin sections after default help.
+        this.configureHelp({
+            visibleOptions: (cmd) => {
+                const all = cmd.options ??
+                    [];
+                return all.filter((opt) => {
+                    const group = opt.__group;
+                    return group === 'base';
+                });
+            },
+        });
+        this.addHelpText('beforeAll', () => {
+            const header = this[HELP_HEADER_SYMBOL];
+            return header && header.length > 0 ? `${header}\n\n` : '';
+        });
+        this.addHelpText('afterAll', (ctx) => this.#renderOptionGroups(ctx.command));
         // Skeleton preSubcommand hook: produce a context if absent, without
-        // mutating process.env. The passOptions hook (when installed) will
-        // compute the final context using merged CLI options; keeping
+        // mutating process.env. The passOptions hook (when installed) will    // compute the final context using merged CLI options; keeping
         // loadProcess=false here avoids leaking dotenv values into the parent
         // process env before subcommands execute.
         this.hook('preSubcommand', async () => {
@@ -1040,11 +1060,96 @@ class GetDotenvCli extends commander.Command {
     getCtx() {
         return this[CTX_SYMBOL];
     }
+    /**
+     * Retrieve the merged root CLI options bag (if set by passOptions()).
+     * Downstream-safe: no generics required.
+     */
+    getOptions() {
+        return this[OPTS_SYMBOL];
+    }
+    /** Internal: set the merged root options bag for this run. */
+    _setOptionsBag(bag) {
+        this[OPTS_SYMBOL] = bag;
+    }
     /**   * Convenience helper to create a namespaced subcommand.
      */
     ns(name) {
         return this.command(name);
     }
+    /**
+     * Tag options added during the provided callback as 'app' for grouped help.
+     * Allows downstream apps to demarcate their root-level options.
+     */
+    tagAppOptions(fn) {
+        const root = this;
+        const originalAddOption = root.addOption.bind(root);
+        const originalOption = root.option.bind(root);
+        const tagLatest = (cmd, group) => {
+            const optsArr = cmd.options;
+            if (Array.isArray(optsArr) && optsArr.length > 0) {
+                const last = optsArr[optsArr.length - 1];
+                last.__group = group;
+            }
+        };
+        root.addOption = function patchedAdd(opt) {
+            opt.__group = 'app';
+            return originalAddOption(opt);
+        };
+        root.option = function patchedOption(...args) {
+            const ret = originalOption(...args);
+            tagLatest(this, 'app');
+            return ret;
+        };
+        try {
+            return fn(root);
+        }
+        finally {
+            root.addOption = originalAddOption;
+            root.option = originalOption;
+        }
+    }
+    /**
+     * Branding helper: set CLI name/description/version and optional help header.
+     * If version is omitted and importMetaUrl is provided, attempts to read the
+     * nearest package.json version (best-effort; non-fatal on failure).
+     */
+    async brand(args) {
+        const { name, description, version, importMetaUrl, helpHeader } = args;
+        if (typeof name === 'string' && name.length > 0)
+            this.name(name);
+        if (typeof description === 'string')
+            this.description(description);
+        let v = version;
+        if (!v && importMetaUrl) {
+            try {
+                const fromUrl = url.fileURLToPath(importMetaUrl);
+                const pkgDir = await packageDirectory.packageDirectory({ cwd: fromUrl });
+                if (pkgDir) {
+                    const txt = await fs.readFile(`${pkgDir}/package.json`, 'utf-8');
+                    const pkg = JSON.parse(txt);
+                    if (pkg.version)
+                        v = pkg.version;
+                }
+            }
+            catch {
+                // best-effort only
+            }
+        }
+        if (v)
+            this.version(v);
+        // Help header:
+        // - If caller provides helpHeader, use it.
+        // - Otherwise, when a version is known, default to "<name> v<version>".
+        if (typeof helpHeader === 'string') {
+            this[HELP_HEADER_SYMBOL] = helpHeader;
+        }
+        else if (v) {
+            // Use the current command name (possibly overridden by 'name' above).
+            const header = `${this.name()} v${v}`;
+            this[HELP_HEADER_SYMBOL] = header;
+        }
+        return this;
+    }
     /**
      * Register a plugin for installation (parent level).
      * Installation occurs on first resolveAndLoad() (or explicit install()).
@@ -1083,7 +1188,71 @@ class GetDotenvCli extends commander.Command {
         for (const p of this._plugins)
             await run(p);
     }
+    // Render App/Plugin grouped options appended after default help.
+    #renderOptionGroups(cmd) {
+        const all = cmd.options ?? [];
+        const byGroup = new Map();
+        for (const o of all) {
+            const opt = o;
+            const g = opt.__group;
+            if (!g || g === 'base')
+                continue; // base handled by default help
+            const rows = byGroup.get(g) ?? [];
+            rows.push({
+                flags: opt.flags ?? '',
+                description: opt.description ?? '',
+            });
+            byGroup.set(g, rows);
+        }
+        if (byGroup.size === 0)
+            return '';
+        const renderRows = (title, rows) => {
+            const width = Math.min(40, rows.reduce((m, r) => Math.max(m, r.flags.length), 0));
+            const lines = rows
+                .map((r) => {
+                const pad = ' '.repeat(Math.max(2, width - r.flags.length + 2));
+                return `  ${r.flags}${pad}${r.description}`.trimEnd();
+            })
+                .join('\n');
+            return `\n${title}:\n${lines}\n`;
+        };
+        let out = '';
+        // App options (if any)
+        const app = byGroup.get('app');
+        if (app && app.length > 0) {
+            out += renderRows('App options', app);
+        }
+        // Plugin groups sorted by id
+        const pluginKeys = Array.from(byGroup.keys()).filter((k) => k.startsWith('plugin:'));
+        pluginKeys.sort((a, b) => a.localeCompare(b));
+        for (const k of pluginKeys) {
+            const id = k.slice('plugin:'.length) || '(unknown)';
+            const rows = byGroup.get(k) ?? [];
+            if (rows.length > 0) {
+                out += renderRows(`Plugin options — ${id}`, rows);
+            }
+        }
+        return out;
+    }
 }
 
+/**
+ * Helper to retrieve the merged root options bag from any action handler
+ * that only has access to thisCommand. Avoids structural casts.
+ */
+const readMergedOptions = (cmd) => {
+    // Ascend to the root command
+    let root = cmd;
+    while (root.parent) {
+        root = root.parent;
+    }
+    const hostAny = root;
+    return typeof hostAny.getOptions === 'function'
+        ? hostAny.getOptions()
+        : root
+            .getDotenvCliOptions;
+};
+
 exports.GetDotenvCli = GetDotenvCli;
 exports.definePlugin = definePlugin;
+exports.readMergedOptions = readMergedOptions;

package/dist/cliHost.d.cts

@@ -1,5 +1,13 @@
-import { ZodType } from 'zod';
 import { Command } from 'commander';
+import { ZodType } from 'zod';
+
+/**
+ * Scripts table shape (configurable shell type).
+ */
+type ScriptsTable<TShell extends string | boolean = string | boolean> = Record<string, string | {
+    cmd: string;
+    shell?: TShell;
+}>;
 
 /**
  * A minimal representation of an environment key/value mapping.
@@ -95,6 +103,76 @@ interface GetDotenvOptions {
     useConfigLoader?: boolean;
 }
 
+type Scripts = Record<string, string | {
+    cmd: string;
+    shell?: string | boolean;
+}>;
+/**
+ * Options passed programmatically to `getDotenvCli`.
+ */
+interface GetDotenvCliOptions extends Omit<GetDotenvOptions, 'paths' | 'vars'> {
+    /**
+     * Logs CLI internals when true.
+     */
+    debug?: boolean;
+    /**
+     * When true, capture child stdout/stderr and re-emit after completion.
+     * Useful for tests/CI. Default behavior is streaming via stdio: 'inherit'.
+     */
+    capture?: boolean;
+    /**
+     * A delimited string of paths to dotenv files.
+     */
+    paths?: string;
+    /**
+     * A delimiter string with which to split `paths`. Only used if
+     * `pathsDelimiterPattern` is not provided.
+     */
+    pathsDelimiter?: string;
+    /**
+     * A regular expression pattern with which to split `paths`. Supersedes
+     * `pathsDelimiter`.
+     */
+    pathsDelimiterPattern?: string;
+    /**
+     * Scripts that can be executed from the CLI, either individually or via the batch subcommand.
+     */
+    scripts?: Scripts;
+    /**
+     * Determines how commands and scripts are executed. If `false` or
+     * `undefined`, commands are executed as plain Javascript using the default
+     * execa parser. If `true`, commands are executed using the default OS shell
+     * parser. Otherwise the user may provide a specific shell string (e.g.
+     * `/bin/bash`)
+     */
+    shell?: string | boolean;
+    /**
+     * A delimited string of key-value pairs declaratively specifying variables &
+     * values to be loaded in addition to any dotenv files.
+     */
+    vars?: string;
+    /**
+     * A string with which to split keys from values in `vars`. Only used if
+     * `varsDelimiterPattern` is not provided.
+     */
+    varsAssignor?: string;
+    /**
+     * A regular expression pattern with which to split variable names from values
+     * in `vars`. Supersedes `varsAssignor`.
+     */
+    varsAssignorPattern?: string;
+    /**
+     * A string with which to split `vars` into key-value pairs. Only used if
+     * `varsDelimiterPattern` is not provided.
+     */
+    varsDelimiter?: string;
+    /**
+     * A regular expression pattern with which to split `vars` into key-value
+     * pairs. Supersedes `varsDelimiter`.
+     */
+    varsDelimiterPattern?: string;
+}
+
 /** * Per-invocation context shared with plugins and actions. */
 type GetDotenvCliCtx<TOptions extends GetDotenvOptions = GetDotenvOptions> = {
     optionsResolved: TOptions;
@@ -102,6 +180,7 @@ type GetDotenvCliCtx<TOptions extends GetDotenvOptions = GetDotenvOptions> = {
     plugins?: Record<string, unknown>;
     pluginConfigs?: Record<string, unknown>;
 };
+declare const HELP_HEADER_SYMBOL: unique symbol;
 /**
  * Plugin-first CLI host for get-dotenv. Extends Commander.Command.
  *
@@ -114,10 +193,13 @@ type GetDotenvCliCtx<TOptions extends GetDotenvOptions = GetDotenvOptions> = {
  * NOTE: This host is additive and does not alter the legacy CLI.
  */
 declare class GetDotenvCli<TOptions extends GetDotenvOptions = GetDotenvOptions> extends Command {
+    #private;
     /** Registered top-level plugins (composition happens via .use()) */
     private _plugins;
     /** One-time installation guard */
     private _installed;
+    /** Optional header line to prepend in help output */
+    private [HELP_HEADER_SYMBOL];
     constructor(alias?: string);
     /**
      * Resolve options (strict) and compute dotenv context.   * Stores the context on the instance under a symbol.
@@ -127,9 +209,33 @@ declare class GetDotenvCli<TOptions extends GetDotenvOptions = GetDotenvOptions>
      * Retrieve the current invocation context (if any).
      */
     getCtx(): GetDotenvCliCtx<TOptions> | undefined;
+    /**
+     * Retrieve the merged root CLI options bag (if set by passOptions()).
+     * Downstream-safe: no generics required.
+     */
+    getOptions(): GetDotenvCliOptions | undefined;
+    /** Internal: set the merged root options bag for this run. */
+    _setOptionsBag(bag: GetDotenvCliOptions): void;
     /**   * Convenience helper to create a namespaced subcommand.
      */
     ns(name: string): Command;
+    /**
+     * Tag options added during the provided callback as 'app' for grouped help.
+     * Allows downstream apps to demarcate their root-level options.
+     */
+    tagAppOptions<T>(fn: (root: Command) => T): T;
+    /**
+     * Branding helper: set CLI name/description/version and optional help header.
+     * If version is omitted and importMetaUrl is provided, attempts to read the
+     * nearest package.json version (best-effort; non-fatal on failure).
+     */
+    brand(args: {
+        name?: string;
+        description?: string;
+        version?: string;
+        importMetaUrl?: string;
+        helpHeader?: string;
+    }): Promise<this>;
     /**
      * Register a plugin for installation (parent level).
      * Installation occurs on first resolveAndLoad() (or explicit install()).
@@ -187,5 +293,11 @@ type DefineSpec = Omit<GetDotenvCliPlugin, 'children' | 'use'> & {
  */
 declare const definePlugin: (spec: DefineSpec) => GetDotenvCliPlugin;
 
-export { GetDotenvCli, definePlugin };
-export type { DefineSpec, GetDotenvCliPlugin };
+/**
+ * Helper to retrieve the merged root options bag from any action handler
+ * that only has access to thisCommand. Avoids structural casts.
+ */
+declare const readMergedOptions: (cmd: Command) => GetDotenvCliOptions | undefined;
+
+export { GetDotenvCli, definePlugin, readMergedOptions };
+export type { DefineSpec, GetDotenvCliCtx, GetDotenvCliOptions, GetDotenvCliPlugin, ScriptsTable };