@visulima/cerebro 3.0.0-alpha.9 → 3.0.0

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,96 +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;
-    /**
-     * 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;

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

@@ -1,65 +0,0 @@
-import type { Content as IContent } from "../../../types/command-line-usage.d.ts";
-import BaseSection from "./base-section.d.ts";
-/**
- * A Content section comprises a header and one or more lines of content.
- * @property header The section header, always bold and underlined.
- * @property 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 objects (recordset-style data). In this case, the data will be rendered in table format. The property names of each object are not important, so long as they are consistent throughout the array.
- * 4. An object with two properties - `data` and `options`. In this case, the data and options will be passed directly to the underlying [table](https://github.com/visulima/visulima/tree/main/packages/tabular) module for rendering.
- * @property raw - Set to true to avoid indentation and wrapping. Useful for banners.
- * @example
- * Simple string of content. For ansi formatting, use [colorize template literal syntax](https://github.com/visulima/visulima/tree/main/packages/colorize#tagged-template-literals).
- * ```js
- * {
- *   header: 'A typical app',
- *   content: 'Generates something {rgb(255,200,0).italic very {underline.bgRed important}}.'
- * }
- * ```
- *
- * An array of strings is interpreted as lines, to be joined by the system newline character.
- * ```js
- * {
- *   header: 'A typical app',
- *   content: [
- *     'First line.',
- *     'Second line.'
- *   ],
- * }
- * ```
- *
- * An array of arrays is rendered in table layout.
- * ```js
- * {
- *   header: 'A typical app',
- *   content: [
- *     [ 'First row, first column.', 'First row, second column.', ],
- *     [ 'Second row, first column.', 'Second row, second column.', ],
- *   ]
- * }
- * ```
- *
- * An object with `data` and `options` properties will be passed directly to the underlying [table](https://github.com/cli-table/cli-table3) module for rendering.
- * ```js
- * {
- *   header: 'A typical app',
- *   content: {
- *     data: [
- *         [ 'First row, first column.', 'First row, second column.', ],
- *         [ 'Second row, first column.', 'Second row, second column.', ],
- *         'Second row, first column.',
- *     ],
- *     options: {
- *       colWidths: [80],
- *     }
- *   }
- * }
- * ```
- */
-declare class ContentSection extends BaseSection {
-    constructor(section: IContent);
-    private getContentLines;
-}
-export default ContentSection;

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

@@ -1,44 +0,0 @@
-import type { OptionList as IOptionList } from "../../../types/command-line-usage.d.ts";
-import BaseSection from "./base-section.d.ts";
-declare class OptionListSection extends BaseSection {
-    constructor(data: IOptionList);
-    private getOptionNames;
-    private intersect;
-}
-/**
- * An OptionList section adds a table displaying the supplied option definitions.
- * @property {string} [header] - The section header, always bold and underlined.
- * @property optionList {OptionDefinition[]} - An array of [option definition](https://github.com/75lb/command-line-args/blob/master/doc/option-definition.md) objects. In addition to the regular definition properties, command-line-usage will look for:
- *
- * - `description` - a string describing the option.
- * - `typeLabel` - a string to replace the default type string (e.g. `<string>`). It's often more useful to set a more descriptive type label, like `<ms>`, `<files>`, `<command>` etc.
- * @property {string|string[]} [group] - If specified, only options from this particular group will be printed. [Example](https://github.com/75lb/command-line-usage/blob/master/example/groups.js).
- * @property {string|string[]} [hide] - The names of one of more option definitions to hide from the option list. [Example](https://github.com/75lb/command-line-usage/blob/master/example/hide.js).
- * @property {boolean} [reverseNameOrder] - If true, the option alias will be displayed after the name, i.e. `--verbose, -v` instead of `-v, --verbose`).
- * @property {object} [tableOptions] - An options object suitable for passing into [table-layout](https://github.com/75lb/table-layout#table-). See [here for an example](https://github.com/75lb/command-line-usage/blob/master/example/option-list-options.js).
- * @example
- * {
- * header: 'Options',
- * optionList: [
- * {
- * name: 'help',
- * alias: 'h',
- * description: 'Display this usage guide.'
- * },
- * {
- * name: 'src',
- * description: 'The input files to process',
- * multiple: true,
- * defaultOption: true,
- * typeLabel: '{underline file} ...'
- * },
- * {
- * name: 'timeout',
- * description: 'Timeout value in ms.',
- * alias: 't',
- * typeLabel: '{underline ms}'
- * }
- * ]
- * }
- */
-export default OptionListSection;

package/dist/util/command-processing/command-processor.d.ts

