@alcyone-labs/arg-parser 2.14.2 → 3.0.0

package/dist/core/ArgParser.d.ts

@@ -1,525 +1,185 @@
-import type { Application as ExpressApplication } from "express";
-import { type McpLoggerOptions } from "@alcyone-labs/simple-mcp-logger";
-import type { GenerateMcpToolsOptions, IMcpToolStructure } from "../mcp/mcp-integration";
-import type { McpLifecycleEvents } from "../mcp/mcp-lifecycle";
-import { ArgParserBase, type IArgParserParams } from "./ArgParserBase";
-import { type LogPath } from "./log-path-utils";
-import { type IMcpServerMethods } from "./types";
-import type { IFlag, IHandlerContext, OutputSchemaConfig } from "./types";
-export type { Application as ExpressApplication } from "express";
 /**
- * Configuration for a single MCP transport
- */
-export type CorsOptions = {
-    origins?: "*" | string | RegExp | Array<string | RegExp>;
-    methods?: string[];
-    headers?: string[];
-    exposedHeaders?: string[];
-    credentials?: boolean;
-    maxAge?: number;
-};
-export type JwtVerifyOptions = {
-    algorithms?: ("HS256" | "RS256")[];
-    secret?: string;
-    publicKey?: string;
-    getPublicKey?: (header: Record<string, unknown>, payload: Record<string, unknown>) => Promise<string> | string;
-    audience?: string | string[];
-    issuer?: string | string[];
-    clockToleranceSec?: number;
-};
-export type AuthOptions = {
-    required?: boolean;
-    scheme?: "bearer" | "jwt";
-    allowedTokens?: string[];
-    validator?: (req: any, token: string | undefined) => boolean | Promise<boolean>;
-    jwt?: JwtVerifyOptions;
-    publicPaths?: string[];
-    protectedPaths?: string[];
-    customMiddleware?: (req: any, res: any, next: any) => any;
-};
-export type McpTransportConfig = {
-    type: "stdio" | "sse" | "streamable-http";
-    port?: number;
-    host?: string;
-    path?: string;
-    sessionIdGenerator?: () => string;
-    cors?: CorsOptions;
-    auth?: AuthOptions;
-};
-/**
- * Configuration options for MCP sub-command
- */
-export type McpSubCommandOptions = {
-    /** Preset transport configurations to use when no CLI flags are provided */
-    defaultTransports?: McpTransportConfig[];
-    /** Single preset transport configuration (alternative to defaultTransports) */
-    defaultTransport?: McpTransportConfig;
-};
-/**
- * Extended server information for DXT package generation and MCP server metadata
- * This type includes logo support for MCP servers and DXT packages
- */
-export type DxtServerInfo = {
-    name: string;
-    version: string;
-    description?: string;
-    /** Author information for DXT manifest */
-    author?: {
-        name: string;
-        email?: string;
-        url?: string;
-    };
-    /** Repository information for DXT manifest */
-    repository?: {
-        type: string;
-        url: string;
-    };
-    /** License identifier for DXT manifest */
-    license?: string;
-    /** Homepage URL for DXT manifest */
-    homepage?: string;
-    /** Documentation URL for DXT manifest */
-    documentation?: string;
-    /** Support/issues URL for DXT manifest */
-    support?: string;
-    /** Keywords for DXT manifest */
-    keywords?: string[];
-    /**
-     * Logo/icon for DXT manifest and MCP server - can be a local file path or URL
-     * This is where logo support is provided for MCP-enabled ArgParser instances
-     */
-    logo?: string;
-};
-/**
- * Copy entry for DXT package bundling, compatible with TSDown's copy options
- */
-export type DxtCopyEntry = {
-    from: string;
-    to: string;
-};
-/**
- * Copy options for DXT package bundling, compatible with TSDown's copy options
- * @example
- * ```ts
- * [
- *   'migrations',
- *   { from: 'migrations', to: 'migrations' },
- *   { from: 'config/default.json', to: 'config/default.json' }
- * ]
- * ```
- */
-export type DxtCopyOptions = Array<string | DxtCopyEntry>;
-/**
- * DXT-specific configuration options
- */
-export type DxtOptions = {
-    /**
-     * Additional files and directories to include in the DXT package.
-     * Paths are relative to the project root (where package.json/tsconfig.json are located).
-     *
-     * @example
-     * ```ts
-     * include: [
-     *   'migrations',                                    // Copy entire migrations folder
-     *   { from: 'config/prod.json', to: 'config.json' }, // Copy and rename file
-     *   'assets/logo.png'                               // Copy specific file
-     * ]
-     * ```
-     */
-    include?: DxtCopyOptions;
-};
-/**
- * MCP server configuration options for withMcp() method
- * This centralizes MCP server metadata that was previously scattered across addMcpSubCommand calls
- */
-export type HttpServerOptions = {
-    configureExpress?: (app: ExpressApplication) => void;
-};
-export type McpServerOptions = {
-    /** MCP server metadata */
-    serverInfo?: DxtServerInfo;
-    /** Default transport configurations for the MCP server */
-    defaultTransports?: McpTransportConfig[];
-    /** Single default transport configuration (alternative to defaultTransports) */
-    defaultTransport?: McpTransportConfig;
-    /** Tool generation options for the MCP server */
-    toolOptions?: GenerateMcpToolsOptions;
-    /**
-     * Custom log file path for MCP server logs (default: "./logs/mcp.log" relative to entry point)
-     *
-     * @deprecated Use 'log' property instead for more comprehensive logging configuration
-     *
-     * Can be:
-     * - Simple string: "./logs/app.log" (relative to entry point)
-     * - Absolute path: "/tmp/app.log"
-     * - Explicit cwd: "cwd:./logs/app.log" (relative to process.cwd())
-     * - Config object: { path: "./logs/app.log", relativeTo: "entry" | "cwd" | "absolute" }
-     */
-    logPath?: LogPath;
-    /**
-     * MCP logger configuration options
-     *
-     * Can be:
-     * - Simple string: "./logs/app.log" (equivalent to logPath for backward compatibility)
-     * - Full options object: { level: "debug", logToFile: "./logs/app.log", prefix: "MyServer" }
-     *
-     * When both 'log' and 'logPath' are specified, they are merged intelligently:
-     * - 'log' provides logger options (level, prefix, mcpMode)
-     * - 'logPath' provides flexible path resolution (relativeTo, basePath)
-     * - If 'log' has logToFile, 'logPath' still takes precedence for path resolution
-     */
-    log?: string | McpLoggerOptions;
-    /**
-     * Lifecycle event handlers for MCP server operations
-     * These provide hooks for initialization, cleanup, and other lifecycle events
-     */
-    lifecycle?: McpLifecycleEvents;
-    /** DXT package configuration options */
-    dxt?: DxtOptions;
-    /** Optional HTTP server configuration hooks */
-    httpServer?: HttpServerOptions;
-};
-/**
- * Combined options for withMcp() method
+ * Core ArgParser implementation
+ *
+ * This is the main ArgParser class with full CLI parsing capabilities.
+ * It has NO dependencies on MCP, DXT, or TUI - those are provided by plugins.
  */
