commander-wizard 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 commander-wizard contributors
+
+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/README.md

@@ -0,0 +1,165 @@
+# commander-wizard
+
+Add a [Clack](https://github.com/bombshell-dev/clack) wizard to your
+[Commander](https://github.com/tj/commander.js) CLI. Users can fill in missing
+inputs, review their choices, and copy a command to run without prompts.
+
+**Requires:** Commander 14 or 15, Node >=22.12.0, and ESM. Wizard mode needs a terminal
+for both stdin and stdout. Rerun commands use POSIX shell syntax.
+
+## Quick start
+
+```sh
+nub add commander commander-wizard
+```
+
+Save as `cli.mjs`:
+
+```js
+import { Command } from 'commander';
+import { addWizard, WizardCancelledError } from 'commander-wizard';
+
+const program = new Command('deploy-cli');
+const deploy = program.command('deploy')
+  .argument('<environment>')
+  .requiredOption('--service <name>')
+  .option('--region <name>', 'AWS region', 'us-east-1')
+  .option('--force', 'skip safety checks')
+  .action((environment, options) => console.log({ environment, ...options }));
+
+// Add your commands and options before calling addWizard.
+addWizard(program, { invocation: ['node', 'cli.mjs'] });
+
+try {
+  await program.parseAsync();
+} catch (error) {
+  if (!(error instanceof WizardCancelledError)) throw error;
+}
+```
+
+```sh
+node cli.mjs deploy --wizard                           # prompt for inputs
+node cli.mjs deploy dev --service api --wizard   # keep supplied inputs
+node cli.mjs deploy dev --service api            # ordinary Commander invocation
+```
+
+Use `parseAsync()` for wizard invocations, or
+`parseAsync(args, { from: 'user' })` with an argument array.
+
+`addWizard()` decorates the root and every leaf subcommand, including nested
+ones. Only the selected leaf command and supported ancestor options are
+prompted.
+
+## Using the wizard
+
+You keep values supplied on the command line and answer prompts for the rest:
+
+- Boolean flags: Yes/No, with No as the default for a plain flag such as `--force`.
+- Choices: select one, or use multiselect for variadic choices.
+- Text inputs: the default is prefilled; press Enter to accept it or edit it.
+  Variadics without choices collect one value per line; an empty line finishes the
+  list.
+
+You review **raw CLI inputs** and a rerun command. Select **Edit …** to revisit a
+prompt with your previous answer prefilled; other answers stay intact. Repeat as
+needed, then choose **Continue to confirmation** (final confirmation defaults to
+No). CLI-supplied inputs remain unchanged and are not offered for editing.
+After confirmation, Commander applies parsers, requirements, conflicts, and
+implications before running your action. Restart the wizard to correct invalid
+inputs; custom parsers do not run during prompting.
+
+Declining or pressing Ctrl-C throws `WizardCancelledError` without running your
+hooks or action. Catch it as in the example. For Commander errors, configure
+`exitOverride()` if you need to catch them instead of exiting.
+
+You keep Commander's parsing and validation for ordinary invocations. Your
+action receives no wizard-trigger option after a wizard run.
+
+**Do not use the wizard for secrets. You expose inputs in review and rerun output.**
+
+## Custom flags
+
+The default is `--wizard`, with no short alias. Set `flags` to a Commander boolean
+flag declaration to replace it:
+
+```js
+addWizard(program, { flags: '-i, --interactive' });
+```
+
+You can use a short flag alone, a long flag alone, or both. Flags that take values
+and negated flags (`--no-…`) are not supported. The configured flags and their
+Commander option attribute must not collide with existing options, including help.
+
+## Rerun commands and defaults
+
+Set `invocation` to executable tokens, such as `['node', 'cli.mjs']` or
+`['your-installed-cli']`. Without it, you get the current Node executable,
+execution flags, and script path. Specify it for custom launchers. Rerun from
+the same directory with the same application configuration. Use a POSIX shell;
+PowerShell and cmd.exe use different quoting.
+
+You can accept string, numeric, and choice defaults. You get those values in the
+rerun command, except for empty variadics and false booleans without a negative
+flag. Declare a negative form such as `--no-color` to express false by name.
+Inputs with defaults are prefilled — press Enter to accept. Clearing the input
+is refused, because omitting the flag would restore the default.
+
+For a custom parser's default, provide the raw CLI spelling with `rawDefaults`.
+For example, add this to the quick start **before parsing**, replacing its
+`addWizard()` call:
+
+```js
+import { Option } from 'commander';
+
+const replicas = new Option('--replicas <count>')
+  .argParser(Number)
+  .default(3);
+deploy.addOption(replicas);
+
+addWizard(program, {
+  invocation: ['node', 'cli.mjs'],
+  rawDefaults: new Map([[replicas, ['3']]]),
+});
+```
+
+Key `rawDefaults` by the `Option` or `Argument` object. Supply raw strings, one
+for a scalar input, that produce the intended value with your parser's
+previous/default argument. Define a parser to convert CLI strings to numbers;
+a numeric default alone does not perform that conversion.
+
+## Compatibility limits
+
+Use root-only or nested leaf actions with global scalar options, short flags,
+positive/negative boolean pairs, positional arguments, choices, and leaf variadics.
+
+In wizard mode, put the full command path before flags:
+`cli group command --wizard --flag=value`. Keep short flags separate; avoid `-abc` and
+`-n3`. Put option-like positional values after `--`, including a literal `--wizard`.
+
+You cannot use these Commander features in wizard mode:
+
+- Executable subcommands, legacy command listeners, actions on commands with
+  children, or implicit/default subcommands.
+- Ancestor positional arguments or variadic options, positional/pass-through
+  option modes, or shadowed global option names/flags.
+- Environment-bound options, optional option values (`--color [value]`), presets,
+  custom boolean parsers, or options stored as command properties.
+- Electron argv or piped input/output.
+
+Configure your tree before calling `addWizard()` on its root. Reserve the
+configured flags and option attribute (`--wizard` and `wizard` by default). Repeat calls keep the first configuration. Do not add commands afterward
+or decorate overlapping trees.
+
+## Development
+
+```sh
+nub install
+nub run typecheck
+nub run test          # regression tests and built-package import check
+nub run test:smoke    # terminal test; requires expect and stty
+nub example.ts deploy --wizard
+nub pack --dry-run
+```
+
+Build with `nub run build`; pack the library and declarations from `dist/`.
+MIT licensed. See `LICENSE`.

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { addWizard, WizardCancelledError } from './wizard.js';
+export type { WizardOptions } from './wizard.js';

package/dist/index.js

@@ -0,0 +1 @@
+export { addWizard, WizardCancelledError } from './wizard.js';

package/dist/wizard.d.ts

@@ -0,0 +1,14 @@
+import type { Argument, Command, Option } from 'commander';
+export declare class WizardCancelledError extends Error {
+    constructor();
+}
+export interface WizardOptions {
+    /** Commander boolean flag declaration. Defaults to --wizard. */
+    flags?: string;
+    /** Executable and prefix arguments, e.g. ['nub', 'example.ts']. Never a shell fragment. */
+    invocation?: readonly string[];
+    /** Raw CLI spellings for defaults processed by custom parsers. Key by Option/Argument identity. */
+    rawDefaults?: ReadonlyMap<Option | Argument, readonly string[]>;
+}
+/** Decorate an already-configured program. No global/prototype patching; use parseAsync for wizard mode. */
+export declare function addWizard<T extends Command>(program: T, config?: WizardOptions): T;

package/dist/wizard.js

@@ -0,0 +1,351 @@
+import * as p from '@clack/prompts';
+import { inspect } from 'node:util';
+export class WizardCancelledError extends Error {
+    constructor() { super('Wizard cancelled.'); this.name = 'WizardCancelledError'; }
+}
+const installed = new WeakSet();
+const fail = (message) => { throw new Error(`Wizard: ${message}`); };
+/** Decorate an already-configured program. No global/prototype patching; use parseAsync for wizard mode. */
+export function addWizard(program, config = {}) {
+    if (installed.has(program))
+        return program;
+    if (config.invocation && (!config.invocation.length || !config.invocation.every(v => typeof v === 'string') || !config.invocation[0]))
+        fail('invocation must contain an executable followed by string arguments.');
+    const flags = config.flags ?? '--wizard';
+    if (typeof flags !== 'string' || !/^(?:-[a-zA-Z0-9](?:[ ,|]+--[a-zA-Z0-9][a-zA-Z0-9-]*)?|--[a-zA-Z0-9][a-zA-Z0-9-]*)$/.test(flags))
+        fail('flags must declare a boolean flag, e.g. --wizard or -i, --interactive.');
+    const flagOption = program.createOption(flags);
+    if (flagOption.negate)
+        fail('flags must not use a negated --no- flag.');
+    const markers = new Set([flagOption.short, flagOption.long].filter((flag) => flag !== undefined));
+    const wizardKey = flagOption.attributeName();
+    const commands = [];
+    const visit = (cmd) => { commands.push(cmd); cmd.commands.forEach(visit); };
+    visit(program);
+    // Preflight the whole tree before changing any command.
+    for (const cmd of commands) {
+        const help = cmd.createHelp().visibleOptions(cmd);
+        if ([...cmd.options, ...help].some(o => markers.has(o.short ?? '') || markers.has(o.long ?? '') || o.attributeName() === wizardKey))
+            fail(`flag conflict on ${cmd.name() || 'program'}: ${flags} is reserved.`);
+        if (installed.has(cmd))
+            fail('overlapping decorated command trees are unsupported.');
+    }
+    const parseAsync = program.parseAsync;
+    for (const cmd of commands.filter(cmd => cmd.commands.length === 0)) {
+        cmd.option(flags, 'collect command inputs interactively');
+        // Never let a wizard flag that escaped our bounded scanner dispatch an action.
+        cmd.on(`option:${flagOption.name()}`, () => fail('use parseAsync() with an explicit command path and unbundled flags for wizard mode.'));
+    }
+    program.parseAsync = async function (argv, options) {
+        const args = userArgs(argv, options?.from);
+        if (!requested(args, markers))
+            return await parseAsync.call(this, argv, options);
+        if (options?.from === 'electron' || (!argv && process.versions.electron))
+            fail('Electron wizard invocations are unsupported; pass explicit user arguments.');
+        let input;
+        try {
+            input = scan(program, args, markers);
+        }
+        catch {
+            // Commander can distinguish reserved text used as data in grammars we do not support.
+            // An actual wizard option is stopped by the option listener above.
+            return await parseAsync.call(this, argv, options);
+        }
+        // A marker consumed as an option value is data, not a wizard request.
+        if (!input.wizard)
+            return await parseAsync.call(this, argv, options);
+        checkLayout(input.chain, wizardKey);
+        if (!process.stdin.isTTY || !process.stdout.isTTY)
+            fail('interactive input requires a TTY.');
+        const completed = await collect(input, config, wizardKey);
+        // Commander alone owns coercion, validation, hooks, and action dispatch.
+        return await parseAsync.call(this, completed, { from: 'user' });
+    };
+    installed.add(program);
+    return program;
+}
+function userArgs(argv, from) {
+    if (from === 'user')
+        return [...(argv ?? process.argv)];
+    return (argv ?? process.argv).slice(!argv && Reflect.get(process, '_eval') !== undefined ? 1 : 2);
+}
+function requested(args, markers) {
+    const end = args.indexOf('--');
+    return args.slice(0, end < 0 ? args.length : end).some(a => markers.has(a));
+}
+/** Deliberately bounded wizard grammar: explicit command path first, unbundled options. */
+function scan(root, args, markers) {
+    const chain = [root];
+    let index = 0;
+    let cmd = root;
+    while (index < args.length) {
+        const child = cmd.commands.find(c => c.name() === args[index] || c.aliases().includes(args[index]));
+        if (!child)
+            break;
+        chain.push(child);
+        cmd = child;
+        index++;
+    }
+    const result = { chain, options: new Map(), positionals: [], supplied: [], wizard: false };
+    const options = chain.flatMap(c => c.options);
+    while (index < args.length) {
+        const token = args[index++];
+        if (token === '--') {
+            result.positionals.push(...args.slice(index));
+            break;
+        }
+        if (markers.has(token)) {
+            result.wizard = true;
+            continue;
+        }
+        if (!token.startsWith('-') || token === '-') {
+            result.positionals.push(token);
+            continue;
+        }
+        const equal = token.startsWith('--') ? token.indexOf('=') : -1;
+        const flag = equal < 0 ? token : token.slice(0, equal);
+        const opt = options.find(o => o.long === flag || o.short === flag);
+        if (!opt)
+            return fail(`unknown or bundled option ${flag}. Put the full command path first; use separate flags.`);
+        const raw = [];
+        raw.push(token);
+        if (opt.required || opt.optional) {
+            if (equal < 0) {
+                if (index >= args.length || (opt.optional && args[index].startsWith('-')))
+                    fail(`supply a value for ${flag} in wizard mode.`);
+                raw.push(args[index++]);
+            }
+            if (opt.variadic && equal < 0)
+                while (index < args.length && !args[index].startsWith('-'))
+                    raw.push(args[index++]);
+        }
+        else if (equal >= 0)
+            fail(`${flag} does not take a value.`);
+        result.options.set(opt, [...(result.options.get(opt) ?? []), ...raw]);
+        result.supplied.push({ option: opt, tokens: raw });
+    }
+    return result;
+}
+function checkLayout(chain, wizardKey) {
+    const keys = new Map();
+    for (const [index, cmd] of chain.entries()) {
+        // Commander 15 has no public capability getters. Keep these checks in one place.
+        for (const field of ['_executableHandler', '_passThroughOptions', '_enablePositionalOptions', '_defaultCommandName', '_storeOptionsAsProperties'])
+            if (Reflect.get(cmd, field))
+                fail(`${field} is unsupported in wizard mode.`);
+        if (index < chain.length - 1 && cmd.registeredArguments.length)
+            fail('ancestor positional arguments are unsupported in wizard mode.');
+        for (const opt of cmd.options) {
+            if (opt.attributeName() === wizardKey)
+                continue;
+            for (const key of [opt.attributeName(), opt.long, opt.short].filter((v) => v !== undefined)) {
+                if (keys.has(key) && keys.get(key) !== index)
+                    fail(`shadowed global option ${key}.`);
+                keys.set(key, index);
+            }
+            const siblings = cmd.options.filter(o => o.attributeName() === opt.attributeName());
+            if (siblings.length > 1 && !(siblings.length === 2 && siblings.some(o => o.negate) && siblings.some(o => o.isBoolean())))
+                fail(`ambiguous option attribute ${opt.attributeName()}.`);
+            if (index < chain.length - 1 && opt.variadic)
+                fail('ancestor variadic options are unsupported in wizard mode.');
+            if (opt.isBoolean() && opt.parseArg)
+                fail('boolean custom parsers are unsupported in wizard mode.');
+            if (opt.optional || opt.envVar || opt.presetArg !== undefined)
+                fail(`${opt.flags}: optional values, env bindings, and presets are unsupported in wizard mode.`);
+        }
+    }
+    const leaf = chain.at(-1);
+    if (leaf.commands.length || !Reflect.get(leaf, '_actionHandler'))
+        fail('select an explicit in-process action command. Legacy listeners are unsupported.');
+}
+function defaults(owner, config) {
+    if (owner.defaultValue === undefined)
+        return [];
+    const supplied = config.rawDefaults?.get(owner);
+    if (supplied) {
+        if (!supplied.every(v => typeof v === 'string') || (!owner.variadic && supplied.length !== 1))
+            fail('rawDefaults must contain raw strings (one for a scalar input).');
+        return [...supplied];
+    }
+    // choices() installs a parser, but its default strings remain CLI spellings.
+    if (owner.parseArg && !owner.argChoices)
+        fail(`provide rawDefaults for ${'flags' in owner ? owner.flags : owner.name()}; custom parsers are not reversible.`);
+    const values = Array.isArray(owner.defaultValue) ? owner.defaultValue : [owner.defaultValue];
+    if (!values.every(v => typeof v === 'string' || typeof v === 'number'))
+        fail('non-text defaults require rawDefaults.');
+    return values.map(String);
+}
+async function ask(owner, required, def, editing = false) {
+    const label = 'flags' in owner ? owner.flags : owner.name();
+    const hasDefault = owner.defaultValue !== undefined &&
+        (Array.isArray(owner.defaultValue) ? owner.defaultValue.length > 0 : owner.defaultValue !== '');
+    // Omitting tokens would restore Commander's default, not clear it.
+    required ||= hasDefault;
+    const emptyError = hasDefault ? 'Enter a value; omission restores the default.' : 'Required';
+    const message = `${label}${owner.description ? ` — ${owner.description}` : ''}`;
+    if (owner.argChoices?.length) {
+        const options = owner.argChoices.map(value => ({ value }));
+        if (owner.variadic)
+            return unwrap(await p.multiselect({
+                message: hasDefault ? `${message} (select at least one; omission restores the default)` : message,
+                options, required, initialValues: def,
+            }));
+        // Optional choices must be skippable rather than silently selecting the first entry.
+        if (!required && !def.length && !unwrap(await p.confirm({ message: `Set ${label}?`, initialValue: false })))
+            return [];
+        return [unwrap(await p.select({ message, options, ...(def[0] === undefined ? {} : { initialValue: def[0] }) }))];
+    }
+    if (owner.variadic) {
+        // ponytail: one value per line; empty value as a list item is not expressible, fine for CLI inputs.
+        const values = [];
+        const note = def.length ? `${editing ? ' (current' : ' (default'}: ${def.join(', ')})` : '';
+        while (true) {
+            const soFar = values.length ? ` — added: ${values.join(', ')}` : '';
+            const value = unwrap(await p.text({
+                message: `${message}${note}${soFar} (empty line to finish)`,
+                validate: v => !v?.trim() && required && !values.length ? 'Enter at least one value' : undefined,
+            }));
+            if (!value.trim())
+                break;
+            values.push(value.trim());
+        }
+        return values;
+    }
+    const value = unwrap(await p.text({
+        message,
+        // Prefill the default so Enter accepts it visibly; clearing is refused below.
+        ...(def.length ? { initialValue: def[0] } : {}),
+        validate(value) {
+            if (!value)
+                return required ? emptyError : undefined;
+            return undefined;
+        },
+    }));
+    return value === '' ? [] : [value];
+}
+function optionTokens(opt, values) {
+    const flag = opt.long ?? opt.short;
+    // Repeated long assignments protect leading '-' values and terminate each variadic occurrence.
+    if (opt.long)
+        return values.map(value => `${flag}=${value}`);
+    return values.flatMap(value => [flag, value]);
+}
+async function collect(input, config, wizardKey) {
+    const leaf = input.chain.at(-1);
+    const answers = new Map();
+    const booleans = new Map();
+    p.intro(`${leaf.name()} · wizard`);
+    while (true) {
+        const argv = [];
+        const summary = [];
+        const editable = [];
+        const collectValue = async (owner, required) => {
+            const values = answers.get(owner) ?? await ask(owner, required, defaults(owner, config));
+            answers.set(owner, values);
+            editable.push({
+                label: 'flags' in owner ? owner.flags : owner.name(),
+                edit: async () => { answers.set(owner, await ask(owner, required, values, true)); },
+            });
+            return values;
+        };
+        for (const [index, cmd] of input.chain.entries()) {
+            if (index)
+                argv.push(cmd.name());
+            for (const entry of input.supplied)
+                if (cmd.options.includes(entry.option))
+                    argv.push(...entry.tokens);
+            const seen = new Set();
+            for (const opt of cmd.options) {
+                const key = opt.attributeName();
+                if ([wizardKey, 'help', 'version'].includes(key) || seen.has(key))
+                    continue;
+                seen.add(key);
+                const group = cmd.options.filter(o => o.attributeName() === key);
+                const provided = group.flatMap(o => input.options.get(o) ?? []);
+                if (provided.length) {
+                    summary.push(`${key}: ${inspect(provided)}`);
+                    continue;
+                }
+                const positive = group.find(o => !o.negate);
+                const negative = group.find(o => o.negate);
+                if (opt.isBoolean() || opt.negate) {
+                    const def = group.reduce((value, option) => option.defaultValue === undefined ? value : Boolean(option.defaultValue), !positive);
+                    // No invented --no-x: restrict answers to states the CLI can actually express.
+                    const fixed = (positive && def && !negative) || (!positive && !def);
+                    const message = `${key} — ${opt.description}`;
+                    const value = booleans.get(opt) ?? (fixed ? def : unwrap(await p.confirm({ message, initialValue: def })));
+                    booleans.set(opt, value);
+                    if (!fixed)
+                        editable.push({
+                            label: opt.flags,
+                            edit: async () => { booleans.set(opt, unwrap(await p.confirm({ message, initialValue: value }))); },
+                        });
+                    if (value && positive)
+                        argv.push(positive.long ?? positive.short);
+                    else if (!value && negative)
+                        argv.push(negative.long ?? negative.short);
+                    summary.push(`${key}: ${value}`);
+                }
+                else {
+                    const values = await collectValue(opt, opt.mandatory);
+                    argv.push(...optionTokens(opt, values));
+                    summary.push(`${key}: ${inspect(values.length ? values : undefined)}`);
+                }
+            }
+        }
+        const positional = [];
+        let cursor = 0;
+        let omitted = false;
+        for (const arg of leaf.registeredArguments) {
+            let values = arg.variadic ? input.positionals.slice(cursor) : input.positionals.slice(cursor, cursor + 1);
+            cursor += values.length;
+            if (!values.length)
+                values = await collectValue(arg, arg.required);
+            if (omitted && values.length)
+                fail('cannot supply a positional argument after an omitted argument.');
+            if (!values.length && !arg.variadic)
+                omitted = true;
+            positional.push(...values);
+            summary.push(`${arg.name()}: ${inspect(arg.variadic ? values : values[0])}`);
+        }
+        positional.push(...input.positionals.slice(cursor)); // let Commander report excess arguments
+        argv.push('--', ...positional);
+        const invocation = config.invocation ?? [process.execPath, ...process.execArgv, process.argv[1] ?? fail('provide invocation.')];
+        const tokens = [...invocation, ...argv];
+        if (tokens.some(token => token.includes('\0')))
+            fail('NUL bytes cannot be represented in shell arguments.');
+        const command = tokens.map(shellQuote).join(' ');
+        p.note(`${summary.join('\n')}\n\nrerun non-interactively:\n${command}`, 'Review CLI inputs (Commander validates after confirmation)');
+        if (editable.length) {
+            const selected = unwrap(await p.select({
+                message: 'Continue or edit an input?',
+                options: [
+                    { value: -1, label: 'Continue to confirmation' },
+                    ...editable.map((field, value) => ({ value, label: `Edit ${field.label}` })),
+                ],
+                initialValue: -1,
+            }));
+            if (selected !== -1) {
+                await editable[selected].edit();
+                continue;
+            }
+        }
+        if (!unwrap(await p.confirm({ message: 'Run with these settings?', initialValue: false }))) {
+            p.cancel('Cancelled — nothing ran.');
+            throw new WizardCancelledError();
+        }
+        p.outro(`Running ${leaf.name()}…`);
+        return argv;
+    }
+}
+function unwrap(value) {
+    if (p.isCancel(value)) {
+        p.cancel('Wizard cancelled.');
+        throw new WizardCancelledError();
+    }
+    return value;
+}
+/** POSIX shell quoting. Windows shells are not supported. */
+function shellQuote(value) {
+    return /^[\w.,:/@%+=-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`;
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "commander-wizard",
+  "version": "0.0.1",
+  "description": "Interactive wizard mode for commander CLIs — collect, review, and rerun command inputs",
+  "keywords": [
+    "commander",
+    "cli",
+    "wizard",
+    "interactive",
+    "prompts",
+    "clack",
+    "typescript"
+  ],
+  "author": "jaydenfyi",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jaydenfyi/commander-wizard.git"
+  },
+  "homepage": "https://github.com/jaydenfyi/commander-wizard#readme",
+  "bugs": {
+    "url": "https://github.com/jaydenfyi/commander-wizard/issues"
+  },
+  "type": "module",
+  "packageManager": "nub@0.6.0",
+  "devEngines": {
+    "packageManager": {
+      "name": "nub",
+      "version": "^0.6.0",
+      "onFail": "warn"
+    }
+  },
+  "scripts": {
+    "start": "nub example.ts",
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "nub run build && tsc -p tsconfig.test.json && node --experimental-test-module-mocks --test dist-test/wizard.test.js",
+    "test:smoke": "expect wizard-smoke.test.tcl",
+    "prepack": "nub run build"
+  },
+  "devDependencies": {
+    "@types/node": "^26",
+    "commander": "^15.0.0",
+    "typescript": "^7"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.7.0"
+  },
+  "peerDependencies": {
+    "commander": "^14.0.0 || ^15.0.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.12.0"
+  }
+}