@@ -1,37 +0,0 @@
-import type { CommandLineOptions } from "@visulima/command-line-args";
-import type { Command as ICommand, OptionDefinition } from "../../types/command.d.ts";
-import type { Toolbox as IToolbox } from "../../types/toolbox.d.ts";
-import mergeArguments from "../data-processing/merge-arguments.d.ts";
-/**
- * Prepares the toolbox for command execution.
- * @template OD The option definition type.
- * @param command The command to prepare toolbox for.
- * @param parsedArgs Parsed command-line arguments.
- * @param booleanValues Extracted boolean flag values.
- * @param extraOptions Additional options to merge into toolbox.
- * @returns The prepared toolbox instance.
- */
-export declare const prepareToolbox: <OD extends OptionDefinition<unknown>, TLogger extends Console = Console>(command: ICommand<OD, TLogger>, parsedArgs: CommandLineOptions, booleanValues: Record<string, unknown>, extraOptions: Record<string, unknown>) => IToolbox<TLogger>;
-/**
- * Processes command arguments and options.
- * @template OD The option definition type.
- * @param command The command to process arguments for.
- * @param commandArguments Raw command-line argument strings.
- * @param defaultOptions Default option definitions to merge.
- * @returns Object containing merged arguments, boolean values, and parsed args.
- * @throws {Error} When an argument has both multiple and lazyMultiple options.
- */
-export declare const processCommandArgs: <OD extends OptionDefinition<unknown>, TLogger extends Console = Console>(command: ICommand<OD, TLogger>, commandArguments: string[], defaultOptions: OptionDefinition<unknown>[]) => {
-    arguments_: ReturnType<typeof mergeArguments>;
-    booleanValues: Record<string, unknown>;
-    parsedArgs: CommandLineOptions;
-};
-/**
- * Executes a command and returns its result.
- * @template OD The option definition type.
- * @param command The command to execute.
- * @param toolbox The prepared toolbox for command execution.
- * @param _commandArgs Parsed command arguments.
- * @returns Promise resolving to the command execution result.
- */
-export declare const executeCommand: <OD extends OptionDefinition<unknown>, TLogger extends Console = Console>(command: ICommand<OD, TLogger>, toolbox: IToolbox<TLogger>, _commandArgs: CommandLineOptions) => Promise<unknown>;

package/dist/util/command-processing/command-validation.d.ts

@@ -1,17 +0,0 @@
-import type { CommandLineOptions } from "@visulima/command-line-args";
-import type { Command as ICommand, OptionDefinition, PossibleOptionDefinition } from "../../types/command.d.ts";
-import type { Toolbox as IToolbox } from "../../types/toolbox.d.ts";
-/**
- * Validates that all required options are present.
- * Uses pre-computed required options metadata from command registration for performance.
- */
-export declare const validateRequiredOptions: <OD extends OptionDefinition<unknown>, TLogger extends Console = Console>(arguments_: PossibleOptionDefinition<OD>[], commandArguments: CommandLineOptions, command: ICommand<OD, TLogger>) => void;
-/**
- * Validates for conflicting options.
- * Uses pre-computed conflict metadata from command registration for performance.
- */
-export declare const validateConflictingOptions: <OD extends OptionDefinition<unknown>, TLogger extends Console = Console>(arguments_: PossibleOptionDefinition<OD>[], commandArguments: IToolbox["options"], command: ICommand<OD, TLogger>) => void;
-/**
- * Validates for duplicate option definitions.
- */
-export declare const validateDuplicateOptions: <OD extends OptionDefinition<unknown>>(command: ICommand<OD>) => void;

package/dist/util/command-processing/nested-command-parser.d.ts

@@ -1,25 +0,0 @@
-/**
- * Parses nested command paths from argv.
- * Supports both flat commands (e.g., "build") and nested commands (e.g., "deploy staging").
- * @param availableCommands Map of all available commands keyed by their full path string
- * @param argv Command line arguments to parse
- * @returns Object with the matched command path and remaining argv
- */
-export declare const parseNestedCommand: (availableCommands: Map<string, string[]>, argv: string[]) => {
-    argv: string[];
-    commandPath: string[] | undefined;
-};
-/**
- * Generates a lookup key from a command path array.
- * @param commandPath Array of command path segments
- * @returns The command path key string
- */
-export declare const getCommandPathKey: (commandPath: string[]) => string;
-/**
- * Generates the full command path for a command, including its commandPath if present.
- * Combines the command name with any parent path segments.
- * @param commandName The name of the command to add to the path
- * @param commandPath Optional path segments from the command definition
- * @returns The full command path array combining commandPath and commandName
- */
-export declare const getFullCommandPath: (commandName: string, commandPath?: string[]) => string[];

package/dist/util/command-processing/option-processor.d.ts

