@visulima/cerebro 3.0.0-alpha.11 → 3.0.0-alpha.13

package/dist/plugins/update-notifier/has-new-version.d.ts

@@ -1,14 +0,0 @@
-declare const hasNewVersion: ({ alwaysRun, debug, distTag: distributionTag, pkg, registryUrl, updateCheckInterval, }: UpdateNotifierOptions) => Promise<string | undefined>;
-export type UpdateNotifierOptions = {
-    alwaysRun?: boolean;
-    debug?: boolean;
-    distTag?: string;
-    pkg: {
-        name: string;
-        version: string;
-    };
-    registryUrl?: string;
-    shouldNotifyInNpmScript?: boolean;
-    updateCheckInterval?: number;
-};
-export default hasNewVersion;

package/dist/types/cli.d.ts

@@ -1,113 +0,0 @@
-import type PluginManager from "../plugin-manager.d.ts";
-import type { Command as ICommand, OptionDefinition } from "./command.d.ts";
-import type { Plugin } from "./plugin.d.ts";
-export type CommandSection = {
-    footer?: string;
-    header?: string;
-};
-export type CliRunOptions = {
-    [key: string]: unknown;
-    /**
-     * Whether to automatically dispose/cleanup the CLI instance after execution
-     * @default true
-     */
-    autoDispose?: boolean;
-    shouldExitProcess?: boolean;
-};
-export type RunCommandOptions = {
-    /**
-     * Extra options to merge into the command's options.
-     * These will be merged with the command's default options and parsed arguments.
-     * Use this to override or add additional options programmatically.
-     * @default Empty object
-     */
-    [key: string]: unknown;
-    /**
-     * Command-line arguments to pass to the command.
-     * If not provided, uses the default argv from the CLI instance.
-     * These arguments will be parsed and merged with the command's options.
-     * @default Empty array
-     */
-    argv?: string[];
-};
-export interface Cli<T extends Console> {
-    /**
-     * Add an arbitrary command to the CLI.
-     * @param command The command to add.
-     * @returns self
-     */
-    addCommand: <OD extends OptionDefinition<unknown> = OptionDefinition<unknown>>(command: ICommand<OD, T>) => this;
-    /**
-     * Add a global option available to all commands.
-     * Global options are parsed alongside command options and shown in help output.
-     * @param option The option definition
-     * @returns self
-     */
-    addGlobalOption: <V = unknown>(option: OptionDefinition<V>) => this;
-    /**
-     * Add a plugin to extend the CLI functionality
-     * @param plugin The plugin to add.
-     * @returns self
-     */
-    addPlugin: (plugin: Plugin<T>) => this;
-    /**
-     * Disposes the CLI instance and cleans up resources
-     * @returns void
-     */
-    dispose: () => void;
-    getCliName: () => string;
-    getCommands: () => Map<string, ICommand<OptionDefinition<unknown>, T>>;
-    getCommandSection: () => CommandSection;
-    getCwd: () => string;
-    /**
-     * Gets all global options (built-in + custom).
-     */
-    getGlobalOptions: () => OptionDefinition<unknown>[];
-    getPackageName: () => string | undefined;
-    getPackageVersion: () => string | undefined;
-    /**
-     * Get the plugin manager instance
-     * @returns The plugin manager
-     */
-    getPluginManager: () => PluginManager<T>;
-    run: (extraOptions?: CliRunOptions) => Promise<void>;
-    /**
-     * Runs a command programmatically from within another command.
-     * This allows commands to call other commands during execution.
-     * @param commandName The name of the command to execute
-     * @param options Optional options including argv and other command options
-     * @returns A promise that resolves with the command's result (or void if command doesn't return a value)
-     * @throws {Error} If the specified command doesn't exist or command arguments are invalid
-     * @example
-     * ```typescript
-     * cli.addCommand({
-     *   name: 'deploy',
-     *   execute: async ({ runtime, logger }) => {
-     *     logger.info('Building...');
-     *     const buildResult = await runtime.runCommand('build', { argv: ['--production'] });
-     *     // buildResult is the return value from the build command's execute function
-     *
-     *     logger.info('Testing...');
-     *     await runtime.runCommand('test', { argv: ['--coverage'] });
-     *   }
-     * });
-     * ```
-     */
-    runCommand: (commandName: string, options?: RunCommandOptions) => Promise<unknown>;
-    setCommandSection: (commandSection: CommandSection) => this;
-    /**
-     * Set a default command, to display a different command if cli is call without command.
-     * @param commandName
-     * @returns self
-     */
-    setDefaultCommand: (commandName: string) => this;
-}
-/**
- * Any of the output types [[OUTPUT_NORMAL]], [[OUTPUT_RAW]] and [[OUTPUT_PLAIN]].
- */
-export type OutputType = 1 | 2 | 4;
-/**
- * Any of the verbosity types
- * [[VERBOSITY_QUIET]], [[VERBOSITY_NORMAL]], [[VERBOSITY_VERBOSE]] and [[VERBOSITY_DEBUG]].
- */
-export type VERBOSITY_LEVEL = 16 | 32 | 64 | 128 | 256;

