@reliverse/rempts 1.7.49 → 1.7.51

package/dist-npm/bin/mod.d.mts

@@ -1,18 +1,9 @@
 import { AnimationName as AnimationName$1, Animation } from '@figliolia/chalk-animation';
 import { Readable, Writable } from 'node:stream';
 import { Fonts } from 'figlet';
-import { ReliArgParserOptions } from '@reliverse/reliarg';
-import { JSONSchema7 } from 'json-schema';
-import { JsonSchema7Type, JsonSchema7ObjectType } from 'zod-to-json-schema';
-import { Command as Command$1, Argument, Option } from 'commander';
 import * as _reliverse_relinka from '@reliverse/relinka';
 import { SpinnerName } from 'cli-spinners';
 import * as _reliverse_runtime from '@reliverse/runtime';
-import * as server from '@trpc/server';
-export { server as trpcServer };
-export { z } from 'zod/v4';
-import * as zod from 'zod';
-export { zod };
 
 type MsgType = "M_NULL" | "M_INFO_NULL" | "M_START" | "M_MIDDLE" | "M_GENERAL" | "M_GENERAL_NULL" | "M_INFO" | "M_ERROR" | "M_ERROR_NULL" | "M_END" | "M_NEWLINE" | "M_BAR";
 type TypographyName = "bold" | "strikethrough" | "underline" | "italic" | "none";
@@ -1023,169 +1014,110 @@ declare function introPrompt(optionsOrTitle: StartPromptOptions | string): Promi
 declare const startPrompt: typeof introPrompt;
 declare const intro: typeof introPrompt;
 
-/** The Standard Schema interface. */
-interface StandardSchemaV1<Input = unknown, Output = Input> {
-    /** The Standard Schema properties. */
-    readonly "~standard": StandardSchemaV1Props<Input, Output>;
-}
-/** The Standard Schema properties interface. */
-interface StandardSchemaV1Props<Input = unknown, Output = Input> {
-    /** The version number of the standard. */
-    readonly version: 1;
-    /** The vendor name of the schema library. */
-    readonly vendor: string;
-    /** Validates unknown input values. */
-    readonly validate: (value: unknown) => StandardSchemaV1Result<Output> | Promise<StandardSchemaV1Result<Output>>;
-    /** Inferred types associated with the schema. */
-    readonly types?: StandardSchemaV1Types<Input, Output> | undefined;
-}
-/** The result interface of the validate function. */
-type StandardSchemaV1Result<Output> = StandardSchemaV1SuccessResult<Output> | StandardSchemaV1FailureResult;
-/** The result interface if validation succeeds. */
-interface StandardSchemaV1SuccessResult<Output> {
-    /** The typed output value. */
-    readonly value: Output;
-    /** The non-existent issues. */
-    readonly issues?: undefined;
-}
-/** The result interface if validation fails. */
-interface StandardSchemaV1FailureResult {
-    /** The issues of failed validation. */
-    readonly issues: readonly StandardSchemaV1Issue[];
-}
-/** The issue interface of the failure output. */
-interface StandardSchemaV1Issue {
-    /** The error message of the issue. */
-    readonly message: string;
-    /** The path of the issue, if any. */
-    readonly path?: readonly (PropertyKey | StandardSchemaV1PathSegment)[] | undefined;
-}
-/** The path segment interface of the issue. */
-interface StandardSchemaV1PathSegment {
-    /** The key representing a path segment. */
-    readonly key: PropertyKey;
-}
-/** The Standard Schema types interface. */
-interface StandardSchemaV1Types<Input = unknown, Output = Input> {
-    /** The input type of the schema. */
-    readonly input: Input;
-    /** The output type of the schema. */
-    readonly output: Output;
-}
-/** Infers the input type of a Standard Schema. */
-type StandardSchemaV1InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
-/** Infers the output type of a Standard Schema. */
-type StandardSchemaV1InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
-
 /**
- * Type which looks *enough* like a trpc v11(+?) router to infer its types correctly
- * This is written from scratch to avoid any kind of dependency on @trpc/server v11+
+ * Options passed to the ReliArgParser.
  */
