unicommand 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,609 @@
+import { ZodType, z } from 'zod';
+export { z } from 'zod';
+import { Program, CreateOptionCommandOpts, Command } from '@caporal/core';
+
+type CompletionConfig = {
+    binNames?: readonly string[];
+};
+declare const registerCompletionCommand: (program: Program, config?: CompletionConfig) => void;
+
+declare const setProgramExamples: (program: Program, examples: string[]) => void;
+declare const isGlobalHelpRequest: (args: readonly string[]) => boolean;
+declare const printProgramHelp: (program: Program) => Promise<void>;
+
+type JsonSchemaProperty = {
+    type: 'array' | 'boolean' | 'number' | 'string';
+    description?: string;
+    items?: {
+        type: 'string';
+    };
+};
+type CommandArgumentDefinition = {
+    synopsis: string;
+    description: string;
+};
+type CommandOptionDefinition = {
+    name: string;
+    description: string;
+    aliases?: readonly string[];
+    config?: CreateOptionCommandOpts;
+    negated?: boolean;
+    schema?: JsonSchemaProperty;
+    value?: string;
+};
+type CommandMcpToolMetadata = {
+    kind: 'tool';
+    readOnly: boolean;
+    destructive: boolean;
+    idempotent: boolean;
+    openWorld: boolean;
+    requiresConfirmation: boolean;
+    sideEffects?: string[];
+};
+type CommandMcpResourceMetadata = {
+    kind: 'resource';
+    uriTemplate: string;
+    mimeType?: string;
+};
+type CommandMcpMetadata = false | CommandMcpToolMetadata | CommandMcpResourceMetadata;
+declare const isCommandMcpToolMetadata: (metadata: CommandMcpMetadata | undefined) => metadata is CommandMcpToolMetadata;
+declare const isCommandMcpResourceMetadata: (metadata: CommandMcpMetadata | undefined) => metadata is CommandMcpResourceMetadata;
+type ShellCompletionSnippet = {
+    complete: string;
+    functions?: string;
+};
+type CommandCompletionDefinition = {
+    bash?: (binName: string) => string;
+    fish?: (binName: string) => ShellCompletionSnippet;
+    zsh?: (binName: string) => ShellCompletionSnippet;
+};
+type CommandExamplesDefinition = (binName: string) => readonly string[];
+type CommandDefinition<TInputSchema extends ZodType = ZodType, TOutputSchema extends ZodType = ZodType> = {
+    name: string;
+    description: string;
+    aliases?: readonly string[];
+    arguments?: readonly CommandArgumentDefinition[];
+    completion?: CommandCompletionDefinition;
+    config?: Parameters<Program['command']>[2];
+    examples?: CommandExamplesDefinition;
+    inputSchema: TInputSchema;
+    mcp?: CommandMcpMetadata;
+    options?: readonly CommandOptionDefinition[];
+    order?: number;
+    outputSchema: TOutputSchema;
+};
+type DefineCommandDefinition<TInputSchema extends ZodType = ZodType, TOutputSchema extends ZodType = ZodType> = Omit<CommandDefinition<TInputSchema, TOutputSchema>, 'inputSchema' | 'outputSchema'> & {
+    inputSchema?: TInputSchema;
+    outputSchema?: TOutputSchema;
+};
+declare const defineCommand: <TInputSchema extends ZodType = ZodType, TOutputSchema extends ZodType = ZodType>(definition: DefineCommandDefinition<TInputSchema, TOutputSchema>) => CommandDefinition<TInputSchema, TOutputSchema>;
+declare const registerCommand: (program: Program, definition: CommandDefinition) => Command;
+declare const commandInputValue: (args: Record<string, unknown>, name: string) => unknown;
+declare const commandInputString: (args: Record<string, unknown>, name: string) => string;
+declare const commandActionInput: (definition: CommandDefinition, args: Record<string, unknown>, options: Record<string, unknown>) => {
+    [x: string]: unknown;
+} & {
+    [k: string]: unknown;
+};
+declare const normalizeCommandInputAliases: <TInput extends Record<string, unknown>>(definition: CommandDefinition, input: TInput) => TInput & {
+    [k: string]: unknown;
+};
+declare const commandDefinitionToZodInputSchema: (definition: CommandDefinition) => z.ZodObject<{
+    [x: string]: ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$strip>;
+declare const commandDefinitionToInputSchema: (definition: CommandDefinition) => {
+    type: string;
+    properties: any;
+    required: string[];
+    additionalProperties: boolean;
+};
+declare const commandOptionSynopsis: (option: CommandOptionDefinition) => string;
+
+type CommandRegistrarContext$1<TContext> = {
+    binName: string;
+    getContext?: () => Promise<TContext> | TContext;
+};
+type CommandRegistrar<TContext> = (program: Program, context: CommandRegistrarContext$1<TContext>) => void;
+type RegisterCliCommandsFromDirectoryOptions<TContext> = {
+    binName: string;
+    commandsDir: string;
+    getContext?: () => Promise<TContext> | TContext;
+    program: Program;
+};
+type CreateCommandProgramOptions<TContext> = {
+    binName: string;
+    binNames?: readonly string[];
+    commandsDir?: string;
+    description: string;
+    getContext?: () => Promise<TContext> | TContext;
+    importMetaUrl: string;
+    isDevRun?: boolean;
+    packageName?: string;
+    printVersion?: (version: string) => void;
+    version?: string;
+};
+type RegisterParentCommandsFromDefinitionsOptions = {
+    description?: (name: string) => string;
+    print?: (message: string) => void;
+};
+declare const createCommandProgram: <TContext>({ binName, binNames, commandsDir, description, getContext, importMetaUrl, isDevRun, packageName, printVersion, version, }: CreateCommandProgramOptions<TContext>) => Promise<Program>;
+declare const registerParentCommandsFromDefinitions: (program: Program, definitions: readonly CommandDefinition[], options?: RegisterParentCommandsFromDefinitionsOptions) => void;
+declare const registerCliCommandsFromDirectory: <TContext>({ binName, commandsDir, getContext, program, }: RegisterCliCommandsFromDirectoryOptions<TContext>) => Promise<CommandDefinition[]>;
+declare const getProgramConstructor: () => new () => Program;
+
+type CliConfig<TProgram> = {
+    createProgram: (binName: string) => TProgram | Promise<TProgram>;
+    defaultBinName: string;
+    envBinName: string;
+    importMetaUrl: string;
+};
+declare const getProgramBin: (config: Pick<CliConfig<unknown>, "defaultBinName" | "envBinName" | "importMetaUrl">) => string;
+declare const isDirectRun: (importMetaUrl: string) => boolean;
+
+type CreateCommandCliRunnerOptions<TContext> = {
+    binNames?: readonly string[];
+    commandsDir?: string;
+    defaultBinName: string;
+    description: string;
+    envBinName: string;
+    getContext?: () => Promise<TContext> | TContext;
+    importMetaUrl: string;
+    isDevRun?: boolean;
+    packageName?: string;
+    printVersion?: (version: string) => void;
+    version?: string;
+};
+type CreatePackageCommandCliRunnerOptions<TContext> = Omit<CreateCommandCliRunnerOptions<TContext>, 'defaultBinName' | 'description' | 'envBinName'> & {
+    defaultBinName?: string;
+    description?: string;
+    envBinName?: string;
+};
+declare const createCliRunner: (config: CliConfig<Program>) => {
+    isDirectRun: () => boolean;
+    runCli: (args?: string[]) => Promise<number>;
+};
+declare const createPackageCommandCliRunner: <TContext>({ defaultBinName, envBinName, importMetaUrl, ...options }: CreatePackageCommandCliRunnerOptions<TContext>) => {
+    isDirectRun: () => boolean;
+    runCli: (args?: string[]) => Promise<number>;
+};
+declare const createCommandCliRunner: <TContext>({ binNames, commandsDir, defaultBinName, description, envBinName, getContext, importMetaUrl, isDevRun, packageName, printVersion, version, }: CreateCommandCliRunnerOptions<TContext>) => {
+    isDirectRun: () => boolean;
+    runCli: (args?: string[]) => Promise<number>;
+};
+
+declare enum PackageManager {
+    Npm = "npm",
+    Pnpm = "pnpm",
+    Yarn = "yarn"
+}
+type RegisterUpdateCommandOptions = {
+    isDevRun: boolean;
+    packageName: string;
+    version?: string;
+};
+declare const registerUpdateCommand: (program: Program, options: RegisterUpdateCommandOptions) => void;
+declare function getPackageManagerFromPath(globalBinPath: string): PackageManager | null;
+
+type McpToolDefinition = {
+    name: string;
+    description: string;
+    inputSchema: unknown;
+    outputSchema: unknown;
+    annotations?: {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+        requiresConfirmation?: boolean;
+        sideEffects?: string[];
+    };
+};
+type JsonRpcRequest = {
+    id?: number | string;
+    jsonrpc?: '2.0';
+    method?: string;
+    params?: unknown;
+};
+type ToolCallParams = {
+    name?: string;
+    arguments?: Record<string, unknown>;
+};
+type McpResultEnvelope = {
+    data: unknown;
+    progress?: Record<string, unknown>;
+};
+type McpResourceDefinition = {
+    uri: string;
+    name: string;
+    description: string;
+    mimeType: string;
+};
+type McpResourceTemplateDefinition = {
+    uriTemplate: string;
+    name: string;
+    description: string;
+    mimeType: string;
+};
+type ResourceReadParams = {
+    uri?: string;
+};
+type CommandResourceRoute = {
+    command: CommandDefinition;
+    handler: (args: Record<string, unknown>) => Promise<unknown> | unknown;
+    inputNames: string[];
+    mimeType: string;
+    name: string;
+    uriTemplate: string;
+};
+type CreateMcpServerOptions = {
+    name: string;
+    tools: McpToolDefinition[];
+    resources?: McpResourceDefinition[];
+    resourceTemplates?: McpResourceTemplateDefinition[];
+    callTool: (params: unknown) => Promise<unknown> | unknown;
+    readResource?: (params: unknown) => Promise<unknown> | unknown;
+};
+type CreateSingleToolMcpServerOptions = {
+    serverName: string;
+    tool: McpToolDefinition;
+    callTool: (args: Record<string, unknown>) => Promise<unknown> | unknown;
+};
+type CreateCommandMcpServerOptions<TContext> = {
+    commandsDir?: string;
+    getContext?: () => Promise<TContext> | TContext;
+    importMetaUrl: string;
+    name: string;
+    prefix?: string;
+};
+type CreatePackageCommandMcpServerOptions<TContext> = Omit<CreateCommandMcpServerOptions<TContext>, 'name' | 'prefix'> & {
+    mcpServerPrefix?: string;
+    name?: string;
+    prefix?: string;
+};
+type CommandMcpRoute = {
+    command: CommandDefinition;
+    inputSchema: ZodType;
+    outputSchema: ZodType;
+    handler: (args: Record<string, unknown>) => Promise<unknown> | unknown;
+};
+type CommandMcpRouteFactory<TContext> = (getContext: () => Promise<TContext> | TContext) => CommandMcpRoute;
+type CreateCommandMcpRouterOptions = {
+    prefix?: string;
+    routes: readonly CommandMcpRoute[];
+};
+
+type ContextFactory<TContext> = () => Promise<TContext> | TContext;
+type Handler<TInput, TResult> = {
+    handle(input: TInput): Promise<TResult> | TResult;
+}['handle'];
+type ContextHandler<TContext, TInput, TResult> = {
+    handle(context: TContext, input: TInput): Promise<TResult> | TResult;
+}['handle'];
+type CommandRegistrarContext<TContext> = {
+    binName?: string;
+    getContext?: ContextFactory<TContext>;
+};
+type CommandAdaptersReturn<TContext, THandler> = {
+    cli: (program: Program, context?: CommandRegistrarContext<TContext>) => void;
+    handler: THandler;
+    mcp: (getContext?: ContextFactory<TContext>) => CommandMcpRoute;
+    metadata: CommandDefinition;
+};
+type CommandPrint<TContext, TInputSchema extends ZodType, TResult> = (output: TResult, input: z.infer<TInputSchema>, context?: TContext) => Promise<void> | void;
+type BaseCommandAdaptersOptions<TInputSchema extends ZodType, TOutputSchema extends ZodType, TResult> = {
+    metadata: CommandDefinition<TInputSchema, TOutputSchema>;
+    print?: CommandPrint<unknown, TInputSchema, TResult>;
+};
+type CommandAdaptersOptions<TInputSchema extends ZodType, TOutputSchema extends ZodType, TResult> = BaseCommandAdaptersOptions<TInputSchema, TOutputSchema, TResult> & {
+    handler: Handler<z.infer<TInputSchema>, TResult>;
+};
+type ContextCommandAdaptersOptions<TContext, TInputSchema extends ZodType, TOutputSchema extends ZodType, TResult> = Omit<BaseCommandAdaptersOptions<TInputSchema, TOutputSchema, TResult>, 'print'> & {
+    handler: ContextHandler<TContext, z.infer<TInputSchema>, TResult>;
+    print?: CommandPrint<TContext, TInputSchema, TResult>;
+};
+declare function createCommandAdapters<TInputSchema extends ZodType = ZodType<Record<string, unknown>>, TOutputSchema extends ZodType = ZodType, TResult = unknown>(options: CommandAdaptersOptions<TInputSchema, TOutputSchema, TResult>): CommandAdaptersReturn<unknown, Handler<z.infer<TInputSchema>, TResult>>;
+declare function createCommandAdapters<TContext, TInputSchema extends ZodType = ZodType<Record<string, unknown>>, TOutputSchema extends ZodType = ZodType, TResult = unknown>(options: ContextCommandAdaptersOptions<TContext, TInputSchema, TOutputSchema, TResult>): CommandAdaptersReturn<TContext, ContextHandler<TContext, z.infer<TInputSchema>, TResult>>;
+
+type CommandModule = Record<string, unknown>;
+type CommandAdapterExport = Pick<CommandAdaptersReturn<unknown, unknown>, 'cli'> & Partial<Pick<CommandAdaptersReturn<unknown, unknown>, 'mcp' | 'metadata'>>;
+declare const loadCommandModules: (commandsDir: string) => Promise<CommandModule[]>;
+declare const loadCommandModulesFromFiles: (files: readonly string[]) => Promise<CommandModule[]>;
+declare const commandDefinitionsFromModules: (modules: readonly CommandModule[]) => CommandDefinition[];
+declare const commandExportsFromModules: <TExport>(modules: readonly CommandModule[], isExport: (name: string, value: unknown) => boolean) => TExport[];
+declare const isCommandAdapterExport: (value: unknown) => value is CommandAdapterExport;
+
+declare const DEFAULT_COMMANDS_DIR = "commands";
+declare const PROGRAM_NAME_ENV_SUFFIX = "_PROG_NAME";
+
+type GenerateReadmeCommandDocsOptions = {
+    binName: string;
+    commandDefinitions?: readonly CommandDefinition[];
+    commandsDir?: string;
+    markerName?: string;
+    readmePath?: string;
+};
+declare const generateReadmeCommandDocs: ({ binName, commandDefinitions, commandsDir, markerName, readmePath, }: GenerateReadmeCommandDocsOptions) => Promise<void>;
+declare const formatCommandDocs: (commands: readonly CommandDefinition[], binName: string) => string;
+
+declare const loadCommandMcpRoutes: <TContext>(commandsDir: string, getContext?: () => Promise<TContext> | TContext) => Promise<CommandMcpRoute[]>;
+declare const createCommandMcpServer: <TContext>({ commandsDir, getContext, importMetaUrl, name, prefix, }: CreateCommandMcpServerOptions<TContext>) => Promise<{
+    start: () => Promise<void>;
+}>;
+declare const startCommandMcpServer: <TContext>(options: CreateCommandMcpServerOptions<TContext>) => Promise<void>;
+declare const startPackageCommandMcpServer: <TContext>({ importMetaUrl, mcpServerPrefix, name, prefix, ...options }: CreatePackageCommandMcpServerOptions<TContext>) => Promise<void>;
+
+declare const assertToolName: (expectedName: string, actualName: string | undefined) => void;
+declare const throwUnknownTool: (name: string | undefined) => never;
+
+declare const commandMcpRouteToResourceRoute: (route: CommandMcpRoute) => CommandResourceRoute[];
+declare const commandResourceRouteToResource: (route: CommandResourceRoute) => McpResourceDefinition;
+declare const commandResourceRouteToResourceTemplate: (route: CommandResourceRoute) => McpResourceTemplateDefinition;
+declare const commandResourceInput: (route: CommandResourceRoute, uri: string | undefined) => {
+    [k: string]: string;
+} | undefined;
+declare const isResourceTemplate: (uri: string) => boolean;
+declare const resourceResult: (params: unknown, data: unknown) => {
+    contents: {
+        uri: string;
+        mimeType: string;
+        text: string;
+    }[];
+};
+
+declare const createCommandMcpRoute: ({ command, handler, inputSchema, outputSchema, }: CommandMcpRoute) => CommandMcpRoute;
+declare const commandMcpRouteToTool: (route: CommandMcpRoute, prefix?: string) => {
+    name: string;
+    description: string;
+    inputSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    outputSchema: {
+        type: string;
+        properties: {
+            data: z.core.ZodStandardJSONSchemaPayload<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+            progress: {
+                type: string;
+                properties: {
+                    count: {
+                        type: string;
+                    };
+                    elapsedMs: {
+                        type: string;
+                    };
+                    changed: {
+                        type: string;
+                    };
+                    errors: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                    matched: {
+                        type: string;
+                    };
+                    nextCursor: {
+                        type: string;
+                    };
+                    processed: {
+                        type: string;
+                    };
+                    skipped: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            status: {
+                type: string;
+                enum: string[];
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+        requiresConfirmation: boolean;
+        sideEffects: string[] | undefined;
+    } | undefined;
+};
+declare const commandNameToMcpToolName: (name: string, prefix?: string) => string;
+declare const createCommandMcpRouter: ({ prefix, routes }: CreateCommandMcpRouterOptions) => {
+    tools: {
+        name: string;
+        description: string;
+        inputSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        outputSchema: {
+            type: string;
+            properties: {
+                data: z.core.ZodStandardJSONSchemaPayload<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+                progress: {
+                    type: string;
+                    properties: {
+                        count: {
+                            type: string;
+                        };
+                        elapsedMs: {
+                            type: string;
+                        };
+                        changed: {
+                            type: string;
+                        };
+                        errors: {
+                            type: string;
+                            items: {
+                                type: string;
+                            };
+                        };
+                        matched: {
+                            type: string;
+                        };
+                        nextCursor: {
+                            type: string;
+                        };
+                        processed: {
+                            type: string;
+                        };
+                        skipped: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                };
+                status: {
+                    type: string;
+                    enum: string[];
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+            requiresConfirmation: boolean;
+            sideEffects: string[] | undefined;
+        } | undefined;
+    }[];
+    resources: McpResourceDefinition[];
+    resourceTemplates: McpResourceTemplateDefinition[];
+    callTool: (params: unknown) => Promise<{
+        data: unknown;
+        progress: {
+            changed: number;
+            matched: number;
+            processed: number;
+            skipped: number;
+        } | undefined;
+    }>;
+    readResource: (params: unknown) => Promise<unknown>;
+};
+
+declare const mcpToolOutputSchema: (dataSchema: ZodType) => {
+    type: string;
+    properties: {
+        data: z.core.ZodStandardJSONSchemaPayload<ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        progress: {
+            type: string;
+            properties: {
+                count: {
+                    type: string;
+                };
+                elapsedMs: {
+                    type: string;
+                };
+                changed: {
+                    type: string;
+                };
+                errors: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                };
+                matched: {
+                    type: string;
+                };
+                nextCursor: {
+                    type: string;
+                };
+                processed: {
+                    type: string;
+                };
+                skipped: {
+                    type: string;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+        status: {
+            type: string;
+            enum: string[];
+        };
+    };
+    required: string[];
+    additionalProperties: boolean;
+};
+declare const emptyMcpInputSchema: {
+    readonly type: "object";
+    readonly properties: {};
+    readonly required: readonly [];
+    readonly additionalProperties: false;
+};
+
+declare const createSingleToolMcpServer: ({ serverName, tool, callTool, }: CreateSingleToolMcpServerOptions) => {
+    start: () => Promise<void>;
+};
+declare const createMcpServer: ({ name, tools, resources, resourceTemplates, callTool, readResource, }: CreateMcpServerOptions) => {
+    start: () => Promise<void>;
+};
+
+type PackageJson = {
+    bin?: Record<string, string>;
+    description?: string;
+    name?: string;
+    version?: string;
+};
+type PackageBinEntry = {
+    binPath: string;
+    commandName: string;
+};
+declare const packageRoot: (importMetaUrl: string) => string;
+declare const readPackageJson: (packageDir: string) => PackageJson;
+declare const shortPackageName: (name?: string) => string;
+declare const packageEnvPrefix: (name?: string) => string;
+declare const packageBinEntry: (packageDir: string, packageJson: PackageJson) => PackageBinEntry;
+
+type PackageCommandMetadata = {
+    binName: string;
+    binNames: string[];
+    description?: string;
+    envBinName: string;
+    mcpPrefix: string;
+    mcpServerName: string;
+    packageDir: string;
+    packageName: string;
+    version?: string;
+};
+type PackageCommandMetadataOptions = {
+    mcpServerPrefix?: string;
+};
+declare const packageCommandMetadata: (importMetaUrl: string, options?: PackageCommandMetadataOptions) => PackageCommandMetadata;
+
+type DevCommandConfig = {
+    binDirEnvName: string;
+    cliPath: string;
+    commandName: string;
+    packageDir: string;
+    programNameEnvName: string;
+};
+type PackageDevCommandOptions = {
+    commandName: string;
+};
+type PackageDevCommandsOptions = {
+    commandNames: readonly string[];
+};
+declare const installDevCommand: (config: DevCommandConfig) => void;
+declare const installPackageDevCommand: (importMetaUrl: string, options: PackageDevCommandOptions) => void;
+declare const installPackageDevCommands: (importMetaUrl: string, options: PackageDevCommandsOptions) => void;
+declare const uninstallDevCommand: (config: Pick<DevCommandConfig, "binDirEnvName" | "commandName">) => void;
+declare const uninstallPackageDevCommand: (importMetaUrl: string, options: PackageDevCommandOptions) => void;
+declare const uninstallPackageDevCommands: (importMetaUrl: string, options: PackageDevCommandsOptions) => void;
+
+type DevCommandShimConfig = {
+    cliPath: string;
+    commandName: string;
+    packageDir: string;
+    programNameEnvName: string;
+};
+declare const installCommandShim: (binDir: string, config: DevCommandShimConfig) => void;
+declare const getBinDir: (envName: string) => string;
+
+export { type CliConfig, type CommandAdapterExport, type CommandAdaptersReturn, type CommandArgumentDefinition, type CommandCompletionDefinition, type CommandDefinition, type CommandExamplesDefinition, type CommandMcpMetadata, type CommandMcpResourceMetadata, type CommandMcpRoute, type CommandMcpRouteFactory, type CommandMcpToolMetadata, type CommandModule, type CommandOptionDefinition, type CommandRegistrar, type CommandRegistrarContext$1 as CommandRegistrarContext, type CommandResourceRoute, type CompletionConfig, type CreateCommandMcpRouterOptions, type CreateCommandMcpServerOptions, type CreateCommandProgramOptions, type CreateMcpServerOptions, type CreatePackageCommandMcpServerOptions, type CreateSingleToolMcpServerOptions, DEFAULT_COMMANDS_DIR, type DefineCommandDefinition, type DevCommandShimConfig, type GenerateReadmeCommandDocsOptions, type JsonRpcRequest, type JsonSchemaProperty, type McpResourceDefinition, type McpResourceTemplateDefinition, type McpResultEnvelope, type McpToolDefinition, PROGRAM_NAME_ENV_SUFFIX, type PackageBinEntry, type PackageCommandMetadata, type PackageJson, PackageManager, type RegisterCliCommandsFromDirectoryOptions, type RegisterParentCommandsFromDefinitionsOptions, type RegisterUpdateCommandOptions, type ResourceReadParams, type ShellCompletionSnippet, type ToolCallParams, assertToolName, commandActionInput, commandDefinitionToInputSchema, commandDefinitionToZodInputSchema, commandDefinitionsFromModules, commandExportsFromModules, commandInputString, commandInputValue, commandMcpRouteToResourceRoute, commandMcpRouteToTool, commandNameToMcpToolName, commandOptionSynopsis, commandResourceInput, commandResourceRouteToResource, commandResourceRouteToResourceTemplate, createCliRunner, createCommandAdapters, createCommandCliRunner, createCommandMcpRoute, createCommandMcpRouter, createCommandMcpServer, createCommandProgram, createMcpServer, createPackageCommandCliRunner, createSingleToolMcpServer, defineCommand, emptyMcpInputSchema, formatCommandDocs, generateReadmeCommandDocs, getBinDir, getPackageManagerFromPath, getProgramBin, getProgramConstructor, installCommandShim, installDevCommand, installPackageDevCommand, installPackageDevCommands, isCommandAdapterExport, isCommandMcpResourceMetadata, isCommandMcpToolMetadata, isDirectRun, isGlobalHelpRequest, isResourceTemplate, loadCommandMcpRoutes, loadCommandModules, loadCommandModulesFromFiles, mcpToolOutputSchema, normalizeCommandInputAliases, packageBinEntry, packageCommandMetadata, packageEnvPrefix, packageRoot, printProgramHelp, readPackageJson, registerCliCommandsFromDirectory, registerCommand, registerCompletionCommand, registerParentCommandsFromDefinitions, registerUpdateCommand, resourceResult, setProgramExamples, shortPackageName, startCommandMcpServer, startPackageCommandMcpServer, throwUnknownTool, uninstallDevCommand, uninstallPackageDevCommand, uninstallPackageDevCommands };