package/dist/types/command-line-usage.d.ts

@@ -1,37 +0,0 @@
-import type { TableOptions } from "@visulima/tabular";
-import type { ArgumentDefinition, OptionDefinition } from "./command.d.ts";
-/** A Content section comprises a header and one or more lines of content. */
-export interface Content {
-    /**
-     * Overloaded property, accepting data in one of four formats.
-     * 1. A single string (one line of text).
-     * 2. An array of strings (multiple lines of text).
-     * 3. An array of arrays (recordset-style data). In this case, the data will be rendered in table format.
-     * 4. An object with two properties - data and options. In this case, the data and options will be passed directly to the underlying table module for rendering.
-     */
-    content?: string[] | string[][] | string | {
-        data: string[][];
-        options: TableOptions;
-    };
-    /** The section header, always bold and underlined. */
-    header?: string;
-    /** Set to true to avoid indentation and wrapping. Useful for banners. */
-    raw?: boolean;
-}
-/** A OptionList section adds a table displaying details of the available options. */
-export interface OptionList<O extends OptionDefinition<any> = any> {
-    /** If specified, only options from this particular group will be printed.  */
-    group?: string[] | string;
-    header?: string;
-    /** The names of one of more option definitions to hide from the option list.  */
-    hide?: string[] | string;
-    /** If specified, the -- prefix will be omitted from the option name. */
-    isArgument?: boolean;
-    /** An array of option definition objects. */
-    optionList?: (ArgumentDefinition | O | OptionDefinition<boolean[]> | OptionDefinition<boolean> | OptionDefinition<number[]> | OptionDefinition<number> | OptionDefinition<string[]> | OptionDefinition<string>)[];
-    /** If true, the option alias will be displayed after the name, i.e. --verbose, -v instead of -v, --verbose). */
-    reverseNameOrder?: boolean;
-    /** An options object suitable for passing into table. */
-    tableOptions?: TableOptions;
-}
-export type Section = Content | OptionList;

package/dist/types/command.d.ts