-export type WithMcpOptions<THandlerReturn = any> = IArgParserParams<THandlerReturn> & {
-    /** MCP-specific server configuration */
-    mcp?: McpServerOptions;
-};
+import type { IArgParserPlugin } from "../plugin/types";
+import type { IFlag, IHandlerContext, ISubCommand, ProcessedFlag, PromptWhen, TFlagInheritance } from "./types";
 /**
- * Type alias for clarity - ArgParser options with MCP capabilities
- * This provides a clearer name for WithMcpOptions
+ * Error thrown by ArgParser
  */
-export type ArgParserWithMcpOptions<THandlerReturn = any> = WithMcpOptions<THandlerReturn>;
+export declare class ArgParserError extends Error {
+    cmdChain: string[];
+    commandChain: string[];
+    constructor(message: string, cmdChain?: string[]);
+}
 /**
- * Configuration for an individual MCP tool (deprecated - use ToolConfig instead)
- * @deprecated Use ToolConfig and addTool() instead. Will be removed in v2.0.
+ * Parameters for creating an ArgParser
  */
-export type McpToolConfig = {
-    /**
-     * Tool name (must be unique within the server)
-     * Note: For MCP compatibility, names will be automatically sanitized to match ^[a-zA-Z0-9_-]{1,64}$
-     * Invalid characters will be replaced with underscores
-     */
-    name: string;
-    /** Tool description */
+export interface IArgParserParams<THandlerReturn = any> {
+    /** Display name of the application */
+    appName?: string;
+    /** Command name for help text */
+    appCommandName?: string;
+    /** Description of the application */
     description?: string;
-    /** Input schema for the tool (Zod schema) */
-    inputSchema?: any;
-    /** Output schema for the tool (Zod schema) */
-    outputSchema?: any;
-    /** Handler function for the tool */
-    handler: (args: any) => Promise<any> | any;
-};
+    /** Handler function */
+    handler?: (ctx: IHandlerContext<any, any>) => THandlerReturn | Promise<THandlerReturn>;
+    /** Subcommands */
+    subCommands?: ISubCommand[];
+    /** Extra newline between flag groups in help */
+    extraNewLine?: boolean;
+    /** Wrap help text at this width */
+    wrapAtWidth?: number;
+    /** Width of blank space in help */
+    blankSpaceWidth?: number;
+    /** Character for mandatory flags */
+    mandatoryCharacter?: string;
+    /** Throw error for duplicate flags */
+    throwForDuplicateFlags?: boolean;
+    /** Handle errors automatically */
+    handleErrors?: boolean;
+    /** Auto exit on parse result */
+    autoExit?: boolean;
+    /** Trigger auto-help if no handler */
+    triggerAutoHelpIfNoHandler?: boolean;
+    /** Flag inheritance behavior */
+    inheritParentFlags?: TFlagInheritance;
+    /** When to trigger interactive prompts */
+    promptWhen?: PromptWhen;
+    /** Cancel callback for prompts */
+    onCancel?: (ctx: IHandlerContext) => void | Promise<void>;
+}
 /**
- * Configuration for a unified tool that works in both CLI and MCP modes
+ * Parse options
  */