-interface Trpc11RouterLike {
-    _def: {
-        _config: {
-            $types: {
-                meta: any;
-                ctx: any;
-            };
-        };
-        procedures: Record<string, Trpc11ProcedureLike | Trpc11ProcedureRecordLike | Record<string, Trpc11ProcedureLike>>;
-    };
-}
-/** Even though you use `t.router({})` to create a sub-router, the actual type is a record of procedures and sub-routers rather than a root-level router */
-interface Trpc11ProcedureRecordLike {
-    [key: string]: Trpc11ProcedureLike | Trpc11ProcedureRecordLike;
-}
-interface Trpc11ProcedureLike {
-    _def: {
-        type: "mutation" | "query" | "subscription";
-        _type?: undefined;
-        meta?: any;
-        inputs?: unknown[];
-        $types: {
-            input: any;
-            output: any;
-        };
-    };
-}
-interface Trpc10RouterLike {
-    _def: {
-        _config: {
-            $types: {
-                meta: any;
-                ctx: any;
-            };
-        };
-        procedures: Record<string, Trpc10ProcedureLike | Trpc10RouterLike>;
-    };
-}
-interface Trpc10ProcedureLike {
-    _def: {
-        type?: undefined;
-        mutation?: boolean;
-        query?: boolean;
-        subscription?: boolean;
-        meta?: any;
-        inputs: unknown[];
-        _input_in: any;
-        _output_out: any;
-    };
-}
-interface OrpcProcedureLike<Ctx> {
-    "~orpc": {
-        __initialContext?: (context: Ctx) => unknown;
-        inputSchema?: StandardSchemaV1;
-    };
-}
-interface OrpcRouterLike<Ctx> {
-    [key: string]: OrpcProcedureLike<Ctx> | OrpcRouterLike<Ctx>;
-}
-type CreateCallerFactoryLike<Procedures = Record<string, (input: unknown) => unknown>> = (router: any) => (context: any) => Procedures;
-type AnyRouter = Trpc10RouterLike | Trpc11RouterLike | OrpcRouterLike<any>;
-type AnyProcedure = Trpc10ProcedureLike | Trpc11ProcedureLike;
-type inferRouterContext<R extends AnyRouter> = R extends Trpc10RouterLike | Trpc11RouterLike ? R["_def"]["_config"]["$types"]["ctx"] : R extends OrpcRouterLike<infer Ctx> ? Ctx : never;
-declare const isTrpc11Procedure: (procedure: AnyProcedure) => procedure is Trpc11ProcedureLike;
-declare const isTrpc11Router: (router: AnyRouter) => router is Trpc11RouterLike;
-declare const isOrpcRouter: (router: AnyRouter) => router is OrpcRouterLike<any>;
+type ReliArgParserOptions = {
+    /**
+     * A list of flags that should be treated as booleans.
+     */
+    boolean?: string[];
+    /**
+     * Whether to print a warning if an unknown flag is encountered.
+     */
+    warnOnUnknown?: boolean;
+    /**
+     * Whether encountering an unknown flag should cause a thrown error.
+     */
+    strict?: boolean;
+    /**
+     * An object that maps a flag to one or more aliases (e.g. { force: "f" } or { f: ["force", "fast"] }).
+     */
+    alias?: Record<string, string | string[]>;
+    /**
+     * Default values for flags (e.g. { force: false, count: 0 }).
+     */
+    defaults?: Record<string, unknown>;
+    /**
+     * If true, allows --no-foo to set foo=false (negated booleans).
+     * Defaults to `true`.
+     */
+    negatedBoolean?: boolean;
+    /**
+     * A callback to determine if a flag is considered "unknown."
+     * If it returns false, the parser may warn or throw, depending on config.
+     */
+    unknown?: (flagName: string) => boolean;
+    /**
+     * If true, attempt to parse non-boolean string values as numbers when possible.
+     * Defaults to false.
+     */
+    parseNumbers?: boolean;
+    /**
+     * If true, negative numbers like -123 will not be treated as short flags
+     * and will be parsed as positional values.
+     * Defaults to true (commonly desired).
+     */
+    allowNegativeNumbers?: boolean;
+    /**
+     * If true, stop parsing flags at the first positional argument,
+     * pushing all subsequent arguments into result._.
+     * Defaults to false.
+     */
+    stopEarly?: boolean;
+    /**
+     * A list of flags that should be collected as arrays if repeated.
+     * e.g. { array: ["include"] } => --include file1 --include file2
+     * results in { include: ["file1", "file2"] }
+     */
+    array?: string[];
+    /**
+     * A list of flags that should always be treated as strings (ignoring parseNumbers).
+     */
+    string?: string[];
+};
 
 type EmptyArgs = Record<string, never>;
 interface BaseArgProps {
     description?: string;
     required?: boolean;
-    allowed?: string[];
+    allowed?: readonly string[];
 }
 interface BaseArgDefinition {
     type: string;
     description?: string;
     required?: boolean;
     default?: any;
-    allowed?: any[];
+    allowed?: readonly any[];
     dependencies?: string[];
 }
 type PositionalArgDefinition = BaseArgDefinition & {
     type: "positional";
     default?: string;
+    allowed?: readonly string[];
 };
 type BooleanArgDefinition = BaseArgDefinition & {
     type: "boolean";
     default?: boolean;
-    allowed?: boolean[];
+    allowed?: readonly boolean[];
     alias?: string;
 };
 type StringArgDefinition = BaseArgDefinition & {
     type: "string";
     default?: string;
+    allowed?: readonly string[];
     alias?: string;
 };
 type NumberArgDefinition = BaseArgDefinition & {
     type: "number";
     default?: number;
-    allowed?: number[];
+    allowed?: readonly number[];
     alias?: string;
 };
 type ArrayArgDefinition = BaseArgDefinition & {
     type: "array";
     default?: string | readonly string[];
+    allowed?: readonly string[];
     alias?: string;
 };
 type ArgDefinition = PositionalArgDefinition | BooleanArgDefinition | StringArgDefinition | NumberArgDefinition | ArrayArgDefinition;