@@ -1,136 +0,0 @@
-import type { OptionDefinition as BaseOptionDefinition } from "@visulima/command-line-args";
-import type { Content } from "./command-line-usage.d.ts";
-import type { Toolbox as IToolbox } from "./toolbox.d.ts";
-type TypeConstructor<T> = (value: unknown) => T extends (infer R)[] ? R | undefined : T | undefined;
-/**
- * Type constructor for environment variables.
- * Environment variables are always strings (or undefined), so the transform function receives string | undefined.
- */
-type EnvTypeConstructor<T> = (value: string | undefined) => T extends (infer R)[] ? R | undefined : T | undefined;
-type MultiplePropertyOptions<T> = T extends ReadonlyArray<unknown> ? {
-    lazyMultiple: true;
-} | {
-    multiple: true;
-} : unknown;
-export type OptionDefinition<T> = MultiplePropertyOptions<T> & Omit<BaseOptionDefinition, "type|defaultValue"> & {
-    __camelCaseName__?: string;
-    __negated__?: true;
-    /**
-     * A string or array of strings indicating the conflicting option(s).
-     * Note: The default value for an option does not cause a conflict.
-     */
-    conflicts?: string[] | string;
-    /** An initial value for the option. */
-    defaultValue?: T;
-    /** A string describing the option. */
-    description?: string;
-    /** Option is hidden from help */
-    hidden?: boolean;
-    implies?: Record<string, unknown>;
-    /** Specifies whether the variable is required. */
-    required?: boolean;
-    /**
-     * A setter function (you receive the output from this) enabling you to be specific about the type and value received. Typical values
-     * are `String`, `Number` and `Boolean` but you can use a custom function.
-     */
-    type?: TypeConstructor<T>;
-    /** A string to replace the default type string (e.g. &lt;string>). It's often more useful to set a more descriptive type label, like &lt;ms>, &lt;files>, &lt;command>, etc.. */
-    typeLabel?: string;
-};
-export type PossibleOptionDefinition<OD> = OD | OptionDefinition<boolean[]> | OptionDefinition<boolean> | OptionDefinition<number[]> | OptionDefinition<number> | OptionDefinition<string[]> | OptionDefinition<string>;
-export type ArgumentDefinition<T = unknown> = Omit<OptionDefinition<T>, "multiple|lazyMultiple|defaultOption|alias|group|defaultValue">;
-/**
- * Environment variable definition for commands.
- * Used to document and provide type-safe access to environment variables a command supports.
- * @template T The type of the environment variable value
- */
-export interface EnvDefinition<T = string> {
-    /** Default value if the environment variable is not set */
-    defaultValue?: T;
-    /** A description of what the environment variable does */
-    description?: string;
-    /** Environment variable is hidden from help */
-    hidden?: boolean;
-    /** The name of the environment variable */
-    name: string;
-    /**
-     * A transform function to convert the string environment variable value to the desired type.
-     * Typical values are `String`, `Number`, `Boolean` or custom functions.
-     * The function receives `string | undefined` and should return the transformed value.
-     */
-    type?: EnvTypeConstructor<T>;
-    /** A string to replace the default type string (e.g. &lt;string>). Useful for more descriptive type labels. */
-    typeLabel?: string;
-}
-export type PossibleEnvDefinition = EnvDefinition<boolean> | EnvDefinition<number> | EnvDefinition;
-/**
- * Command interface with type-safe options and environment variables.
- * @template O - The option definition type
- * @template TContext - The toolbox context type (allows custom typing for better autocomplete)
- * @example
- * ```typescript
- * // Define your options type for autocomplete
- * type BuildOptions = {
- *   output?: string;
- *   production?: boolean;
- *   watch?: boolean;
- * };
- *
- * type BuildEnv = {
- *   apiKey?: string;
- *   debug?: boolean;
- * };
- *
- * cli.addCommand({
- *   name: "build",
- *   options: [
- *     { name: "output", type: String, alias: "o" },
- *     { name: "production", type: Boolean },
- *     { name: "watch", type: Boolean }
- *   ],
- *   env: [
- *     { name: "API_KEY", type: String },
- *     { name: "DEBUG", type: Boolean }
- *   ],
- *   execute: ({ options, env }: Toolbox<Console, BuildOptions, BuildEnv>) => {
- *     // Full autocomplete on options and env!
- *     console.log(options.output, options.production, env.apiKey);
- *   }
- * });
- * ```
- */
-export interface Command<O extends OptionDefinition<unknown> = OptionDefinition<unknown>, TLogger extends Console = Console, TContext extends IToolbox<TLogger> = IToolbox<TLogger>> {
-    /**
-     * @internal
-     */
-    __conflictingOptions__?: PossibleOptionDefinition<O>[];
-    /**
-     * @internal
-     */
-    __requiredOptions__?: PossibleOptionDefinition<O>[];
-    /** Potential other names for this command */
-    alias?: string[] | string;
-    /** Positional argument */
-    argument?: ArgumentDefinition;
-    /** The command path, an array that describes how to get to this command */
-    commandPath?: string[];
-    /** A tweet-sized summary of your command */
-    description?: string;
-    /** Environment variables supported by this command */
-    env?: (EnvDefinition<boolean> | EnvDefinition<number> | EnvDefinition)[];
-    /** The full command examples, can be multiple lines */
-    examples?: string[] | string[][];
-    /** The function for running your command, can be async */
-    execute: ((toolbox: TContext) => Promise<void>) | ((toolbox: TContext) => void);
-    /** The path to the file name for this command. */
-    file?: string;
-    /** Group commands together under a heading */
-    group?: string;
-    /** Should your command be shown in the listings  */
-    hidden?: boolean;
-    /** The name of your command */
-    name: string;
-    options?: (O | OptionDefinition<boolean[]> | OptionDefinition<boolean> | OptionDefinition<number[]> | OptionDefinition<number> | OptionDefinition<string[]> | OptionDefinition<string>)[];
-    usage?: Content[];
-}
-export {};

