@visulima/cerebro 3.0.0-alpha.9 → 3.0.1

package/dist/packem_shared/runtime-process-B6ZplyWn.js

@@ -1,187 +0,0 @@
-const hasDeno = (global) => "Deno" in global;
-const hasBun = (global) => "Bun" in global;
-const getArgv = () => {
-  if (hasDeno(globalThis)) {
-    const deno = globalThis.Deno;
-    const execPath = deno.execPath();
-    let scriptPath = execPath;
-    try {
-      const { importMeta } = globalThis;
-      if (importMeta?.url) {
-        scriptPath = importMeta.url;
-      }
-    } catch {
-    }
-    return [execPath, scriptPath, ...deno.args];
-  }
-  if (hasBun(globalThis)) {
-    const bun = globalThis.Bun;
-    return bun.process.argv;
-  }
-  return process.argv;
-};
-const getCwd = () => {
-  if (hasDeno(globalThis)) {
-    const deno = globalThis.Deno;
-    return deno.cwd();
-  }
-  if (hasBun(globalThis)) {
-    const bun = globalThis.Bun;
-    return bun.process.cwd();
-  }
-  return process.cwd();
-};
-const getEnv = () => {
-  if (hasDeno(globalThis)) {
-    const deno = globalThis.Deno;
-    return /* @__PURE__ */ new Proxy(deno.env.toObject(), {
-      get: (target, prop) => {
-        if (typeof prop === "string") {
-          return deno.env.get(prop);
-        }
-        return target[prop];
-      },
-      has: (target, prop) => {
-        if (typeof prop === "string") {
-          return deno.env.has(prop);
-        }
-        return prop in target;
-      },
-      set: (_target, prop, value) => {
-        if (typeof prop === "string") {
-          if (value === void 0) {
-            return true;
-          }
-          deno.env.set(prop, value);
-          return true;
-        }
-        return false;
-      }
-    });
-  }
-  if (hasBun(globalThis)) {
-    const bun = globalThis.Bun;
-    return bun.process.env;
-  }
-  return process.env;
-};
-const getExecArgv = () => {
-  if (hasDeno(globalThis)) {
-    return [];
-  }
-  if (hasBun(globalThis)) {
-    const bun = globalThis.Bun;
-    return bun.process.execArgv;
-  }
-  return process.execArgv;
-};
-const getExecPath = () => {
-  if (hasDeno(globalThis)) {
-    const deno = globalThis.Deno;
-    return deno.execPath();
-  }
-  if (hasBun(globalThis)) {
-    const bun = globalThis.Bun;
-    return bun.process.execPath;
-  }
-  return process.execPath;
-};
-const getPlatform = () => {
-  if (hasDeno(globalThis)) {
-    const deno = globalThis.Deno;
-    const os = deno.build?.os ?? "unknown";
-    return os === "windows" ? "win32" : os;
-  }
-  if (hasBun(globalThis)) {
-    const bun = globalThis.Bun;
-    return bun.platform ?? "unknown";
-  }
-  return process.platform;
-};
-const getArch = () => {
-  if (hasDeno(globalThis)) {
-    const deno = globalThis.Deno;
-    const arch = deno.build?.arch ?? "unknown";
-    if (arch === "x86_64") {
-      return "x64";
-    }
-    if (arch === "aarch64") {
-      return "arm64";
-    }
-    return arch;
-  }
-  if (hasBun(globalThis)) {
-    const bun = globalThis.Bun;
-    return bun.process.arch;
-  }
-  return process.arch;
-};
-const getVersions = () => {
-  if (hasDeno(globalThis)) {
-    const deno = globalThis.Deno;
-    const versions = {};
-    if (deno.version?.deno) {
-      versions.deno = deno.version.deno;
-    }
-    if (deno.version?.v8) {
-      versions.v8 = deno.version.v8;
-    }
-    if (deno.version?.typescript) {
-      versions.typescript = deno.version.typescript;
-    }
-    return versions;
-  }
-  if (hasBun(globalThis)) {
-    const bun = globalThis.Bun;
-    const versions = { ...bun.process.versions };
-    if (bun.version) {
-      versions.bun = bun.version;
-    }
-    return versions;
-  }
-  return process.versions;
-};
-const exitProcess = (exitCode = 0) => {
-  if (hasDeno(globalThis)) {
-    const deno = globalThis.Deno;
-    deno.exit(exitCode);
-    throw new Error("Deno exit failed");
-  }
-  if (hasBun(globalThis)) {
-    const bun = globalThis.Bun;
-    bun.process.exit(exitCode);
-    throw new Error("Bun exit failed");
-  }
-  const nodeProcess = process;
-  nodeProcess.exit(exitCode);
-  return void 0;
-};
-const onProcessEvent = (event, handler) => {
-  if (hasDeno(globalThis)) {
-    return () => {
-    };
-  }
-  if (hasBun(globalThis)) {
-    try {
-      const bun = globalThis.Bun;
-      if (bun.process?.on) {
-        bun.process.on(event, handler);
-        return () => {
-          if (bun.process?.removeListener) {
-            bun.process.removeListener(event, handler);
-          }
-        };
-      }
-    } catch {
-    }
-    return () => {
-    };
-  }
-  const nodeProcess = process;
-  nodeProcess.on(event, handler);
-  return () => {
-    nodeProcess.removeListener(event, handler);
-  };
-};
-
-export { getVersions as a, getPlatform as b, getArch as c, getEnv as d, exitProcess as e, getArgv as f, getCwd as g, getExecPath as h, getExecArgv as i, onProcessEvent as o };

