goke 6.9.0 → 6.10.0

package/dist/goke.js

@@ -13,6 +13,7 @@ import pc from './picocolors.js';
 import mri from "./mri.js";
 import { GokeError, coerceBySchema, extractJsonSchema, extractSchemaMetadata, isStandardSchema } from "./coerce.js";
 import { createJustBashCommand as createJustBashCommandBridge } from './just-bash.js';
+import { COMPLETION_FLAG, generateCompletionScript, installCompletions, uninstallCompletions, detectShell, detectCompletionShell, validateShell } from './completions.js';
 import { EventEmitter, fs as runtimeFs, openInBrowser, process } from '#runtime';
 // ─── Node.js platform constants ───
 const processArgs = process.argv;
@@ -322,9 +323,41 @@ class Command {
      * instance before `.command()` was called.
      */
     action(callback) {
+        // Give anonymous functions a name derived from the command so stack traces
+        // show e.g. "command:deploy" instead of "<anonymous>"
+        if (!callback.name) {
+            const label = this.name ? `command:${this.name}` : 'command:default';
+            Object.defineProperty(callback, 'name', { value: label });
+        }
         this.commandAction = callback;
         return this;
     }
+    /**
+     * Return the registered action callback with full type safety.
+     *
+     * Use this in tests to call the action directly without parsing argv.
+     * The returned function has the same typed signature as the `.action()` callback:
+     * `(..positionalArgs, options, executionContext) => unknown | Promise<unknown>`
+     *
+     * Throws if no action has been registered on this command.
+     *
+     * @example
+     * ```ts
+     * const cmd = cli
+     *   .command('deploy', 'Deploy')
+     *   .option('--env <env>', z.enum(['staging', 'production']))
+     *   .action((options, { console }) => console.log(options.env))
+     *
+     * const action = cmd.getAction()
+     * action({ env: 'staging', '--': [] }, cli.createExecutionContext({ stdout }))
+     * ```
+     */
+    getAction() {
+        if (!this.commandAction) {
+            throw new GokeError(`No action registered on command "${this.name || '(default)'}"`);
+        }
+        return this.commandAction;
+    }
     isMatched(args) {
         const nameParts = this.name.split(' ').filter(Boolean);
         if (nameParts.length === 0) {
@@ -937,6 +970,294 @@ class Goke extends EventEmitter {
             this.console.error(`\nRun "${cmdName}" for usage information.`);
         }
     }
+    /**
+     * Register shell completion commands: `completions install` and `completions uninstall`.
+     *
+     * Also wires the hidden `--get-goke-completions` flag that shell scripts call
+     * on each Tab press. When this flag is detected during `parse()`, the CLI
+     * prints matching completions to stdout and exits immediately.
+     *
+     * @example
+     * ```ts
+     * goke('mycli')
+     *   .help()
+     *   .completions()
+     *   .command('deploy', 'Deploy the app')
+     *   .parse(process.argv)
+     *
+     * // Then the user runs:
+     * //   mycli completions install
+     * //   mycli dep<TAB>  →  mycli deploy
+     * ```
+     */
+    completions() {
+        this.command('completions install', 'Install shell completions')
+            .option('--shell [shell]', 'Target shell (zsh or bash). Auto-detected if omitted.')
+            .action(async (options, { console, process: proc }) => {
+            const shell = validateShell(options.shell);
+            const cliPath = proc.argv[1] ?? this.name;
+            const result = await installCompletions(this.name, cliPath, shell);
+            console.log(`Wrote ${result.shell} completions to ${result.path}`);
+            if (result.shell === 'zsh') {
+                console.log('Restart your shell or run: autoload -Uz compinit && compinit');
+            }
+            else {
+                console.log('Restart your shell to enable completions.');
+            }
+        });
+        this.command('completions uninstall', 'Remove shell completions')
+            .option('--shell [shell]', 'Target shell (zsh or bash). Auto-detected if omitted.')
+            .action(async (options, { console }) => {
+            const shell = validateShell(options.shell);
+            const removed = await uninstallCompletions(this.name, shell);
+            if (removed.length > 0) {
+                for (const p of removed) {
+                    console.log(`Removed ${p}`);
+                }
+            }
+            else {
+                console.log('No completion files found to remove.');
+            }
+        });
+        this.command('completions script', 'Print the completion script to stdout')
+            .option('--shell [shell]', 'Target shell (zsh or bash). Auto-detected if omitted.')
+            .action((options, { console, process: proc }) => {
+            const shell = validateShell(options.shell) ?? detectShell();
+            if (!shell) {
+                throw new GokeError('Could not detect shell. Set the SHELL environment variable or pass --shell explicitly.');
+            }
+            const cliPath = proc.argv[1] ?? this.name;
+            const script = generateCompletionScript(shell, this.name, cliPath);
+            console.log(script);
+        });
+        return this;
+    }
+    /**
+     * Compute completions for the given args (as received from the shell script).
+     *
+     * Returns an array of completion strings. For zsh, each entry is `name:description`.
+     * For bash, each entry is just the name.
+     *
+     * @internal Used by parse() when --get-goke-completions is detected.
+     */
+    getCompletions(argv) {
+        // argv comes from the shell: ["my-cli", "dep", ""] or ["my-cli", "deploy", "--"]
+        // Strip the binary name (first element, which is the CLI name itself)
+        const args = argv.slice(1);
+        const current = args.length > 0 ? args[args.length - 1] : '';
+        const previous = args.slice(0, -1);
+        // Use GOKE_COMPLETION_SHELL (set by the shell shim) over $SHELL to avoid
+        // format mismatch when e.g. a bash shim runs on a machine where $SHELL is zsh.
+        const isZsh = detectCompletionShell() === 'zsh';
+        const completions = [];
+        const escapeColon = (s) => s.replace(/:/g, '\\:');
+        // Extract the long --flag from an option's rawName string.
+        // rawName is like "--dry-run", "-v, --verbose", "--port <port>"
+        // Returns the original kebab-case flag including dashes.
+        const getLongFlag = (option) => {
+            const parts = removeBrackets(option.rawName).split(',').map((s) => s.trim());
+            // Prefer the -- prefixed part; fall back to the last part (short-only flags like -x)
+            const longPart = parts.find((p) => p.startsWith('--')) ?? parts[parts.length - 1];
+            return longPart.startsWith('-') ? longPart : `--${longPart}`;
+        };
+        // Check if the previous token is a non-boolean option expecting a value.
+        // In that case we should NOT suggest more flags or commands; let the shell
+        // fall back to file completion or return nothing.
+        const isAwaitingOptionValue = () => {
+            if (previous.length === 0)
+                return false;
+            const lastToken = previous[previous.length - 1];
+            if (!lastToken.startsWith('-'))
+                return false;
+            // Find the option matching this token across all registered options
+            const allOptions = [
+                ...this.globalCommand.options,
+                ...this.commands.flatMap((c) => c.options),
+            ];
+            const tokenName = camelcaseOptionName(lastToken.replace(/^-{1,2}/, ''));
+            for (const option of allOptions) {
+                if (option.names.includes(tokenName)) {
+                    // If it takes a value (required or optional) and is not boolean, we're awaiting a value
+                    return !option.isBoolean && option.required !== undefined;
+                }
+            }
+            return false;
+        };
+        // If the previous token is a non-boolean option, don't suggest anything.
+        // Let the shell fall back to file completion.
+        if (!current.startsWith('-') && isAwaitingOptionValue()) {
+            return [];
+        }
+        // Helper to push an option as a completion entry
+        const pushOption = (option) => {
+            const flag = getLongFlag(option);
+            if (isZsh && option.description) {
+                completions.push(`${escapeColon(flag)}:${escapeColon(option.description)}`);
+            }
+            else {
+                completions.push(flag);
+            }
+        };
+        // Check if any alias of an option has already been used
+        const isOptionUsed = (option, usedOptions) => {
+            return option.names.some((name) => usedOptions.has(name));
+        };
+        // Try to match a command from the previous words
+        let matchedCommand;
+        let consumedArgs = 0;
+        // Sort by name length (longest first) for greedy matching
+        const sortedCommands = [...this.commands].sort((a, b) => {
+            const aLen = a.name.split(' ').filter(Boolean).length;
+            const bLen = b.name.split(' ').filter(Boolean).length;
+            return bLen - aLen;
+        });
+        for (const command of sortedCommands) {
+            const result = command.isMatched(previous);
+            if (result.matched) {
+                matchedCommand = command;
+                consumedArgs = result.consumedArgs;
+                break;
+            }
+        }
+        if (matchedCommand) {
+            // We matched a command, suggest its options
+            const usedOptions = new Set(previous.slice(consumedArgs)
+                .filter((a) => a.startsWith('-'))
+                .map((a) => a.replace(/^-{1,2}/, ''))
+                .map(camelcaseOptionName));
+            const allOptions = [...(matchedCommand.globalCommand?.options ?? []), ...matchedCommand.options];
+            for (const option of allOptions) {
+                if (option.deprecated)
+                    continue;
+                // Skip already-used options (check all aliases, not just the primary name)
+                if (option.isBoolean && isOptionUsed(option, usedOptions))
+                    continue;
+                const flag = getLongFlag(option);
+                if (current.startsWith('-')) {
+                    if (!flag.startsWith(current))
+                        continue;
+                }
+                else if (current !== '') {
+                    continue;
+                }
+                pushOption(option);
+            }
+            // If current word doesn't start with -, also suggest subcommands that extend this one
+            if (!current.startsWith('-')) {
+                const prefix = matchedCommand.name ? matchedCommand.name + ' ' : '';
+                for (const cmd of this.commands) {
+                    if (cmd._hidden)
+                        continue;
+                    if (cmd === matchedCommand)
+                        continue;
+                    if (cmd.name.startsWith(prefix) && cmd.name !== matchedCommand.name) {
+                        const sub = cmd.name.slice(prefix.length).split(' ')[0];
+                        if (sub.startsWith(current)) {
+                            if (isZsh) {
+                                const desc = cmd.description.split('\n')[0].trim();
+                                completions.push(desc ? `${escapeColon(sub)}:${escapeColon(desc)}` : sub);
+                            }
+                            else {
+                                completions.push(sub);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            // No command matched yet, suggest commands
+            // Check if some previous words partially match a multi-word command prefix
+            const prevJoined = previous.join(' ');
+            for (const command of this.commands) {
+                if (command._hidden)
+                    continue;
+                if (command.isDefaultCommand)
+                    continue;
+                const cmdName = command.name;
+                const cmdParts = cmdName.split(' ').filter(Boolean);
+                if (cmdParts.length === 0)
+                    continue;
+                // For single-word commands, just check prefix against current
+                if (cmdParts.length === 1) {
+                    if (previous.length === 0 && cmdParts[0].startsWith(current)) {
+                        if (isZsh) {
+                            const desc = command.description.split('\n')[0].trim();
+                            completions.push(desc ? `${escapeColon(cmdParts[0])}:${escapeColon(desc)}` : cmdParts[0]);
+                        }
+                        else {
+                            completions.push(cmdParts[0]);
+                        }
+                    }
+                    continue;
+                }
+                // Multi-word commands: check if previous matches the prefix parts
+                const matchPrefix = cmdParts.slice(0, -1).join(' ');
+                const lastPart = cmdParts[cmdParts.length - 1];
+                if (prevJoined === matchPrefix && lastPart.startsWith(current)) {
+                    if (isZsh) {
+                        const desc = command.description.split('\n')[0].trim();
+                        completions.push(desc ? `${escapeColon(lastPart)}:${escapeColon(desc)}` : lastPart);
+                    }
+                    else {
+                        completions.push(lastPart);
+                    }
+                }
+            }
+            // Also suggest first words of multi-word commands when at root level
+            if (previous.length === 0) {
+                const seenFirstWords = new Set();
+                for (const command of this.commands) {
+                    if (command._hidden || command.isDefaultCommand)
+                        continue;
+                    const firstWord = command.name.split(' ')[0];
+                    if (!firstWord || seenFirstWords.has(firstWord))
+                        continue;
+                    // Skip if already added as a single-word command above
+                    if (completions.some((c) => {
+                        const name = c.split(':')[0].replace(/\\:/g, ':');
+                        return name === firstWord;
+                    }))
+                        continue;
+                    seenFirstWords.add(firstWord);
+                    if (firstWord.startsWith(current)) {
+                        // For first words of multi-word commands, no description (it's a prefix, not a full command)
+                        completions.push(firstWord);
+                    }
+                }
+            }
+            // Also include default/root command options at root level
+            // (commands with name '' that have their own options)
+            const defaultCommands = this.commands.filter((c) => c.isDefaultCommand);
+            const defaultOptions = defaultCommands.flatMap((c) => c.options);
+            // Suggest global options + default command options when current starts with -
+            if (current.startsWith('-') || current === '') {
+                const globalAndDefaultOptions = [...this.globalCommand.options, ...defaultOptions];
+                const seen = new Set();
+                for (const option of globalAndDefaultOptions) {
+                    if (option.deprecated)
+                        continue;
+                    if (seen.has(option.name))
+                        continue;
+                    seen.add(option.name);
+                    const flag = getLongFlag(option);
+                    if (current.startsWith('-')) {
+                        if (!flag.startsWith(current))
+                            continue;
+                    }
+                    else if (current !== '') {
+                        continue;
+                    }
+                    // Only suggest options when current is - prefixed or empty and no commands matched
+                    if (current === '' && completions.length > 0 && !current.startsWith('-'))
+                        continue;
+                    pushOption(option);
+                }
+            }
+        }
+        // Deduplicate
+        return [...new Set(completions)];
+    }
     /**
      * Parse argv
      */
@@ -947,6 +1268,19 @@ class Goke extends EventEmitter {
         if (!this.name) {
             this.name = argv[1] ? getFileName(argv[1]) : 'cli';
         }
+        // Intercept --get-goke-completions before any command matching/validation.
+        // The shell completion script passes this flag on every Tab press.
+        const completionFlagIndex = argv.indexOf(`--${COMPLETION_FLAG}`);
+        if (completionFlagIndex !== -1) {
+            // Everything after the flag is the words typed so far
+            const completionArgs = argv.slice(completionFlagIndex + 1);
+            const completions = this.getCompletions(completionArgs);
+            for (const c of completions) {
+                this.stdout.write(c + '\n');
+            }
+            this.exit(0);
+            return { args: [], options: {} };
+        }
         let shouldParse = true;
         // Sort by name length (longest first) so "mcp login" matches before "mcp"
         const sortedCommands = [...this.commands].sort((a, b) => {
@@ -1294,5 +1628,149 @@ class Goke extends EventEmitter {
         }
     }
 }
-export { createConsole, Command, GokeProcessExit, openInBrowser };
+/**
+ * Generate markdown documentation pages for every command in a CLI.
+ *
+ * Returns one `DocPage` per non-hidden command, plus a root index page
+ * that lists all available commands. Each page includes an arguments table,
+ * options table, global options, and examples when available.
+ *
+ * @example
+ * ```ts
+ * import { goke, generateDocs } from 'goke'
+ * import fs from 'node:fs'
+ *
+ * const cli = goke('mycli')
+ *   .command('deploy <env>', 'Deploy to an environment')
+ *   .option('--force', 'Skip confirmation')
+ *
+ * const pages = generateDocs({ cli })
+ * for (const page of pages) {
+ *   fs.writeFileSync(`docs/${page.slug}.md`, page.content)
+ * }
+ * ```
+ */
+function generateDocs({ cli }) {
+    const pages = [];
+    // Collect global options (from globalCommand), excluding deprecated
+    const globalOptions = cli.globalCommand.options.filter((o) => !o.deprecated);
+    // Root index page listing all commands
+    const visibleCommands = cli.commands.filter((cmd) => !cmd._hidden);
+    if (visibleCommands.length > 0) {
+        const lines = [];
+        lines.push(`# ${cli.name}`);
+        lines.push('');
+        const { versionNumber } = cli.globalCommand;
+        if (versionNumber) {
+            lines.push(`Version: ${versionNumber}`);
+            lines.push('');
+        }
+        lines.push('## Commands');
+        lines.push('');
+        lines.push('| Command | Description |');
+        lines.push('|---------|-------------|');
+        for (const cmd of visibleCommands) {
+            if (cmd.isDefaultCommand)
+                continue;
+            const desc = cmd.description.split('\n')[0].trim();
+            const slug = cmd.name.replace(/\s+/g, '-');
+            lines.push(`| [\`${cmd.name}\`](./${slug}.md) | ${desc} |`);
+        }
+        lines.push('');
+        if (globalOptions.length > 0) {
+            lines.push('## Global Options');
+            lines.push('');
+            lines.push(formatOptionsTable(globalOptions));
+            lines.push('');
+        }
+        pages.push({ command: '', slug: 'index', content: lines.join('\n') });
+    }
+    // One page per command
+    for (const cmd of visibleCommands) {
+        if (cmd.isDefaultCommand)
+            continue;
+        const lines = [];
+        const title = cmd.name;
+        lines.push(`# ${title}`);
+        lines.push('');
+        if (cmd.description) {
+            lines.push(cmd.description);
+            lines.push('');
+        }
+        // Usage line
+        const usage = cmd.usageText || cmd.rawName;
+        lines.push('## Usage');
+        lines.push('');
+        lines.push('```sh');
+        lines.push(`${cli.name} ${usage}`);
+        lines.push('```');
+        lines.push('');
+        // Arguments table
+        if (cmd.args.length > 0) {
+            lines.push('## Arguments');
+            lines.push('');
+            lines.push('| Argument | Required | Description |');
+            lines.push('|----------|----------|-------------|');
+            for (const arg of cmd.args) {
+                const bracket = arg.required
+                    ? `<${arg.variadic ? '...' : ''}${arg.value}>`
+                    : `[${arg.variadic ? '...' : ''}${arg.value}]`;
+                const required = arg.required ? 'Yes' : 'No';
+                const desc = arg.variadic ? `${arg.value} (variadic)` : arg.value;
+                lines.push(`| \`${bracket}\` | ${required} | ${desc} |`);
+            }
+            lines.push('');
+        }
+        // Command-specific options
+        const cmdOptions = cmd.options.filter((o) => !o.deprecated);
+        if (cmdOptions.length > 0) {
+            lines.push('## Options');
+            lines.push('');
+            lines.push(formatOptionsTable(cmdOptions));
+            lines.push('');
+        }
+        // Global options section
+        if (globalOptions.length > 0) {
+            lines.push('## Global Options');
+            lines.push('');
+            lines.push(formatOptionsTable(globalOptions));
+            lines.push('');
+        }
+        // Examples
+        if (cmd.examples.length > 0) {
+            lines.push('## Examples');
+            lines.push('');
+            for (const example of cmd.examples) {
+                const text = typeof example === 'function' ? example(cli.name) : example;
+                // Auto-wrap in ```sh if not already fenced
+                if (text.trimStart().startsWith('```')) {
+                    lines.push(text);
+                }
+                else {
+                    lines.push('```sh');
+                    lines.push(text);
+                    lines.push('```');
+                }
+                lines.push('');
+            }
+        }
+        const slug = cmd.name.replace(/\s+/g, '-');
+        pages.push({ command: cmd.name, slug, content: lines.join('\n') });
+    }
+    return pages;
+}
+function formatOptionsTable(options) {
+    const lines = [];
+    lines.push('| Option | Default | Description |');
+    lines.push('|--------|---------|-------------|');
+    for (const opt of options) {
+        const defaultVal = opt.default !== undefined ? `\`${String(opt.default)}\`` : '-';
+        // Escape pipe characters in description for markdown tables
+        const desc = opt.description.replace(/\|/g, '\\|').replace(/\n/g, ' ');
+        lines.push(`| \`${opt.rawName}\` | ${defaultVal} | ${desc} |`);
+    }
+    return lines.join('\n');
+}
+export { createConsole, Command, GokeProcessExit, openInBrowser, generateDocs };
+export { generateCompletionScript, installCompletions, uninstallCompletions, detectShell, detectCompletionShell, validateShell };
 export default Goke;

package/dist/index.d.ts

@@ -6,10 +6,17 @@ import { Command } from "./goke.js";
  * @param options Configuration for stdout, stderr, and argv
  */
 declare const goke: (name?: string, options?: GokeOptions) => Goke<{}>;
+/**
+ * Vendored picocolors instance for terminal colors.
+ * Import this instead of installing picocolors, chalk, or any other color library.
+ */
+export declare const colors: import("./picocolors.js").PicoColors;
 export default goke;
 export { goke, Goke, Command };
-export { createConsole, GokeProcessExit, openInBrowser } from "./goke.js";
-export type { GokeOutputStream, GokeConsole, GokeExecutionContext, GokeExecutionContextOverride, GokeFs, GokeOptions, GokeProcess } from "./goke.js";
+export { createConsole, GokeProcessExit, openInBrowser, generateDocs, generateCompletionScript, installCompletions, uninstallCompletions, detectShell } from "./goke.js";
+export type { GokeOutputStream, GokeConsole, GokeExecutionContext, GokeExecutionContextOverride, GokeFs, GokeOptions, GokeProcess, DocPage, GenerateDocsOptions, ShellType } from "./goke.js";
 export type { StandardTypedV1, StandardJSONSchemaV1, JsonSchema } from "./coerce.js";
 export { GokeError, coerceBySchema, extractJsonSchema, wrapJsonSchema, isStandardSchema, extractSchemaMetadata } from "./coerce.js";
+export { detectAgent, agentInfo, agent, isAgent } from "./agents.js";
+export type { AgentName, AgentInfo } from "./agents.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAA;AAC5B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAEnC;;;GAGG;AACH,QAAA,MAAM,IAAI,GAAI,aAAS,EAAE,UAAU,WAAW,aAA4B,CAAA;AAE1E,eAAe,IAAI,CAAA;AACnB,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAA;AAC9B,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACzE,YAAY,EAAE,gBAAgB,EAAE,WAAW,EAAE,oBAAoB,EAAE,4BAA4B,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AACpJ,YAAY,EAAE,eAAe,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AACpF,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,iBAAiB,EAAE,cAAc,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAA;AAC5B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAGnC;;;GAGG;AACH,QAAA,MAAM,IAAI,GAAI,aAAS,EAAE,UAAU,WAAW,aAA4B,CAAA;AAE1E;;;GAGG;AACH,eAAO,MAAM,MAAM,sCAAK,CAAA;AAExB,eAAe,IAAI,CAAA;AACnB,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAA;AAC9B,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,aAAa,EAAE,YAAY,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AACxK,YAAY,EAAE,gBAAgB,EAAE,WAAW,EAAE,oBAAoB,EAAE,4BAA4B,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,OAAO,EAAE,mBAAmB,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAC7L,YAAY,EAAE,eAAe,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AACpF,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,iBAAiB,EAAE,cAAc,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AACnI,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AACpE,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA"}

package/dist/index.js

@@ -1,11 +1,18 @@
 import Goke from "./goke.js";
 import { Command } from "./goke.js";
+import pc from "./picocolors.js";
 /**
  * @param name The program name to display in help and version message
  * @param options Configuration for stdout, stderr, and argv
  */
 const goke = (name = '', options) => new Goke(name, options);
+/**
+ * Vendored picocolors instance for terminal colors.
+ * Import this instead of installing picocolors, chalk, or any other color library.
+ */
+export const colors = pc;
 export default goke;
 export { goke, Goke, Command };
-export { createConsole, GokeProcessExit, openInBrowser } from "./goke.js";
+export { createConsole, GokeProcessExit, openInBrowser, generateDocs, generateCompletionScript, installCompletions, uninstallCompletions, detectShell } from "./goke.js";
 export { GokeError, coerceBySchema, extractJsonSchema, wrapJsonSchema, isStandardSchema, extractSchemaMetadata } from "./coerce.js";
+export { detectAgent, agentInfo, agent, isAgent } from "./agents.js";

package/dist/runtime-browser.d.ts

@@ -30,6 +30,6 @@ declare const process: {
     exit(code: number): never;
 };
 declare const fs: GokeFs;
-declare function openInBrowser(_url: string): void;
+declare function openInBrowser(_url: string): Promise<void>;
 export { EventEmitter, fs, openInBrowser, process };
 //# sourceMappingURL=runtime-browser.d.ts.map

package/dist/runtime-browser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-browser.d.ts","sourceRoot":"","sources":["../src/runtime-browser.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAE1C,KAAK,QAAQ,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAA;AAExC,cAAM,YAAY;;IAGhB,EAAE,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,QAAQ;IAOjD,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE;IAS/C,UAAU;IAIV,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;CAGrC;AAQD,QAAA,MAAM,OAAO;UACC,MAAM,EAAE;;;SAKQ,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;;;;;;qBATjD,MAAM;;;;;qBAAN,MAAM;;eAcR,MAAM,GAAG,KAAK;CAK1B,CAAA;AAcD,QAAA,MAAM,EAAE,EAAE,MAcT,CAAA;AAED,iBAAS,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAEzC;AAED,OAAO,EAAE,YAAY,EAAE,EAAE,EAAE,aAAa,EAAE,OAAO,EAAE,CAAA"}
+{"version":3,"file":"runtime-browser.d.ts","sourceRoot":"","sources":["../src/runtime-browser.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAE1C,KAAK,QAAQ,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAA;AAExC,cAAM,YAAY;;IAGhB,EAAE,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,QAAQ;IAOjD,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE;IAS/C,UAAU;IAIV,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;CAGrC;AAQD,QAAA,MAAM,OAAO;UACC,MAAM,EAAE;;;SAKQ,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;;;;;;qBATjD,MAAM;;;;;qBAAN,MAAM;;eAcR,MAAM,GAAG,KAAK;CAK1B,CAAA;AAcD,QAAA,MAAM,EAAE,EAAE,MAcT,CAAA;AAED,iBAAe,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAExD;AAED,OAAO,EAAE,YAAY,EAAE,EAAE,EAAE,aAAa,EAAE,OAAO,EAAE,CAAA"}

package/dist/runtime-browser.js

@@ -68,7 +68,7 @@ const fs = {
     utimes: createUnsupportedFsMethod('utimes'),
     writeFile: createUnsupportedFsMethod('writeFile'),
 };
-function openInBrowser(_url) {
+async function openInBrowser(_url) {
     // Browser builds should decide how to surface URLs themselves.
 }
 export { EventEmitter, fs, openInBrowser, process };

package/dist/runtime-node.d.ts

@@ -5,6 +5,6 @@ import { EventEmitter } from 'events';
 import type { GokeFs } from './goke-fs.js';
 declare const process: NodeJS.Process;
 declare const fs: GokeFs;
-declare function openInBrowser(url: string): void;
+declare function openInBrowser(url: string): Promise<void>;
 export { EventEmitter, fs, openInBrowser, process };
 //# sourceMappingURL=runtime-node.d.ts.map

package/dist/runtime-node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-node.d.ts","sourceRoot":"","sources":["../src/runtime-node.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAErC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAE1C,QAAA,MAAM,OAAO,gBAAqB,CAAA;AAClC,QAAA,MAAM,EAAE,EAAE,MAAe,CAAA;AAEzB,iBAAS,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAiBxC;AAED,OAAO,EAAE,YAAY,EAAE,EAAE,EAAE,aAAa,EAAE,OAAO,EAAE,CAAA"}
+{"version":3,"file":"runtime-node.d.ts","sourceRoot":"","sources":["../src/runtime-node.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAErC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAE1C,QAAA,MAAM,OAAO,gBAAqB,CAAA;AAClC,QAAA,MAAM,EAAE,EAAE,MAAe,CAAA;AAEzB,iBAAe,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAyBvD;AAED,OAAO,EAAE,YAAY,EAAE,EAAE,EAAE,aAAa,EAAE,OAAO,EAAE,CAAA"}

package/dist/runtime-node.js

@@ -1,29 +1,38 @@
 /**
  * Node.js runtime bindings for goke core.
  */
-import { execSync } from 'child_process';
+import { exec } from 'child_process';
 import { EventEmitter } from 'events';
 import * as nodeFs from 'node:fs/promises';
 const process = globalThis.process;
 const fs = nodeFs;
-function openInBrowser(url) {
+async function openInBrowser(url) {
     if (!process.stdout.isTTY) {
-        process.stdout.write(url + '\n');
+        process.stderr.write(url + '\n');
         return;
     }
+    let cmd;
+    if (process.platform === 'darwin') {
+        cmd = `open ${JSON.stringify(url)}`;
+    }
+    else if (process.platform === 'win32') {
+        cmd = `start "" ${JSON.stringify(url)}`;
+    }
+    else {
+        cmd = `xdg-open ${JSON.stringify(url)}`;
+    }
     try {
-        if (process.platform === 'darwin') {
-            execSync(`open ${JSON.stringify(url)}`, { stdio: 'ignore' });
-        }
-        else if (process.platform === 'win32') {
-            execSync(`start "" ${JSON.stringify(url)}`, { stdio: 'ignore' });
-        }
-        else {
-            execSync(`xdg-open ${JSON.stringify(url)}`, { stdio: 'ignore' });
-        }
+        await new Promise((resolve, reject) => {
+            exec(cmd, { stdio: 'ignore' }, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
     }
     catch {
-        process.stdout.write(url + '\n');
+        process.stderr.write(url + '\n');
     }
 }
 export { EventEmitter, fs, openInBrowser, process };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goke",
-  "version": "6.9.0",
+  "version": "6.10.0",
   "type": "module",
   "description": "Simple yet powerful framework for building command-line apps. Inspired by cac.",
   "repository": {