-export type ToolConfig = {
-    /**
-     * Tool name (CLI subcommand name & MCP tool name)
-     * Note: For MCP compatibility, names will be automatically sanitized to match ^[a-zA-Z0-9_-]{1,64}$
-     * Invalid characters will be replaced with underscores
-     */
-    name: string;
-    /** Tool description */
-    description?: string;
-    /** Flags for this tool (auto-converted to MCP schema) */
-    flags: readonly IFlag[];
-    /** Handler function for the tool */
-    handler: (ctx: IHandlerContext) => Promise<any> | any;
-    /** Output schema for this tool (predefined pattern, Zod schema, or schema definition object) */
-    outputSchema?: OutputSchemaConfig;
-};
+export interface IParseOptions {
+    /** Skip help handling */
+    skipHelpHandling?: boolean;
+    /** Skip handler execution */
+    skipHandlers?: boolean;
+    /** Await async handlers */
+    deep?: boolean;
+    /** MCP mode flag */
+    isMcp?: boolean;
+    /** Dynamic help preload */
+    dynamicHelpPreload?: boolean;
+    /** Auto execute */
+    autoExecute?: boolean;
+    /** Import meta URL */
+    importMetaUrl?: string;
+}
 /**
- * ArgParser with Model Context Protocol (MCP) integration capabilities.
+ * Core ArgParser class
  *
- * This class adds MCP server functionality on top of the standard ArgParser,
- * allowing CLI tools to be easily exposed as MCP tools with minimal boilerplate.
- *
- * @example
- * ```typescript
- * const parser = new ArgParser({
- *   appName: "My CLI",
- *   appCommandName: "my-cli",
- *   handler: async (ctx) => ({ result: "success" })
- * })
- *   .addFlags([...])
- *   .addMcpSubCommand("serve", {
- *     name: "my-cli-mcp-server",
- *     version: "1.0.0"
- *   });
- * ```
+ * Provides complete CLI argument parsing with support for:
+ * - Flags (with types, validation, defaults)
+ * - Subcommands
+ * - Interactive prompts
+ * - Help generation
+ * - Plugin system
  */