package/dist/types/option-types.d.ts

@@ -1,83 +0,0 @@
-/**
- * Helper types for creating type-safe commands with autocomplete support.
- * These types help you define your options and environment variables with full TypeScript autocomplete.
- * Use these types to create type-safe Toolbox interfaces for your commands.
- * @example
- * ```typescript
- * import { CreateOptions, CreateEnv, type Toolbox } from '@visulima/cerebro';
- *
- * // Define options with their original names (they'll be converted to camelCase)
- * type BuildOptions = CreateOptions<{
- *   "output-dir": string | undefined;
- *   "verbose": boolean | undefined;
- *   "port": number | undefined;
- * }>;
- * // Result: { outputDir: string | undefined, verbose: boolean | undefined, port: number | undefined }
- *
- * // Define environment variables (UPPER_SNAKE_CASE -> camelCase)
- * type BuildEnv = CreateEnv<{
- *   "API_KEY": string | undefined;
- *   "DEBUG": boolean | undefined;
- * }>;
- * // Result: { apiKey: string | undefined, debug: boolean | undefined }
- *
- * // Use in your command
- * cli.addCommand({
- *   name: "build",
- *   options: [
- *     { name: "output-dir", type: String },
- *     { name: "verbose", type: Boolean },
- *     { name: "port", type: Number }
- *   ],
- *   env: [
- *     { name: "API_KEY", type: String },
- *     { name: "DEBUG", type: Boolean }
- *   ],
- *   execute: ({ options, env }: Toolbox<Console, BuildOptions, BuildEnv>) => {
- *     // Full autocomplete on options.outputDir, options.verbose, env.apiKey, etc.
- *     console.log(options.outputDir, options.verbose, env.apiKey);
- *   }
- * });
- * ```
- */
-/**
- * Converts option names to camelCase for the options object.
- * Options like "output-dir" become "outputDir" in the toolbox.
- * @example
- * ```typescript
- * // Option name: "output-dir" -> options.outputDir
- * // Option name: "api_key" -> options.apiKey
- * // Option name: "verbose" -> options.verbose
- * ```
- */
-export type OptionNameToCamelCase<T extends string> = T extends `${infer Start}-${infer Rest}` ? `${Lowercase<Start>}${Capitalize<OptionNameToCamelCase<Rest>>}` : T extends `${infer Start}_${infer Rest}` ? `${Lowercase<Start>}${Capitalize<OptionNameToCamelCase<Rest>>}` : Lowercase<T>;
-/**
- * Helper type to create a type-safe options object from option definitions.
- * @example
- * ```typescript
- * type MyOptions = CreateOptions<{
- *   "output-dir": string | undefined;
- *   "verbose": boolean | undefined;
- *   "port": number | undefined;
- * }>;
- * // Result: { outputDir: string | undefined, verbose: boolean | undefined, port: number | undefined }
- * ```
- */
-export type CreateOptions<T extends Record<string, unknown>> = {
-    [K in keyof T as OptionNameToCamelCase<K & string>]: T[K];
-};
-/**
- * Helper type to create a type-safe environment variables object from env definitions.
- * Environment variable names are converted from UPPER_SNAKE_CASE to camelCase.
- * @example
- * ```typescript
- * type MyEnv = CreateEnv<{
- *   "API_KEY": string | undefined;
- *   "DEBUG": boolean | undefined;
- * }>;
- * // Result: { apiKey: string | undefined, debug: boolean | undefined }
- * ```
- */
-export type CreateEnv<T extends Record<string, unknown>> = {
-    [K in keyof T as OptionNameToCamelCase<K & string>]: T[K];
-};