package/dist/plugin-manager.d.ts

@@ -1,53 +0,0 @@
-import type { Plugin, PluginContext } from "./types/plugin.d.ts";
-import type { Toolbox } from "./types/toolbox.d.ts";
-type Logger = Console;
-/**
- * Manages plugin lifecycle and execution
- */
-declare class PluginManager<T extends Logger = Logger> {
-    private readonly logger;
-    private readonly plugins;
-    private initialized;
-    private cachedDependencyOrder;
-    constructor(logger: T);
-    /**
-     * Checks if any plugins are registered.
-     * @returns True if at least one plugin is registered
-     */
-    hasPlugins(): boolean;
-    /**
-     * Registers a plugin.
-     * @param plugin The plugin to register
-     * @throws {Error} If plugin name is already registered or dependencies are invalid
-     */
-    register(plugin: Plugin<T>): void;
-    /**
-     * Initializes all registered plugins.
-     * @param context The plugin context for initialization
-     */
-    init(context: PluginContext<T>): Promise<void>;
-    /**
-     * Executes a specific lifecycle hook for all plugins.
-     * @param hook The lifecycle hook name
-     * @param toolbox The command toolbox (for command-specific hooks)
-     * @param result The command result (for afterCommand hook)
-     */
-    executeLifecycle(hook: "beforeCommand" | "afterCommand" | "execute", toolbox: Toolbox<T>, result?: unknown): Promise<void>;
-    /**
-     * Executes error handlers for all plugins.
-     * @param error The error that occurred
-     * @param toolbox The command toolbox
-     */
-    executeErrorHandlers(error: Error, toolbox: Toolbox<T>): Promise<void>;
-    /**
-     * Gets all registered plugins in dependency order.
-     * @returns Array of plugins sorted by dependencies
-     */
-    getDependencyOrder(): Plugin<T>[];
-    /**
-     * Validates that all plugin dependencies exist.
-     * @throws {Error} If any dependencies are missing
-     */
-    private validateDependencies;
-}
-export default PluginManager;

package/dist/plugins/update-notifier/cache.d.ts

@@ -1,11 +0,0 @@
-/**
- * Retrieves the last update check timestamp for the specified package.
- * @param packageName
- * @returns - The timestamp of the last update check, or undefined if the check failed.
- */
-export declare const getLastUpdate: (packageName: string) => number | undefined;
-/**
- * Saves the last update time for a given package.
- * @param packageName
- */
-export declare const saveLastUpdate: (packageName: string) => void;

package/dist/plugins/update-notifier/get-distribution-version.d.ts

@@ -1,2 +0,0 @@
-declare const getDistributionVersion: (packageName: string, distributionTag: string, registryUrl: string) => Promise<string>;
-export default getDistributionVersion;

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,102 +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 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;
-    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 | undefined;
-    /** 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 | undefined;
-    /** A string describing the option. */
-    description?: string | undefined;
-    /** 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> | undefined;
-    /** 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 | undefined;
-};
-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 | undefined;
-    /** A description of what the environment variable does */
-    description?: string | undefined;
-    /** 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> | undefined;
-    /** A string to replace the default type string (e.g. &lt;string>). Useful for more descriptive type labels. */
-    typeLabel?: string | undefined;
-}
-export type PossibleEnvDefinition = EnvDefinition<boolean> | EnvDefinition<number> | EnvDefinition<string>;
-/**
- * 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<string>)[];
-    /** 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>;