-export declare class ArgParser<THandlerReturn = any> extends ArgParserBase<THandlerReturn> implements IMcpServerMethods {
+export declare class ArgParser<THandlerReturn = any> {
     #private;
-    /** Stored MCP server configuration from withMcp() */
-    private _mcpServerConfig?;
-    /** Registered MCP tools (deprecated) */
-    private _mcpTools;
-    /** Registered unified tools */
-    private _tools;
-    /** Output schema management */
-    private _defaultOutputSchema?;
-    private _outputSchemaMap;
-    private _autoGenerateOutputSchema?;
-    /** MCP version for output schema compatibility */
-    private _mcpProtocolVersion;
-    /**
-     * Get the stored MCP server configuration
-     * @returns MCP server configuration if set via withMcp(), undefined otherwise
-     */
-    getMcpServerConfig(): McpServerOptions | undefined;
-    /**
-     * Set a default output schema for all MCP tools generated from this parser
-     * @param schema - Predefined pattern name, Zod schema, or schema definition object
-     * @returns This ArgParser instance for chaining
-     */
-    setDefaultOutputSchema(schema: OutputSchemaConfig): this;
-    /**
-     * Set an output schema for a specific tool/command
-     * @param toolName - Name of the tool/command
-     * @param schema - Predefined pattern name, Zod schema, or schema definition object
-     * @returns This ArgParser instance for chaining
-     */
-    setOutputSchema(toolName: string, schema: OutputSchemaConfig): this;
-    /**
-     * Enable automatic output schema generation for MCP tools
-     * @param pattern - True for default pattern, or specific pattern name
-     * @returns This ArgParser instance for chaining
-     */
-    enableAutoOutputSchema(pattern?: boolean | keyof typeof import("./types").OutputSchemaPatterns): this;
-    /**
-     * Set the MCP protocol version for compatibility checks
-     * @param version - MCP protocol version (e.g., "2025-06-18")
-     * @returns This ArgParser instance for chaining
-     */
-    setMcpProtocolVersion(version: string): this;
+    constructor(params?: IArgParserParams<THandlerReturn>, initialFlags?: readonly IFlag[]);
     /**
-     * Check if the current MCP protocol version supports output schemas
-     * Output schemas were introduced in MCP version 2025-06-18
-     * @returns true if output schemas are supported
+     * Install a plugin
      */
-    private supportsOutputSchemas;
+    use(plugin: IArgParserPlugin): this;
     /**
-     * Add a unified tool that works in both CLI and MCP modes
-     * In CLI mode, the tool becomes a subcommand with its own flags
-     * In MCP mode, the tool becomes an MCP tool with auto-generated schema
-     *
-     * @param toolConfig Configuration for the tool
-     * @returns This ArgParser instance for chaining
+     * Check if a plugin is installed
      */
-    addTool(toolConfig: ToolConfig): this;
+    hasPlugin(name: string): boolean;
     /**
-     * Add an MCP tool to this parser (deprecated)
-     * @deprecated Use addTool() instead. This method will be removed in v2.0.
-     * @param toolConfig Configuration for the MCP tool
-     * @returns This ArgParser instance for chaining
+     * Get an installed plugin
      */
-    addMcpTool(toolConfig: McpToolConfig): this;
+    getPlugin(name: string): IArgParserPlugin | undefined;
     /**
-     * Get all registered unified tools
-     * @returns Map of tool names to tool configurations
+     * List all installed plugins
      */
-    getTools(): Map<string, ToolConfig>;
+    listPlugins(): string[];
     /**
-     * Get all registered MCP tools (deprecated)
-     * @deprecated Use getTools() instead
-     * @returns Map of tool names to tool configurations
+     * Add a flag
      */
-    getMcpTools(): Map<string, McpToolConfig>;
+    addFlag(flag: IFlag): this;
     /**
-     * Get information about all available tools (unified, legacy MCP, and CLI-generated)
-     * @param options Optional configuration for MCP tool generation
-     * @returns Object with tool counts and names for debugging
+     * Add multiple flags
      */
-    getToolInfo(options?: GenerateMcpToolsOptions): {
-        unifiedTools: string[];
-        legacyMcpTools: string[];
-        cliTools: string[];
-        totalTools: number;
-        duplicates: string[];
-    };
+    addFlags(flags: readonly IFlag[]): this;
     /**
-     * Get information about all available MCP tools (legacy method)
-     * @deprecated Use getToolInfo() instead
-     * @param options Optional configuration for MCP tool generation
-     * @returns Object with tool counts and names for debugging
+     * Check if a flag exists
      */
-    getMcpToolInfo(options?: GenerateMcpToolsOptions): {
-        manualTools: string[];
-        cliTools: string[];
-        totalTools: number;
-        duplicates: string[];
-    };
+    hasFlag(name: string): boolean;
     /**
-     * Validate that all tools are properly registered and routable
-     * @returns Validation results
+     * Get a flag definition
      */
-    validateToolRouting(): {
-        isValid: boolean;
-        issues: string[];
-        cliSubcommands: string[];
-        mcpTools: string[];
-    };
+    getFlagDefinition(name: string): ProcessedFlag | undefined;
     /**
-     * Test tool routing by simulating a tool call
-     * This is useful for debugging and ensuring tools are properly registered
-     * @param toolName Name of the tool to test
-     * @param args Arguments to pass to the tool
-     * @returns Promise with the tool execution result or error
+     * Get all flags
      */
-    testMcpToolRouting(toolName: string, args?: any): Promise<{
-        success: boolean;
-        result?: any;
-        error?: string;
-        executionTime?: number;
-    }>;
+    get flags(): ProcessedFlag[];
     /**
-     * Generate MCP tools from this ArgParser instance
-     * @param options Optional configuration for MCP tool generation
-     * @returns Array of MCP tool structures ready for server registration
+     * Get all flag names
      */
-    toMcpTools(options?: GenerateMcpToolsOptions): IMcpToolStructure[];
+    get flagNames(): string[];
     /**
-     * Create an MCP server with tools generated from this ArgParser
-     * @param serverInfo Server configuration
-     * @param toolOptions Optional MCP tool generation options
-     * @param logPath Optional log path (deprecated, use log config in withMcp instead)
-     * @returns Configured MCP server instance
+     * Add a subcommand
      */
-    createMcpServer(serverInfo?: DxtServerInfo, toolOptions?: GenerateMcpToolsOptions, logPath?: LogPath): Promise<any>;
+    addSubCommand(subCommand: ISubCommand): this;
     /**
-     * Set up change notifications for the MCP server
-     * @param _server The MCP server instance (unused for now, but reserved for future client connection tracking)
+     * Get a subcommand
      */
-    private setupMcpChangeNotifications;
+    getSubCommand(name: string): ISubCommand | undefined;
     /**
-     * Start an MCP server using stdio transport
-     * @param serverInfo Server configuration
-     * @param toolOptions Optional MCP tool generation options
-     * @returns Promise that resolves when server is connected
+     * Get all subcommands
      */
-    startMcpServer(serverInfo: {
-        name: string;
-        version: string;
-        description?: string;
-    }, toolOptions?: GenerateMcpToolsOptions): Promise<void>;
+    getSubCommands(): Map<string, ISubCommand>;
     /**
-     * Start an MCP server with multiple transport types simultaneously
-     * @param serverInfo Server configuration
-     * @param transports Array of transport configurations
-     * @param toolOptions Optional MCP tool generation options
-     * @returns Promise that resolves when all servers are started
+     * Inherit flags to a sub-parser
      */
-    startMcpServerWithMultipleTransports(serverInfo: {
-        name: string;
-        version: string;
-        description?: string;
-    }, transports: Array<{
-        type: "stdio" | "sse" | "streamable-http";
-        port?: number;
-        host?: string;
-        path?: string;
-        sessionIdGenerator?: () => string;
-        cors?: CorsOptions;
-        auth?: AuthOptions;
-    }>, toolOptions?: GenerateMcpToolsOptions, logPath?: LogPath): Promise<void>;
+    private inheritFlagsToSubParser;
     /**
-     * Start an MCP server with a specific transport type
-     * @param serverInfo Server configuration
-     * @param transportType Type of transport to use
-     * @param transportOptions Transport-specific options
-     * @param toolOptions Optional MCP tool generation options
-     * @returns Promise that resolves when server is connected
+     * Set the handler
      */
-    startMcpServerWithTransport(serverInfo: {
-        name: string;
-        version: string;
-        description?: string;
-    }, transportType: "stdio" | "sse" | "streamable-http", transportOptions?: {
-        port?: number;
-        host?: string;
-        path?: string;
-        sessionIdGenerator?: () => string;
-        cors?: CorsOptions;
-        auth?: AuthOptions;
-    }, toolOptions?: GenerateMcpToolsOptions, logPath?: LogPath): Promise<void>;
-    parse(processArgs?: string[], options?: any): Promise<any>;
+    setHandler(handler: (ctx: IHandlerContext<any, any>) => THandlerReturn | Promise<THandlerReturn>): this;
     /**
-     * CLI-friendly parse method that automatically handles ParseResult objects
-     * When autoExit is false, this method will call process.exit() based on ParseResult
-     * This ensures backward compatibility for CLI applications
+     * Get the handler
      */
-    parseForCli(processArgs?: string[], options?: any): any;
+    getHandler(): ((ctx: IHandlerContext) => any) | undefined;
+    getAppName(): string;
+    getAppCommandName(): string | undefined;
+    getDescription(): string | undefined;
+    getSubCommandName(): string;
+    getAutoExit(): boolean;
+    getPromptWhen(): PromptWhen;
     /**
-     * Alias for parse() method for backward compatibility
-     * Since parse() is already async, this just calls parse()
-     *
-     * @deprecated Use parse() instead. This method will be removed in a future version.
+     * Parse command line arguments
      */
-    parseAsync(processArgs?: string[], options?: any): Promise<any>;
+    parse(processArgs?: string[], options?: IParseOptions): Promise<any>;
     /**
-     * Convenience method for auto-execution: only runs if the script is executed directly (not imported).
-     * This eliminates the need for boilerplate code to check if the script is being run directly.
-     *
-     * @param importMetaUrl Pass import.meta.url from your script for reliable detection
-     * @param processArgs Optional arguments to parse (defaults to process.argv.slice(2))
-     * @param options Additional parse options
-     * @returns Promise that resolves to the parse result, or empty object if script is imported
-     *
-     * @example
-     * ```typescript
-     * // At the bottom of your CLI script:
-     * await cli.parseIfExecutedDirectly(import.meta.url);
-     *
-     * // With error handling:
-     * await cli.parseIfExecutedDirectly(import.meta.url).catch((error) => {
-     *   this.logger.error("Fatal error:", error instanceof Error ? error.message : String(error));
-     *   process.exit(1);
-     * });
-     * ```
+     * Parse flags only
      */
-    parseIfExecutedDirectly(importMetaUrl: string, processArgs?: string[], options?: any): Promise<any>;
+    private parseFlags;
     /**
-     * Add an MCP sub-command that starts an MCP server exposing this parser's functionality
-     * @param subCommandName Name of the sub-command (default: "mcp-server")
-     * @param serverInfo Server configuration (supports extended DXT fields)
-     * @param options Optional configuration including preset transports and tool options
-     * @returns This ArgParserWithMcp instance for chaining
-     * @deprecated Use withMcp() to configure server metadata and --s-mcp-serve system flag instead. This method will be removed in v2.0.
+     * Parse a flag value based on type
      */
-    addMcpSubCommand(subCommandName: string | undefined, serverInfo: DxtServerInfo, options?: McpSubCommandOptions & {
-        toolOptions?: GenerateMcpToolsOptions;
-    }): this;
+    private parseFlagValue;
     /**
-     * Add an MCP sub-command that starts an MCP server exposing this parser's functionality
-     * @param subCommandName Name of the sub-command (default: "mcp-server")
-     * @param serverInfo Server configuration (supports extended DXT fields)
-     * @param toolOptions Optional MCP tool generation options (backward compatibility)
-     * @returns This ArgParserWithMcp instance for chaining
-     * @deprecated Use withMcp() to configure server metadata and --s-mcp-serve system flag instead. This method will be removed in v2.0.
+     * Find the command chain for subcommands
      */
-    addMcpSubCommand(subCommandName: string | undefined, serverInfo: DxtServerInfo, toolOptions?: GenerateMcpToolsOptions): this;
+    private findCommandChain;
     /**
-     * Factory method to create an ArgParser instance with MCP capabilities
-     * This provides a clean API for users who want MCP functionality from the start
-     * Automatically sets handleErrors: false for MCP compatibility
-     *
-     * @param options Combined ArgParser and MCP server configuration options
-     * @param initialFlags Optional array of initial flags to add
-     * @returns ArgParser instance with MCP capabilities and stored server metadata
+     * Detect and strip system flags
      */
-    static withMcp<T = any>(options?: WithMcpOptions<T>, initialFlags?: readonly IFlag[]): ArgParser<T>;
+    private detectAndStripSystemFlags;
     /**
-     * Create an ArgParser instance optimized for CLI usage
-     * This sets autoExit: true by default for traditional CLI behavior
+     * Handle exit
      */
-    static forCli<T = any>(options?: ConstructorParameters<typeof ArgParserBase>[0], initialFlags?: ConstructorParameters<typeof ArgParserBase>[1]): ArgParser<T>;
+    private handleExit;
     /**
-     * Create an ArgParser instance optimized for library usage
-     * This sets autoExit: false by default for programmatic control
+     * Generate help text
      */
-    static forLibrary<T = any>(options?: ConstructorParameters<typeof ArgParserBase>[0], initialFlags?: ConstructorParameters<typeof ArgParserBase>[1]): ArgParser<T>;
-    static fromArgParser<T = any>(parser: ArgParserBase<T>): ArgParser<T>;
+    helpText(): string;
 }
 //# sourceMappingURL=ArgParser.d.ts.map