package/dist/types/options.d.ts

@@ -1,4 +0,0 @@
-/**
- * A flexible object for the many "options" objects we throw around in cerebro.
- */
-export type Options = Record<string | symbol, unknown>;

package/dist/types/plugin.d.ts

@@ -1,53 +0,0 @@
-import type { Cli } from "./cli.d.ts";
-import type { Toolbox } from "./toolbox.d.ts";
-/**
- * Context provided to plugins during initialization
- */
-export interface PluginContext<T extends Console = Console> {
-    /** The CLI instance */
-    cli: Cli<T>;
-    /** Current working directory */
-    cwd: string;
-    /** Logger instance */
-    logger: T;
-}
-/**
- * Plugin interface with lifecycle hooks
- */
-export interface Plugin<T extends Console = Console> {
-    /**
-     * Called after command execution completes successfully
-     * @param toolbox The command toolbox
-     * @param result The result returned by the command
-     */
-    afterCommand?: (toolbox: Toolbox<T>, result: unknown) => Promise<void> | void;
-    /**
-     * Called before command execution
-     * @param toolbox The command toolbox
-     */
-    beforeCommand?: (toolbox: Toolbox<T>) => Promise<void> | void;
-    /** Plugin dependencies (other plugin names that must be loaded first) */
-    dependencies?: string[];
-    /** Plugin description */
-    description?: string;
-    /**
-     * Called during command execution (for plugins that extend toolbox functionality)
-     * @param toolbox The command toolbox
-     */
-    execute?: (toolbox: Toolbox<T>) => Promise<void> | void;
-    /**
-     * Called once during plugin initialization
-     * @param context The plugin context
-     */
-    init?: (context: PluginContext<T>) => Promise<void> | void;
-    /** Plugin name (must be unique) */
-    name: string;
-    /**
-     * Called when an error occurs during command execution
-     * @param error The error that occurred
-     * @param toolbox The command toolbox
-     */
-    onError?: (error: Error, toolbox: Toolbox<T>) => Promise<void> | void;
-    /** Plugin version */
-    version?: string;
-}

package/dist/types/toolbox.d.ts