@@ -1,44 +0,0 @@
-import type { OptionDefinition } from "../../types/command.d.ts";
-import type { Toolbox as IToolbox } from "../../types/toolbox.d.ts";
-/**
- * Converts option names to camelCase and adds them as __camelCaseName__ properties.
- * @template OD The option definition type
- * @param command The command object containing options to process
- * @param command.options The options array to process
- */
-export declare const processOptionNames: <OD extends OptionDefinition<unknown>>(command: {
-    options?: OD[];
-}) => void;
-/**
- * Adds negatable options for boolean flags.
- * For options starting with "no-", creates a corresponding non-negated option.
- * @template OD The option definition type
- * @param command The command object to add negatable options to
- * @param command.name The name of the command (used for error messages)
- * @param command.options The array of option definitions to process
- * @throws {Error} When a negated option is not of type Boolean
- */
-export declare const addNegatableOptions: <OD extends OptionDefinition<unknown>>(command: {
-    name: string;
-    options?: OD[];
-}) => void;
-/**
- * Maps negatable options to their non-negated counterparts.
- * Processes toolbox options starting with "no" and converts them to non-negated form.
- * @param toolbox The command toolbox containing options
- * @param command The command object with option definitions
- * @param command.options The command options array
- */
-export declare const mapNegatableOptions: <O extends OptionDefinition<unknown>, TLogger extends Console = Console>(toolbox: IToolbox<TLogger>, command: {
-    options?: ReadonlyArray<O | OptionDefinition<boolean[]> | OptionDefinition<boolean> | OptionDefinition<number[]> | OptionDefinition<number> | OptionDefinition<string[]> | OptionDefinition<string>>;
-}) => void;
-/**
- * Applies implied option values.
- * Sets implied option values from option definitions that have an implies property.
- * @param toolbox The command toolbox to apply implied values to
- * @param command The command object with option definitions
- * @param command.options The command options array
- */
-export declare const mapImpliedOptions: <O extends OptionDefinition<unknown>, TLogger extends Console = Console>(toolbox: IToolbox<TLogger>, command: {
-    options?: ReadonlyArray<O | OptionDefinition<boolean[]> | OptionDefinition<boolean> | OptionDefinition<number[]> | OptionDefinition<number> | OptionDefinition<string[]> | OptionDefinition<string>>;
-}) => void;

package/dist/util/data-processing/list-missing-arguments.d.ts

@@ -1,15 +0,0 @@
-import type { CommandLineOptions } from "@visulima/command-line-args";
-import type { OptionDefinition, PossibleOptionDefinition } from "../../types/command.d.ts";
-/**
- * Lists missing required arguments from parsed command line options
- * Optimized to use pre-filtered required options when available
- * Combines filter operations for better performance
- *
- * Note: This function mutates parsedArguments by setting missing boolean options to false.
- * @param commandLineConfig All command options OR pre-filtered required options
- * @param parsedArguments Parsed command line arguments (will be mutated for boolean defaults)
- * @param onlyRequired If true, commandLineConfig already contains only required options (optimization)
- * @returns Array of missing required options
- */
-declare const listMissingArguments: <OD extends OptionDefinition<any>>(commandLineConfig: PossibleOptionDefinition<OD>[], parsedArguments: CommandLineOptions, onlyRequired?: boolean) => PossibleOptionDefinition<OD>[];
-export default listMissingArguments;

package/dist/util/data-processing/merge-arguments.d.ts

@@ -1,7 +0,0 @@
-import type { OptionDefinition, PossibleOptionDefinition } from "../../types/command.d.ts";
-/**
- * Performs a simple merge of multiple argument lists. Does not mutate given
- * argument lists or argument.
- */
-declare const mergeArguments: <OD extends OptionDefinition<any>>(argumentLists: PossibleOptionDefinition<OD>[]) => PossibleOptionDefinition<OD>[];
-export default mergeArguments;

package/dist/util/general/find-alternatives.d.ts

@@ -1,8 +0,0 @@
-/**
- * Finds strings in an array that are similar to the given string.
- * @param string The target string to match against
- * @param array Array of candidate strings to search
- * @returns Array of similar strings from the input array
- */
-declare const findAlternatives: (string: string, array: string[]) => string[];
-export default findAlternatives;

package/dist/util/general/hide-bin.d.ts

@@ -1,2 +0,0 @@
-declare const hideBin: (argv: string[]) => string[];
-export default hideBin;

package/dist/util/general/parse-raw-command.d.ts

@@ -1,7 +0,0 @@
-/**
- * Parses the raw command into an array of strings.
- * @param commandArray Command string or list of command parts.
- * @returns The command as an array of strings.
- */
-declare const parseRawCommand: (commandArray: string[] | string) => string[];
-export default parseRawCommand;