@@ -1249,11 +1181,6 @@ interface DefineCommandOptions<A extends ArgDefinitions = EmptyArgs> {
      * Called once per CLI process, after all command/run() logic is finished
      */
     onLauncherExit?: () => void | Promise<void>;
-    /**
-     * tRPC/oRPC router for RPC mode. When provided, the command will automatically
-     * switch to RPC mode and use the router's procedures as CLI commands.
-     */
-    router?: AnyRouter;
 }
 interface Command<A extends ArgDefinitions = EmptyArgs> {
     meta?: CommandMeta;
@@ -1291,372 +1218,70 @@ interface Command<A extends ArgDefinitions = EmptyArgs> {
      * Called once per CLI process, after all command/run() logic is finished
      */
     onLauncherExit?: () => void | Promise<void>;
-    /**
-     * tRPC/oRPC router for RPC mode. When provided, the command will automatically
-     * switch to RPC mode and use the router's procedures as CLI commands.
-     */
-    router?: AnyRouter;
 }
+type ExtractAllowed<T extends ArgDefinition> = T extends {
+    type: "positional";
+    allowed: readonly (infer U)[];
+} ? U : T extends {
+    type: "positional";
+} ? string : T extends {
+    type: "boolean";
+    allowed: readonly (infer U)[];
+} ? U : T extends {
+    type: "boolean";
+} ? boolean : T extends {
+    type: "string";
+    allowed: readonly (infer U)[];
+} ? U : T extends {
+    type: "string";
+} ? string : T extends {
+    type: "number";
+    allowed: readonly (infer U)[];
+} ? U : T extends {
+    type: "number";
+} ? number : T extends {
+    type: "array";
+    allowed: readonly (infer U)[];
+} ? U[] : T extends {
+    type: "array";
+} ? string[] : never;
 type InferArgTypes<A extends ArgDefinitions> = {
-    [K in keyof A]: A[K] extends PositionalArgDefinition ? string : A[K] extends BooleanArgDefinition ? boolean : A[K] extends StringArgDefinition ? string : A[K] extends NumberArgDefinition ? number : A[K] extends {
-        type: "array";
-    } ? string[] : never;
+    [K in keyof A]: ExtractAllowed<A[K]>;
 };
 interface FileBasedOptions {
     enable: boolean;
     cmdsRootPath: string;
 }
 
-/**
- * Load a command from the filesystem.
- *
- * @param cmdPath - Path to the command file or directory containing cmd.ts/cmd.js
- * @returns Promise<Command> - The loaded command
- *
- * @example
- * ```ts
- * // Load a command
- * const cmd = await loadCommand("./web/cmd");
- *
- * // Use with runCmd - pass args as separate array elements
- * await runCmd(cmd, ["--dev", "true"]); // ✅ Correct
- * await runCmd(cmd, [`--dev ${isDev}`]); // ❌ Wrong - creates single string
- * ```
- */
-declare function loadCommand(cmdPath: string): Promise<Command>;
-
-/**
- * Static implementation functions for the typed command system.
- * These functions are imported by the generated cmds.ts file.
- */
-declare function argsToStringArray(args: Record<string, unknown>): string[];
-declare function createCallCmd<TCommandArgsMap>(): Promise<(<T extends keyof TCommandArgsMap>(cmdName: T, args?: TCommandArgsMap[T]) => Promise<void>)>;
-declare function createGetTypedCmd<TCommandArgsMap>(): Promise<(<T extends keyof TCommandArgsMap>(cmdName: T) => Promise<{
-    command: Command;
-    run: (args?: TCommandArgsMap[T]) => Promise<void>;
-}>)>;
-declare function callCmdImpl<TCommandArgsMap>(cmdName: keyof TCommandArgsMap, args?: TCommandArgsMap[keyof TCommandArgsMap]): Promise<void>;
-declare function getTypedCmdImpl<TCommandArgsMap>(cmdName: keyof TCommandArgsMap): Promise<{
-    command: Command;
-    run: (args?: TCommandArgsMap[keyof TCommandArgsMap]) => Promise<void>;
-}>;
-
-/**
- * JSON representation of a commander `Command` instance
- * Note: this is not necessarily a _complete_ representation of the command - it aims to be a big enough subset to be useful for generating documentation etc.
- */
-interface CommandJSON {
-    name?: string;
-    version?: string;
-    description?: string;
-    usage?: string;
-    commands?: CommandJSON[];
-    arguments?: {
-        name: string;
-        description?: string;
-        required: boolean;
-        defaultValue?: {};
-        defaultValueDescription?: string;
-        variadic: boolean;
-        choices?: string[];
-    }[];
-    options?: {
-        name: string;
-        description?: string;
-        required: boolean;
-        defaultValue?: {};
-        defaultValueDescription?: string;
-        variadic: boolean;
-        attributeName?: string;
-        flags?: string;
-        short?: string;
-        negate: boolean;
-        optional: boolean;
-        choices?: string[];
-    }[];
-}
-/**
- * Convert a commander `Command` instance to a JSON object.
- *
- * Note: in theory you could use this with any `Command` instance, it doesn't have
- * to be one built by `@reliverse/rempts`. Implementing here because it's pretty simple to do and `commander` doesn't seem to provide a way to do it.
- *
- * Note: falsy values for strings are replaced with `undefined` in the output - e.g. if there's an empty description, it will be `undefined` in the output.
- */
-declare const commandToJSON: (command: Command$1) => CommandJSON;
-
-interface TrpcCliParams<R extends AnyRouter> extends Dependencies {
-    /** A tRPC router. Procedures will become CLI commands. */
-    router: R;
-    name?: string;
-    version?: string;
-    description?: string;
-    usage?: string | string[];
-    /** Context to be supplied when invoking the router. */
-    context?: inferRouterContext<R>;
-    /** @deprecated this is actually **removed** not deprecated; use `aliases` on each procedure `meta` instead */
-    alias?: never;
-    /** @deprecated this is actually **removed** not deprecated; set `default: true` on the procedure `meta` instead */
-    _default?: never;
-    /** The `@trpc/server` module to use for calling procedures. Required when using trpc v10. */
-    trpcServer?: TrpcServerModuleLike | Promise<TrpcServerModuleLike>;
-}
-/** Rough shape of the `@trpc/server` (v10) module. Needed to pass in to `createRpcCli` when using trpc v10. */
-interface TrpcServerModuleLike {
-    initTRPC: {
-        create: () => {
-            createCallerFactory: CreateCallerFactoryLike<{}>;
-        };
-    };
-}
-/**
- * Optional interface for describing procedures via meta - if your router conforms to this meta shape, it will contribute to the CLI help text.
- */
-interface TrpcCliMeta {
-    /** Version of the script displayed in `--help` output. Use to avoid enabling `--version` option. */
-    version?: string;
-    /** Description of the script or command to display in `--help` output. */
-    description?: string;
-    /** Usage code examples to display in `--help` output. */
-    usage?: false | string | string[];
-    /** Example code snippets to display in `--help` output. */
-    examples?: string | string[];
-    /** If true, this command will be run if no command is specified. */
-    default?: boolean;
-    aliases?: {
-        /** Aliases for the command. Note: take care to avoid conflicts with other commands. */
-        command?: string[];
-        /** Aliases for the options. Note: take care to avoid conflicts with other options. An error will be thrown if an alias is defined for a non-existent option. */
-        options?: Record<string, string>;
-    };
-    /** If true, will use a single CLI option expect the entire input to be parsed in as JSON, e.g. `--input '{"foo": "bar"}`. Can be useful to opt out of the default mapping of input schemas to CLI options. */
-    jsonInput?: boolean;
-    /** Sub-property for the CLI meta. If present, will take precedence over the top-level meta, to avoid conflicts with other tools. */
-    cliMeta?: TrpcCliMeta;
-}
-interface ParsedProcedure {
-    positionalParameters: {
-        name: string;
-        description: string;
-        type: "string" | "number" | "boolean" | (string & {});
-        required: boolean;
-        array: boolean;
-    }[];
-    /** JSON Schema type describing the flags for the procedure */
-    optionsJsonSchema: JsonSchema7Type;
-    /**
-     * Function for taking parsed argv output and transforming it so it can be passed into the procedure.
-     * Needed because this function is where inspect the input schema(s) and determine how to map the argv to the input
-     */
-    getPojoInput: (argv: {
-        positionalValues: (string | string[])[];
-        options: Record<string, unknown>;
-    }) => unknown;
-}
-type Result<T> = {
-    success: true;
-    value: T;
-} | {
-    success: false;
-    error: string;
-};
-/** A function that logs any inputs. e.g. `console.info` */
-type Log = (...args: unknown[]) => void;
-/**
- * A struct which has `info` and `error` functions for logging. Easiest example: `console`
- * But most loggers like pino, winston etc. have a similar interface.
- */
-interface Logger {
-    info?: Log;
-    error?: Log;
+interface CallCmdOptions {
+    /** Whether to automatically exit process on errors (default: false for programmatic usage) */
+    autoExit?: boolean;
+    /** Whether to show debug output */
+    debug?: boolean;
+    /** Whether to call lifecycle hooks (onCmdInit/onCmdExit) */
+    useLifecycleHooks?: boolean;
+    /** Custom parser options for argv processing */
+    parserOptions?: ReliArgParserOptions;
 }
 /**
- * Slim reconstruction of an `omelette` instance. Hand-written here to avoid a hard dependency on `omelette` or its types.
- * Usually you will just pass in an `omelette` instance by doing something like
- *
- * ```ts
- * import omelette from 'omelette'
- * import {createRpcCli} from '@reliverse/rempts'
+ * Programmatically call a defineCommand command with arguments.
+ * Fully compatible with launcher-mod.ts execution logic.
  *
- * const cli = createRpcCli({
- *   router: myRouter,
- *   completion: omelette('myprogram'),
- * })
- * ```
- *
- * Or it also accepts an async function that resolves to an `omelette` instance, so you can use dynamic import:
+ * @param command - The command definition created with defineCommand()
+ * @param input - Either argv array (CLI-style) or args object (programmatic style)
+ * @param options - Optional configuration for execution
+ * @returns Promise resolving to the command context
  *
+ * @example
  * ```ts
- * import {createRpcCli} from '@reliverse/rempts'
+ * // CLI-style with argv array
+ * const result = await callCmd(myCommand, ['--flag', 'value', 'positional']);
  *
- * const cli = await createRpcCli({
- *   router: myRouter,
- *   completion: () => import('omelette').then(omelette => omelette.default('myprogram')),
- * })
+ * // Programmatic style with object
+ * const result = await callCmd(myCommand, { flag: true, name: 'value' });
  * ```
  */
-interface OmeletteInstanceLike {
-    on: (event: "complete", callback: (fragment: string, params: {
-        line: string;
-        fragment: number;
-        reply: (suggestions: string[]) => void;
-    }) => void) => void;
-    init: () => void;
-    setupShellInitFile: () => void;
-    cleanupShellInitFile: () => void;
-    tree: (value: any) => this;
-}
-interface InquirerPromptOptions {
-    message: string;
-    required?: boolean;
-    validate?: (input: string) => boolean | string;
-    default?: any;
-}
-/** looks like the `@inquirer/prompts` package */
-interface InquirerPromptsLike {
-    input: (params: InquirerPromptOptions) => Promise<string>;
-    confirm: (params: InquirerPromptOptions) => Promise<boolean>;
-}
-/** looks like the `prompts` package */
-interface PromptsLike {
-    prompt: Function;
-    inject: Function;
-}
-/** looks like the `enquirer` package */
-interface EnquirerLike {
-    prompt: <T>(params: {
-        type: "input";
-        name: string;
-        message: string;
-        validate?: (input: string) => boolean | string;
-        initial?: unknown;
-    }) => Promise<T>;
-}
-interface ClackPromptsLike {
-    intro: (title: string) => void;
-    outro: (title: string) => void;
-}
-type Promptable = InquirerPromptsLike | EnquirerLike | PromptsLike | Prompter | ClackPromptsLike | ((command: CommanderProgramLike) => Prompter);
-interface TrpcCliRunParams {
-    argv?: string[];
-    logger?: Logger;
-    completion?: OmeletteInstanceLike | (() => Promise<OmeletteInstanceLike>);
-    prompts?: Promptable;
-    /** Format an error thrown by the root procedure before logging to `logger.error` */
-    formatError?: (error: unknown) => string;
-    process?: {
-        exit: (code: number) => never;
-    };
-}
-/**
- * Type that looks like a `commander` Command instance, but doesn't require a dependency on `commander` to avoid awkward typescript errors.
- * If you need to use it as a `Command` instance, just cast it with `as` to `import('commander').Command`.
- */
-interface CommanderProgramLike {
-    name: () => string;
-    parseAsync: (args: string[], options?: {
-        from: "user" | "node" | "electron";
-    }) => Promise<unknown>;
-    helpInformation: () => string;
-}
-interface TrpcCli {
-    /** run the CLI - gets args from `process.argv` by default */
-    run: (params?: TrpcCliRunParams, program?: CommanderProgramLike) => Promise<void>;
-    /**
-     * Build a `Commander` program from the CLI - you can use this to manually customise the program before passing it to `.run(...)`.
-     * Note that you will need to cast the return value to `import('commander').Command` to use it as a `Command` instance.
-     */
-    buildProgram: (params?: TrpcCliRunParams) => CommanderProgramLike;
-    /**
-     * @experimental
-     * Get a JSON representation of the CLI - useful for generating documentation etc. This function returns basic information about the CLI
-     * and each command - to get any extra details you will need to use the `buildProgram` function and walk the tree of commands yourself.
-     */
-    toJSON: (program?: CommanderProgramLike) => CommandJSON;
-}
-interface Dependencies {
-    "@valibot/to-json-schema"?: {
-        toJsonSchema: (input: unknown, options?: {
-            errorMode?: "throw" | "ignore" | "warn";
-        }) => JSONSchema7;
-    };
-    effect?: {
-        Schema: {
-            isSchema: (input: unknown) => input is "JSONSchemaMakeable";
-        };
-        JSONSchema: {
-            make: (input: "JSONSchemaMakeable") => JSONSchema7;
-        };
-    };
-}
-interface PromptContext {
-    input?: NodeJS.ReadableStream;
-    output?: NodeJS.WritableStream;
-    clearPromptOnDone?: boolean;
-    signal?: AbortSignal;
-    /** The command that is being prompted for. Cast this to a `commander.Command` to access the command's name, description, options etc. */
-    command: {
-        name: () => string;
-    };
-    /** The original inputs the user provided - if they passed some but not all arguments/options, this will contain the values they did pass. */
-    inputs: {
-        argv: string[];
-        arguments: {
-            name: string;
-            specified: boolean;
-            value: unknown;
-        }[];
-        options: {
-            name: string;
-            specified: boolean;
-            value: unknown;
-        }[];
-    };
-    /** If set, this is the argument that is being prompted for. Cast to a `commander.Argument`. */
-    argument?: {
-        name: () => string;
-    };
-    /** If set, this is the option that is being prompted for. Cast to a `commander.Option`. */
-    option?: {
-        name: () => string;
-    };
-}
-interface Prompter {
-    setup?: (context: PromptContext) => Promise<void>;
-    teardown?: (context: PromptContext) => Promise<void>;
-    input: (params: {
-        message: string;
-        validate?: (input: string) => boolean | string;
-        required?: boolean;
-        default?: string;
-    }, context: PromptContext) => Promise<string>;
-    select: (params: {
-        message: string;
-        choices: string[] | {
-            name: string;
-            value: string;
-            description?: string;
-        }[];
-        required?: boolean;
-        default?: string;
-        validate?: (input: string) => boolean | string;
-    }, context: PromptContext) => Promise<string>;
-    confirm: (params: {
-        message: string;
-        default?: boolean;
-        validate?: (input: string) => boolean | string;
-    }, context: PromptContext) => Promise<boolean>;
-    checkbox: (params: {
-        message: string;
-        choices: {
-            name: string;
-            value: string;
-            checked?: boolean;
-        }[];
-        required?: boolean;
-        default?: string[];
-    }, context: PromptContext) => Promise<string[]>;
-}
+declare function callCmd<A extends ArgDefinitions = EmptyArgs>(command: Command<A>, input: string[] | Partial<InferArgTypes<A>>, options?: CallCmdOptions): Promise<CommandContext<InferArgTypes<A>>>;
 
 /**
  * Defines a command with metadata, argument definitions,
@@ -1686,7 +1311,6 @@ declare function showUsage<A extends ArgDefinitions>(command: Command<A>, parser
  * - File-based Commands: scanning for commands within a given commands root.
  * - Commands defined within the command object.
  * - Standard flags like --help, --version, and --debug.
- * - RPC functionality: tRPC/oRPC router integration with automatic CLI generation.
  *
  * This function passes along remaining arguments to command runners to ensure
  * consistent parsing.
@@ -1709,41 +1333,6 @@ declare function createCli<A extends ArgDefinitions = EmptyArgs>(options: Comman
     onCmdExit?: Command<A>["onCmdExit"];
     onLauncherInit?: Command<A>["onLauncherInit"];
     onLauncherExit?: Command<A>["onLauncherExit"];
-    rpc?: {
-        /** A tRPC router. Procedures will become CLI commands. */
-        router: AnyRouter;
-        /** Context to be supplied when invoking the router. */
-        context?: any;
-        /** The `@trpc/server` module to use for calling procedures. Required when using trpc v10. */
-        trpcServer?: any | Promise<any>;
-        /** Usage code examples to display in `--help` output. */
-        usage?: string | string[];
-        /** Dependencies for schema validation libraries */
-        "@valibot/to-json-schema"?: {
-            toJsonSchema: (input: unknown, options?: {
-                errorMode?: "throw" | "ignore" | "warn";
-            }) => any;
-        };
-        effect?: {
-            Schema: {
-                isSchema: (input: unknown) => input is "JSONSchemaMakeable";
-            };
-            JSONSchema: {
-                make: (input: "JSONSchemaMakeable") => any;
-            };
-        };
-    };
-    rpcRunParams?: {
-        argv?: string[];
-        logger?: Logger;
-        completion?: OmeletteInstanceLike | (() => Promise<OmeletteInstanceLike>);
-        prompts?: Promptable;
-        /** Format an error thrown by the root procedure before logging to `logger.error` */
-        formatError?: (error: unknown) => string;
-        process?: {
-            exit: (code: number) => never;
-        };
-    };
 }, legacyParserOptions?: ReliArgParserOptions & {
     fileBased?: FileBasedOptions;
     autoExit?: boolean;
@@ -1758,178 +1347,9 @@ declare function createCli<A extends ArgDefinitions = EmptyArgs>(options: Comman
  * for IntelliSense and validation for array defaults against options.
  */
 declare function defineArgs<A extends ArgDefinitions>(args: A): A;
-/**
- * Programmatically run a command with subcommand support and flexible argument handling.
- * This function can handle subcommands (including nested), positional arguments, and automatically normalizes
- * template literals and space-separated strings.
- *
- * @param command The command definition (from defineCommand)
- * @param argv The argv array to parse (default: []). Supports template literals and subcommands.
- * @param parserOptions Optional reliArgParser options
- *
- * @example
- * ```ts
- * // ✅ Single command with template literals
- * await runCmdWithSubcommands(cmd, [`--dev ${isDev}`]);
- *
- * // ✅ Subcommand with arguments
- * await runCmdWithSubcommands(cmd, [`build --input src/mod.ts --someBoolean`]);
- *
- * // ✅ Subcommand with positional arguments
- * await runCmdWithSubcommands(cmd, [`build src/mod.ts --someBoolean`]);
- *
- * // ✅ Nested subcommands
- * await runCmdWithSubcommands(cmd, [`build someSubCmd src/mod.ts --no-cjs`]);
- * await runCmdWithSubcommands(cmd, [`build sub1 sub2 sub3 file.ts --flag`]);
- *
- * // ✅ Mixed array with subcommands
- * await runCmdWithSubcommands(cmd, [
- *   `build someSubCmd src/mod.ts`,
- *   "--no-cjs",
- *   "--verbose"
- * ]);
- * ```
- */
-declare function runCmdWithSubcommands<A extends ArgDefinitions = EmptyArgs>(command: Command<A>, argv?: string[], parserOptions?: ReliArgParserOptions & {
-    fileBased?: FileBasedOptions;
-    autoExit?: boolean;
-}): Promise<any>;
-/**
- * Programmatically run a command's run() handler with parsed arguments.
- * Does not handle subcommands, file-based commands, or global hooks.
- * Suitable for use in demos, tests, or programmatic invocation.
- *
- * @param command The command definition (from defineCommand)
- * @param argv The argv array to parse (default: []). Each argument should be a separate array element.
- * @param parserOptions Optional reliArgParser options
- *
- * @example
- * **each argument as separate array element**:
- * ```ts
- * await runCmd(cmd, ["--dev", "true"]);
- * await runCmd(cmd, ["--name", "John", "--verbose"]);
- * ```
- * **automatic normalization of template literals**:
- * ```ts
- * await runCmd(cmd, [`--dev ${isDev}`]); // Automatically converted to ["--dev", "true"]
- * await runCmd(cmd, [`--dev ${isDev} --build mod.ts`]); // ["--dev", "true", "--build", "mod.ts"]
- * ```
- */
-declare function runCmd<A extends ArgDefinitions = EmptyArgs>(command: Command<A>, argv?: string[], parserOptions?: ReliArgParserOptions): Promise<void>;
 
 declare const runMain: typeof createCli;
 
-/** uses omelette to add completions to a commander program */
-declare function addCompletions(program: Command$1, completion: OmeletteInstanceLike): void;
-
-/** An error thrown when the trpc procedure results in a bad request */
-declare class CliValidationError extends Error {
-}
-/** An error which is only thrown when a custom \`process\` parameter is used. Under normal circumstances, this should not be used, even internally. */
-declare class FailedToExitError extends Error {
-    readonly exitCode: number;
-    constructor(message: string, { exitCode, cause }: {
-        exitCode: number;
-        cause: unknown;
-    });
-}
-
-declare class TrpcCommand extends Command$1 {
-    /** @internal track the commands that have been run, so that we can find the `__result` of the last command */
-    __ran: TrpcCommand[];
-    __input?: unknown;
-    /** @internal stash the return value of the underlying procedure on the command so to pass to `FailedToExitError` for use in a pinch */
-    __result?: unknown;
-}
-/**
- * @internal takes a trpc router and returns an object that you **could** use to build a CLI, or UI, or a bunch of other things with.
- * Officially, just internal for building a CLI. GLHF.
- */
-declare const parseRouter: <R extends AnyRouter>({ router, ...params }: TrpcCliParams<R>) => [string, ProcedureInfo][];
-interface ProcedureInfo {
-    meta: TrpcCliMeta;
-    parsedProcedure: ParsedProcedure;
-    incompatiblePairs: [string, string][];
-    procedure: {};
-}
-/**
- * Run a trpc router as a CLI.
- *
- * @param router A trpc router
- * @param context The context to use when calling the procedures - needed if your router requires a context
- * @param trpcServer The trpc server module to use. Only needed if using trpc v10.
- * @returns A CLI object with a `run` method that can be called to run the CLI. The `run` method will parse the command line arguments, call the appropriate trpc procedure, log the result and exit the process. On error, it will log the error and exit with a non-zero exit code.
- */
-declare function createRpcCli<R extends AnyRouter>({ router, ...params }: TrpcCliParams<R>): TrpcCli;
-
-declare const flattenedProperties: (sch: JsonSchema7Type) => JsonSchema7ObjectType["properties"];
-/** For a union type, returns a list of pairs of properties which *shouldn't* be used together (because they don't appear in the same type variant) */
-declare const incompatiblePropertyPairs: (sch: JsonSchema7Type) => [string, string][];
-/**
- * Tries fairly hard to build a roughly human-readable description of a json-schema type.
- * A few common properties are given special treatment, most others are just stringified and output in `key: value` format.
- */
-declare const getDescription: (v: JsonSchema7Type, depth?: number) => string;
-declare const getSchemaTypes: (propertyValue: JsonSchema7Type) => ("string" | "boolean" | "number" | (string & {}))[];
-declare const getEnumChoices: (propertyValue: JsonSchema7Type) => {
-    readonly type: "string_enum";
-    readonly choices: string[];
-} | {
-    readonly type: "number_enum";
-    readonly choices: number[];
-} | null;
-
-declare const lineByLineLogger: (logger: Logger) => Logger;
-/**
- * A logger which uses `console.log` and `console.error` to log in the following way:
- * - Primitives are logged directly
- * - Arrays are logged item-by-item
- * - Objects are logged as JSON
- *
- * This is useful for logging structured data in a human-readable way, and for piping logs to other tools.
- */
-declare const lineByLineConsoleLogger: Logger;
-
-declare function parseProcedureInputs(inputs: unknown[], dependencies: Dependencies): Result<ParsedProcedure>;
-
-interface Shadowed<T> {
-    original: T;
-    shadow: T;
-}
-type WithValue<T> = Shadowed<T> & {
-    value: string | undefined;
-    specified: boolean;
-};
-interface Analysis {
-    command: Shadowed<Command$1>;
-    arguments: WithValue<Argument>[];
-    options: WithValue<Option>[];
-}
-declare const createShadowCommand: (command: Command$1, onAnalyze: (params: Analysis) => void | Promise<void>) => Command$1;
-declare const promptify: (program: CommanderProgramLike, prompts: Promptable) => CommanderProgramLike;
-
-declare const prettifyStandardSchemaError: (error: unknown) => string | null;
-declare function toDotPath(path: (string | number | symbol)[]): string;
-declare class StandardSchemaV1Error extends Error implements StandardSchemaV1FailureResult {
-    issues: StandardSchemaV1FailureResult["issues"];
-    constructor(failure: StandardSchemaV1FailureResult, options?: {
-        cause?: Error;
-    });
-}
-
-declare const looksLikeStandardSchemaFailure: (error: unknown) => error is StandardSchemaV1FailureResult;
-declare const looksLikeStandardSchema: (thing: unknown) => thing is StandardSchemaV1;
-
-/**
- * Pretty much like the `instanceof` operator, but should work across different realms. Necessary for zod because some installations
- * might result in this library using the commonjs zod export, while the user's code uses the esm export.
- * https://github.com/mmkal/trpc-cli/issues/7
- *
- * Tradeoff: It's possible that this function will return false positives if the target class has the same name as an unrelated class in the current realm.
- * So, only use it for classes that are unlikely to have name conflicts like `ZodAbc` or `TRPCDef`.
- */
-declare const looksLikeInstanceof: <T>(value: unknown, target: string | (new (...args: any[]) => T)) => value is T;
-
 declare const log: _reliverse_relinka.RelinkaFunction;
 
 /**
@@ -2329,5 +1749,5 @@ declare function createAsciiArt({ message, font, clearConsole, }: {
     clearConsole?: boolean;
 }): Promise<void>;
 
-export { CANCEL, CliValidationError, FailedToExitError, StandardSchemaV1Error, TrpcCommand, addCompletions, animateText, animationMap, anykeyPrompt, applyVariant, argsToStringArray, bar, block, breakLines, callCmdImpl, cancel, colorMap, colorize, commandToJSON, completePrompt, confirm, confirmPrompt, countLines, createAsciiArt, createCallCmd, createCancel, createCli, createGetTypedCmd, createMultiStep, createRpcCli, createShadowCommand, createStep, datePrompt, defineArgs, defineCommand, deleteLastLine, deleteLastLines, endPrompt, errorHandler, fallbackSymbols, figures, flattenedProperties, fmt, getColumns, getDescription, getEnumChoices, getExactTerminalWidth, getSchemaTypes, getTerminalHeight, getTerminalWidth, getTypedCmdImpl, group, incompatiblePropertyPairs, input, inputPrompt, intro, introPrompt, isCancel, isOrpcRouter, isTerminalInteractive, isTrpc11Procedure, isTrpc11Router, isValidName, isValidVariant, isWindows, lineByLineConsoleLogger, lineByLineLogger, loadCommand, log, looksLikeInstanceof, looksLikeStandardSchema, looksLikeStandardSchemaFailure, mainSymbols, msg, msgUndo, msgUndoAll, multiselect, multiselectPrompt, nextStepsPrompt, normalizeName, numMultiSelectPrompt, numSelectPrompt, numberPrompt, outro, outroPrompt, parseProcedureInputs, parseRouter, password, pm, prettifyStandardSchemaError, preventUnsupportedTTY, preventWindowsHomeDirRoot, preventWrongTerminalSize, printLineBar, promptify, relinkaAsyncByRemptsDeprecated, relinkaByRemptsDeprecated, reliversePrompts, removeCursor, renderEndLine, renderEndLineInput, restoreCursor, resultPrompt, runCmd, runCmdWithSubcommands, runMain, select, selectPrompt, selectSimple, setRawMode, showUsage, spinner, startEditor, startPrompt, streamText, streamTextBox, streamTextWithSpinner, symbols, taskProgressPrompt, taskSpinPrompt, text, throwError, toBaseColor, toDotPath, toSolidColor, togglePrompt, typographyMap, useSpinner, variantMap };
-export type { AllKinds, AnyProcedure, AnyRouter, ArgDefinition, ArgDefinitions, ArrayArgDefinition, BaseArgDefinition, BaseArgProps, BooleanArgDefinition, BorderColorName, CancelValue, ChoiceOptions, ClackPromptsLike, ColorName, Command, CommandContext, CommandHook, CommandJSON, CommandMeta, CommandRun, CommandSpec, CommanderProgramLike, CommandsMap, ConfirmPromptOptions, CreateCallerFactoryLike, DatePromptOptions, DefineCommandOptions, Dependencies, EditorExitResult, EmptyArgs, EnquirerLike, FileBasedOptions, FmtMsgOptions, GroupContext, GroupOptions, GroupStep, GroupSteps, InferArgTypes, InputPromptOptions, InquirerPromptOptions, InquirerPromptsLike, Log, Logger, MessageConfig, MessageKind, MsgConfig, MsgType, MultiselectPromptParams, NumberArgDefinition, OmeletteInstanceLike, OrpcProcedureLike, OrpcRouterLike, OutputColor, ParsedProcedure, PositionalArgDefinition, PreventWrongTerminalSizeOptions, ProgressBar, ProgressBarOptions, PromptContext, PromptOptions, PromptType, Promptable, Prompter, PromptsLike, RenderParams, Result, ResultsType, SelectOption, SelectPromptParams, SeparatorOption, StandardColor, StandardSchemaV1, StandardSchemaV1FailureResult, StandardSchemaV1InferInput, StandardSchemaV1InferOutput, StandardSchemaV1Issue, StandardSchemaV1PathSegment, StandardSchemaV1Props, StandardSchemaV1Result, StandardSchemaV1SuccessResult, StandardSchemaV1Types, StreamOptions, StreamTextOptions, StringArgDefinition, SymbolName, Symbols, TogglePromptParams, Trpc10ProcedureLike, Trpc10RouterLike, Trpc11ProcedureLike, Trpc11ProcedureRecordLike, Trpc11RouterLike, TrpcCli, TrpcCliMeta, TrpcCliParams, TrpcCliRunParams, TrpcServerModuleLike, TypographyName, VariantName$1 as VariantName, inferRouterContext };
+export { CANCEL, animateText, animationMap, anykeyPrompt, applyVariant, bar, block, breakLines, callCmd, cancel, colorMap, colorize, completePrompt, confirm, confirmPrompt, countLines, createAsciiArt, createCancel, createCli, createMultiStep, createStep, datePrompt, defineArgs, defineCommand, deleteLastLine, deleteLastLines, endPrompt, errorHandler, fallbackSymbols, figures, fmt, getColumns, getExactTerminalWidth, getTerminalHeight, getTerminalWidth, group, input, inputPrompt, intro, introPrompt, isCancel, isTerminalInteractive, isValidName, isValidVariant, isWindows, log, mainSymbols, msg, msgUndo, msgUndoAll, multiselect, multiselectPrompt, nextStepsPrompt, normalizeName, numMultiSelectPrompt, numSelectPrompt, numberPrompt, outro, outroPrompt, password, pm, preventUnsupportedTTY, preventWindowsHomeDirRoot, preventWrongTerminalSize, printLineBar, relinkaAsyncByRemptsDeprecated, relinkaByRemptsDeprecated, reliversePrompts, removeCursor, renderEndLine, renderEndLineInput, restoreCursor, resultPrompt, runMain, select, selectPrompt, selectSimple, setRawMode, showUsage, spinner, startEditor, startPrompt, streamText, streamTextBox, streamTextWithSpinner, symbols, taskProgressPrompt, taskSpinPrompt, text, throwError, toBaseColor, toSolidColor, togglePrompt, typographyMap, useSpinner, variantMap };
+export type { AllKinds, ArgDefinition, ArgDefinitions, ArrayArgDefinition, BaseArgDefinition, BaseArgProps, BooleanArgDefinition, BorderColorName, CallCmdOptions, CancelValue, ChoiceOptions, ColorName, Command, CommandContext, CommandHook, CommandMeta, CommandRun, CommandSpec, CommandsMap, ConfirmPromptOptions, DatePromptOptions, DefineCommandOptions, EditorExitResult, EmptyArgs, FileBasedOptions, FmtMsgOptions, GroupContext, GroupOptions, GroupStep, GroupSteps, InferArgTypes, InputPromptOptions, MessageConfig, MessageKind, MsgConfig, MsgType, MultiselectPromptParams, NumberArgDefinition, OutputColor, PositionalArgDefinition, PreventWrongTerminalSizeOptions, ProgressBar, ProgressBarOptions, PromptOptions, PromptType, RenderParams, ResultsType, SelectOption, SelectPromptParams, SeparatorOption, StandardColor, StreamOptions, StreamTextOptions, StringArgDefinition, SymbolName, Symbols, TogglePromptParams, TypographyName, VariantName$1 as VariantName };