@@ -1,120 +0,0 @@
-import type { Cli as ICli } from "./cli.d.ts";
-import type { Command as ICommand } from "./command.d.ts";
-import type { Options } from "./options.d.ts";
-/**
- * Type-safe Toolbox interface with customizable options and environment variable types.
- * @template TLogger - The logger type (defaults to Console)
- * @template TOptions - The options type (defaults to Options/Record<string, unknown>)
- * @template TEnv - The environment variables type (defaults to Record<string, unknown>)
- */
-export interface Toolbox<TLogger extends Console = Console, TOptions extends Record<string, unknown> = Options, TEnv extends Record<string, unknown> = Record<string, unknown>> extends Cerebro.ExtensionOverrides {
-    /**
-     * The argument passed to the command.
-     * For example, if you run `cerebro foo bar baz`, then this will be `["foo", "bar", "baz"]`.
-     * @example
-     * ```typescript
-     * cli.addCommand({
-     *   name: "copy",
-     *   argument: {
-     *     name: "files",
-     *     type: String,
-     *     description: "Files to copy"
-     *   },
-     *   execute: ({ argument }) => {
-     *     // argument is an array of strings
-     *     // argument[0] is the first file, argument[1] is the second, etc.
-     *     argument.forEach((file) => console.log(`Copying ${file}...`));
-     *   }
-     * });
-     * ```
-     */
-    argument: string[];
-    argv: ReadonlyArray<string>;
-    /**
-     * The command that is being executed.
-     */
-    command: ICommand;
-    /**
-     * The name of the command that is being executed.
-     */
-    commandName: string;
-    /**
-     * Environment variables processed from the command definition.
-     * Values are transformed according to their type definitions and default values.
-     * @example
-     * ```typescript
-     * // Define env types when creating command
-     * type MyEnv = { apiKey: string; debug: boolean };
-     *
-     * cli.addCommand({
-     *   name: "build",
-     *   env: [
-     *     { name: "API_KEY", type: String },
-     *     { name: "DEBUG", type: Boolean }
-     *   ],
-     *   execute: ({ env }) => {
-     *     // env.apiKey and env.debug are now typed!
-     *     console.log(env.apiKey, env.debug);
-     *   }
-     * });
-     * ```
-     */
-    env: TEnv;
-    /** The logger instance. */
-    logger: TLogger;
-    /**
-     * Any optional parameters. Typically coming from command-line
-     * argument like this: `--force -p tsconfig-mjson`.
-     * @example
-     * ```typescript
-     * // Define options type for better autocomplete
-     * type MyOptions = {
-     *   output?: string;
-     *   verbose?: boolean;
-     *   port?: number;
-     * };
-     *
-     * cli.addCommand({
-     *   name: "serve",
-     *   options: [
-     *     { name: "output", type: String },
-     *     { name: "verbose", type: Boolean },
-     *     { name: "port", type: Number }
-     *   ],
-     *   execute: ({ options }: { options: MyOptions }) => {
-     *     // options.output, options.verbose, options.port are typed!
-     *     console.log(options.output, options.verbose, options.port);
-     *   }
-     * });
-     * ```
-     */
-    options: TOptions;
-    /**
-     * Raw tokens that command-line-args could not assign to a defined
-     * option — typically everything after a `--` separator, since
-     * cerebro runs the parser with `stopAtFirstUnknown: true`.
-     *
-     * Use this for passthrough patterns like
-     * `my-cmd foo bar -- --flag=value --other`, where everything after
-     * `--` is forwarded to an inner tool (`create-vite`, a template
-     * runner, etc.). Empty array when there was no `--` segment.
-     * @example
-     * ```typescript
-     * cli.addCommand({
-     *   name: "create",
-     *   argument: { name: "template", type: String },
-     *   execute: ({ argument, rawUnknown }) => {
-     *     // `vis create vite my-app -- --template react-ts`
-     *     // → argument === ["vite", "my-app"]
-     *     // → rawUnknown === ["--template", "react-ts"]
-     *     spawnSync("npm", ["create", "vite", ...rawUnknown]);
-     *   },
-     * });
-     * ```
-     */
-    rawUnknown: ReadonlyArray<string>;
-    /**
-     * This is the instance of the CLI that is running the command.
-     */
-    runtime: ICli<TLogger>;
-}

package/dist/util/arg-processing/get-boolean-values.d.ts

@@ -1,7 +0,0 @@
-import type { OptionDefinition, PossibleOptionDefinition } from "../../types/command.d.ts";
-/**
- * Gets the values of any boolean arguments that were specified on the command line with a value.
- * These arguments were removed by removeBooleanValues.
- */
-declare const getBooleanValues: <OD extends OptionDefinition<unknown>>(arguments_: string[], options: PossibleOptionDefinition<OD>[], optionMapByName?: Map<string, PossibleOptionDefinition<OD>>, optionMapByAlias?: Map<string, PossibleOptionDefinition<OD>>) => Partial<OD>;
-export default getBooleanValues;