package/dist/util/general/register-exception-handler.d.ts

@@ -1,9 +0,0 @@
-/**
- * Registers global exception handlers for uncaught exceptions and unhandled promise rejections.
- * Logs errors using the provided logger and exits the process with code 1.
- * @template T - Logger type that extends Console interface
- * @param logger Console-like logger instance for error reporting
- * @returns Cleanup function to remove event listeners
- */
-declare const registerExceptionHandler: <T extends Console = Console>(logger: T) => () => void;
-export default registerExceptionHandler;

package/dist/util/general/runtime-process.d.ts

@@ -1,65 +0,0 @@
-/**
- * Runtime-agnostic process-like APIs that work across Node.js, Deno, and Bun.
- */
-/**
- * Gets command line arguments compatible with process.argv format.
- * For Deno, constructs argv from Deno.args (prepending execPath).
- * For Node.js and Bun, uses process.argv directly.
- * @returns Array of command line arguments
- */
-export declare const getArgv: () => ReadonlyArray<string>;
-/**
- * Gets the current working directory.
- * @returns The current working directory path
- */
-export declare const getCwd: () => string;
-/**
- * Gets environment variables as a mutable object.
- * Returns a proxy object that handles mutations across different runtimes.
- * @returns Environment variables object (mutable proxy)
- */
-export declare const getEnv: () => Record<string, string | undefined>;
-/**
- * Gets execution arguments (e.g., --inspect, --trace-warnings).
- * @returns Array of execution arguments
- */
-export declare const getExecArgv: () => ReadonlyArray<string>;
-/**
- * Gets the absolute pathname of the executable that started the process.
- * @returns The executable path
- */
-export declare const getExecPath: () => string;
-/**
- * Gets the operating system platform.
- * @returns Platform string (e.g., "darwin", "linux", "win32")
- */
-export declare const getPlatform: () => string;
-/**
- * Gets the CPU architecture.
- * @returns Architecture string (e.g., "x64", "arm64")
- */
-export declare const getArch: () => string;
-/**
- * Gets version information about the runtime.
- * @returns Object with version strings
- */
-export declare const getVersions: () => Record<string, string>;
-/**
- * Terminates the process with the specified exit code.
- * @param exitCode Exit code (default: 0)
- */
-export declare const exitProcess: (exitCode?: number) => never;
-/**
- * Runtime-agnostic event handler registration.
- * Note: Deno and Bun don't have equivalent event emitters, so this only works in Node.js.
- * In other runtimes, handlers are registered but may not be called for all events.
- */
-export type ProcessEventType = "uncaughtException" | "unhandledRejection";
-export type ProcessEventHandler = (...args: unknown[]) => void;
-/**
- * Registers an event handler for process events.
- * @param event Event type to listen for
- * @param handler Handler function
- * @returns Cleanup function to remove the handler
- */
-export declare const onProcessEvent: (event: ProcessEventType, handler: ProcessEventHandler) => () => void;

package/dist/util/general/semver-gt.d.ts

@@ -1,2 +0,0 @@
-declare const semverGt: (version1: string, version2: string) => boolean;
-export default semverGt;

package/dist/util/general/validate-input.d.ts

@@ -1,24 +0,0 @@
-/**
- * Validates that a string is not empty or whitespace-only.
- */
-export declare const validateNonEmptyString: (value: unknown, fieldName: string) => string;
-/**
- * Validates that a value is an array of strings.
- */
-export declare const validateStringArray: (value: unknown, fieldName: string) => string[];
-/**
- * Validates that a value is a function.
- */
-export declare const validateFunction: (value: unknown, fieldName: string) => (...args: unknown[]) => unknown;
-/**
- * Validates that a value is an object (but not null).
- */
-export declare const validateObject: (value: unknown, fieldName: string) => Record<string, unknown>;
-/**
- * Validates command name format and prevents malicious inputs.
- */
-export declare const validateCommandName: (name: string) => string;
-/**
- * Validates plugin name format and prevents malicious inputs.
- */
-export declare const validatePluginName: (name: string) => string;

package/dist/util/process-env-variables.d.ts

@@ -1,9 +0,0 @@
-import type { EnvDefinition } from "../types/command.d.ts";
-/**
- * Processes environment variables from a command definition.
- * Transforms string values to their specified types and applies default values.
- * @param envDefinitions Array of environment variable definitions
- * @returns Object with camelCase keys and transformed values
- */
-declare const processEnvVariables: (envDefinitions: (EnvDefinition<boolean> | EnvDefinition<number> | EnvDefinition<string>)[] | undefined) => Record<string, unknown>;
-export default processEnvVariables;