package/dist/util/arg-processing/get-parameter-option.d.ts

@@ -1,7 +0,0 @@
-import type { OptionDefinition, PossibleOptionDefinition } from "../../types/command.d.ts";
-declare const getParameterOption: <OD extends OptionDefinition<unknown>>(argument: string, options: PossibleOptionDefinition<OD>[], optionMapByName?: Map<string, PossibleOptionDefinition<OD>>, optionMapByAlias?: Map<string, PossibleOptionDefinition<OD>>) => {
-    argName?: string;
-    argValue?: string;
-    option?: PossibleOptionDefinition<OD>;
-};
-export default getParameterOption;

package/dist/util/arg-processing/map-option-type-label.d.ts

@@ -1,3 +0,0 @@
-import type { OptionDefinition, PossibleOptionDefinition } from "../../types/command.d.ts";
-declare const mapOptionTypeLabel: <OD extends OptionDefinition<any>>(definition: PossibleOptionDefinition<OD>) => PossibleOptionDefinition<OD>;
-export default mapOptionTypeLabel;

package/dist/util/arg-processing/option-is-boolean.d.ts

@@ -1,9 +0,0 @@
-import type { OptionDefinition, PossibleOptionDefinition } from "../../types/command.d.ts";
-/**
- * Determines whether an option definition is typed as Boolean.
- * @template OD
- * @param option Option definition to inspect.
- * @returns True when the option's type constructor is the built-in `Boolean`.
- */
-declare const optionIsBoolean: <OD extends OptionDefinition<unknown>>(option: PossibleOptionDefinition<OD>) => boolean;
-export default optionIsBoolean;

package/dist/util/arg-processing/remove-boolean-values.d.ts

@@ -1,9 +0,0 @@
-import type { OptionDefinition, PossibleOptionDefinition } from "../../types/command.d.ts";
-/**
- * Removes boolean values from arguments to prevent commandLineArgs errors.
- * commandLineArgs throws an error if we pass a value for a boolean arg as follows:
- * myCommand -a=true --booleanArg=false --otherArg true
- * This function removes these booleans to avoid errors from commandLineArgs.
- */
-declare const removeBooleanValues: <OD extends OptionDefinition<any>>(arguments_: string[], options: PossibleOptionDefinition<OD>[], optionMapByName?: Map<string, PossibleOptionDefinition<OD>>, optionMapByAlias?: Map<string, PossibleOptionDefinition<OD>>) => string[];
-export default removeBooleanValues;

package/dist/util/command-line-commands.d.ts

@@ -1,10 +0,0 @@
-/**
- * Copied from
- * The MIT License (MIT)
- * Copyright (c) 2015-21 Lloyd Brookes <75pound@gmail.com>
- */
-declare const commandLineCommands: (commands: (string | null)[], argv: string[]) => {
-    argv: string[];
-    command: string | null;
-};
-export default commandLineCommands;

package/dist/util/command-line-usage/get-terminal-width.d.ts

@@ -1,7 +0,0 @@
-/**
- * Gets the terminal width from the CEREBRO_TERMINAL_WIDTH environment variable.
- * Falls back to undefined if not set, allowing the tabular package to detect it automatically.
- * @returns The terminal width as a number, or undefined if not set
- */
-declare const getTerminalWidth: () => number | undefined;
-export default getTerminalWidth;

package/dist/util/command-line-usage/index.d.ts

@@ -1,3 +0,0 @@
-import type { Section as ISection } from "../../types/command-line-usage.d.ts";
-declare const commandLineUsage: (sections: ISection[]) => string;
-export default commandLineUsage;

package/dist/util/command-line-usage/section/base-section.d.ts

@@ -1,8 +0,0 @@
-declare class BaseSection {
-    protected lines: string[];
-    constructor();
-    add(line: string): void;
-    toString(): string;
-    header(text: string): void;
-}
-export default BaseSection;