@alcyone-labs/arg-parser 1.0.0 → 1.2.0

package/dist/src/ArgParser.d.ts

@@ -0,0 +1,148 @@
+import { ArgParserBase } from "./ArgParserBase";
+import type { GenerateMcpToolsOptions, IMcpToolStructure } from "./mcp-integration";
+/**
+ * Configuration for a single MCP transport
+ */
+export type McpTransportConfig = {
+    type: "stdio" | "sse" | "streamable-http";
+    port?: number;
+    host?: string;
+    path?: string;
+    sessionIdGenerator?: () => string;
+};
+/**
+ * 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;
+};
+/**
+ * ArgParser with Model Context Protocol (MCP) integration capabilities.
+ *
+ * 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"
+ *   });
+ * ```
+ */
+export declare class ArgParser<THandlerReturn = any> extends ArgParserBase<THandlerReturn> {
+    #private;
+    /**
+     * 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
+     */
+    toMcpTools(options?: GenerateMcpToolsOptions): IMcpToolStructure[];
+    /**
+     * Create an MCP server with tools generated from this ArgParser
+     * @param serverInfo Server configuration
+     * @param toolOptions Optional MCP tool generation options
+     * @returns Configured MCP server instance
+     */
+    createMcpServer(serverInfo: {
+        name: string;
+        version: string;
+        description?: string;
+    }, toolOptions?: GenerateMcpToolsOptions): Promise<any>;
+    /**
+     * 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
+     */
+    startMcpServer(serverInfo: {
+        name: string;
+        version: string;
+        description?: string;
+    }, toolOptions?: GenerateMcpToolsOptions): Promise<void>;
+    /**
+     * 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
+     */
+    startMcpServerWithMultipleTransports(serverInfo: {
+        name: string;
+        version: string;
+        description?: string;
+    }, transports: Array<{
+        type: "stdio" | "sse" | "streamable-http";
+        port?: number;
+        host?: string;
+        path?: string;
+        sessionIdGenerator?: () => string;
+    }>, toolOptions?: GenerateMcpToolsOptions): Promise<void>;
+    /**
+     * 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
+     */
+    startMcpServerWithTransport(serverInfo: {
+        name: string;
+        version: string;
+        description?: string;
+    }, transportType: "stdio" | "sse" | "streamable-http", transportOptions?: {
+        port?: number;
+        host?: string;
+        path?: string;
+        sessionIdGenerator?: () => string;
+    }, toolOptions?: GenerateMcpToolsOptions): Promise<void>;
+    parse(processArgs: string[], options?: any): any;
+    /**
+     * Async version of parse for when async handlers are detected
+     */
+    parseAsync(processArgs: string[], options?: any): Promise<any>;
+    /**
+     * 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
+     * @param options Optional configuration including preset transports and tool options
+     * @returns This ArgParserWithMcp instance for chaining
+     */
+    addMcpSubCommand(subCommandName: string | undefined, serverInfo: {
+        name: string;
+        version: string;
+        description?: string;
+    }, options?: McpSubCommandOptions & {
+        toolOptions?: GenerateMcpToolsOptions;
+    }): this;
+    /**
+     * 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
+     * @param toolOptions Optional MCP tool generation options (backward compatibility)
+     * @returns This ArgParserWithMcp instance for chaining
+     * @deprecated Use the options parameter instead for better configurability
+     */
+    addMcpSubCommand(subCommandName: string | undefined, serverInfo: {
+        name: string;
+        version: string;
+        description?: string;
+    }, toolOptions?: GenerateMcpToolsOptions): this;
+    /**
+     * 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
+     */
+    static withMcp<T = any>(options?: ConstructorParameters<typeof ArgParserBase>[0], initialFlags?: ConstructorParameters<typeof ArgParserBase>[1]): ArgParser<T>;
+    static fromArgParser<T = any>(parser: ArgParserBase<T>): ArgParser<T>;
+}
+//# sourceMappingURL=ArgParser.d.ts.map

package/dist/src/ArgParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArgParser.d.ts","sourceRoot":"","sources":["../../src/ArgParser.ts"],"names":[],"mappings":"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"}

package/dist/{ArgParser.d.ts → src/ArgParserBase.d.ts}

@@ -1,10 +1,16 @@
-import { HandlerContext, IFlag, ISubCommand, ProcessedFlag, TParsedArgs } from "./types";
+import type { IFlag, IHandlerContext, ISubCommand, ProcessedFlag, TParsedArgs } from "./types";
 export declare class ArgParserError extends Error {
     cmdChain: string[];
     commandChain: string[];
     constructor(message: string, cmdChain?: string[]);
 }
-interface IArgParserParams {
+export interface IArgParserParams<THandlerReturn = any> {
+    /**
+     * This is the display name of the app, used in help text
+     */
+    appName?: string;
+    subCommands?: ISubCommand[];
+    handler?: (ctx: IHandlerContext<any, any>) => THandlerReturn | Promise<THandlerReturn>;
     /**
      * Add an extra new line between each flag group,
      * makes the text more readable but uses more space
@@ -48,8 +54,7 @@ interface IArgParserParams {
     handleErrors?: boolean;
     /**
      * The command name to display in help suggestions (e.g., 'dabl').
-     * If not provided, it falls back to appName or guessing from the script path.
-     * @since 1.5.1
+     * If not provided, it falls back to guessing from the script path.
      */
     appCommandName?: string;
     /**
@@ -76,18 +81,20 @@ type TParsedArgsWithRouting<T = any> = T & {
     $commandChain?: string[];
     handlerToExecute?: {
         handler: Function;
-        context: HandlerContext;
+        context: IHandlerContext;
     };
 };
-export declare class ArgParser {
+export declare class ArgParserBase<THandlerReturn = any> {
     #private;
-    constructor(options?: IArgParserParams & {
-        appName?: string;
-        subCommands?: ISubCommand[];
-        handler?: (ctx: HandlerContext) => void;
-    }, initialFlags?: readonly IFlag[]);
+    constructor(options?: IArgParserParams<THandlerReturn>, initialFlags?: readonly IFlag[]);
     get flags(): ProcessedFlag[];
     get flagNames(): string[];
+    getAppName(): string | undefined;
+    getAppCommandName(): string | undefined;
+    getSubCommandName(): string;
+    getDescription(): string | undefined;
+    getHandler(): ((ctx: IHandlerContext) => void) | undefined;
+    getSubCommands(): Map<string, ISubCommand>;
     private _addToOutput;
     addFlags(flags: readonly IFlag[]): this;
     addFlag(flag: IFlag): this;
@@ -100,7 +107,7 @@ export declare class ArgParser {
      * @param handler - The function to execute.
      * @returns The ArgParser instance for chaining.
      */
-    setHandler(handler: (ctx: HandlerContext) => void): this;
+    setHandler(handler: (ctx: IHandlerContext<any, any>) => THandlerReturn | Promise<THandlerReturn>): this;
     printAll(filePath?: string): void;
     parse(processArgs: string[], options?: IParseOptions): TParsedArgsWithRouting<any>;
     /**
@@ -115,4 +122,4 @@ export declare class ArgParser {
     getLastParseResult(): TParsedArgs<ProcessedFlag[]>;
 }
 export {};
-//# sourceMappingURL=ArgParser.d.ts.map
+//# sourceMappingURL=ArgParserBase.d.ts.map

package/dist/src/ArgParserBase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArgParserBase.d.ts","sourceRoot":"","sources":["../../src/ArgParserBase.ts"],"names":[],"mappings":"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"}

package/dist/{FlagManager.d.ts → src/FlagManager.d.ts}

@@ -1,4 +1,4 @@
-import { IFlag, ProcessedFlag } from "./types";
+import type { IFlag, ProcessedFlag } from "./types";
 export declare class FlagManager {
     #private;
     constructor(options?: {

package/dist/src/FlagManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlagManager.d.ts","sourceRoot":"","sources":["../../src/FlagManager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAEpD,qBAAa,WAAW;;gBAKpB,OAAO,GAAE;QAAE,sBAAsB,CAAC,EAAE,OAAO,CAAA;KAAO,EAClD,YAAY,GAAE,SAAS,KAAK,EAAO;IAMrC,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,KAAK,GAAG,aAAa;IAwC5C,OAAO,CAAC,IAAI,EAAE,KAAK,GAAG,IAAI;IAoB1B,+BAA+B,CAAC,aAAa,EAAE,aAAa,GAAG,IAAI;IAQnE,QAAQ,CAAC,KAAK,EAAE,SAAS,KAAK,EAAE,GAAG,IAAI;IAOvC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI9B,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAIhD,IAAI,KAAK,IAAI,aAAa,EAAE,CAE3B;IAED,IAAI,SAAS,IAAI,MAAM,EAAE,CAExB;CACF"}

package/dist/src/fuzzy-test-cli.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { ArgParser } from "./ArgParser";
+declare const fuzzyTestCli: ArgParser<void>;
+export { fuzzyTestCli };
+//# sourceMappingURL=fuzzy-test-cli.d.ts.map

package/dist/src/fuzzy-test-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fuzzy-test-cli.d.ts","sourceRoot":"","sources":["../../src/fuzzy-test-cli.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAgBxC,QAAA,MAAM,YAAY,iBAmEhB,CAAC;AAkPH,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/src/fuzzy-tester.d.ts

@@ -0,0 +1,101 @@
+import type { ArgParserBase } from "./ArgParserBase";
+export interface FuzzyTestOptions {
+    /** Maximum depth for command path exploration */
+    maxDepth?: number;
+    /** Number of random test cases to generate per command path */
+    randomTestCases?: number;
+    /** Include performance timing in results */
+    includePerformance?: boolean;
+    /** Test invalid combinations to verify error handling */
+    testErrorCases?: boolean;
+    /** Verbose output for debugging */
+    verbose?: boolean;
+}
+export interface TestResult {
+    commandPath: string[];
+    args: string[];
+    success: boolean;
+    error?: string;
+    executionTime?: number;
+    parsedResult?: any;
+}
+export interface FuzzyTestReport {
+    totalTests: number;
+    successfulTests: number;
+    failedTests: number;
+    commandPaths: string[][];
+    results: TestResult[];
+    summary: {
+        coverageByPath: Record<string, {
+            total: number;
+            passed: number;
+        }>;
+        errorTypes: Record<string, number>;
+    };
+}
+export declare class ArgParserFuzzyTester {
+    private parser;
+    private options;
+    constructor(parser: ArgParserBase, options?: FuzzyTestOptions);
+    /**
+     * Run comprehensive fuzzy testing on the ArgParser instance
+     */
+    runFuzzyTest(): Promise<FuzzyTestReport>;
+    /**
+     * Discover all possible command paths in the parser
+     */
+    private discoverCommandPaths;
+    /**
+     * Recursively discover subcommand paths
+     */
+    private discoverSubCommandPaths;
+    /**
+     * Get subcommands from a parser instance
+     */
+    private getSubCommands;
+    /**
+     * Get flags from a parser instance
+     */
+    private getFlags;
+    /**
+     * Test a specific command path with various flag combinations
+     */
+    private testCommandPath;
+    /**
+     * Get the parser instance for a specific command path
+     */
+    private getParserForPath;
+    /**
+     * Generate valid flag combinations for testing
+     */
+    private generateValidFlagCombinations;
+    /**
+     * Generate random flag combination
+     */
+    private generateRandomFlagCombination;
+    /**
+     * Generate error test cases
+     */
+    private generateErrorCases;
+    /**
+     * Generate arguments for a specific flag
+     */
+    private generateFlagArgs;
+    /**
+     * Generate values for a flag based on its type and constraints
+     */
+    private generateFlagValues;
+    /**
+     * Generate a single value for a flag
+     */
+    private generateSingleFlagValue;
+    /**
+     * Execute a single test case
+     */
+    private executeTest;
+    /**
+     * Generate comprehensive test report
+     */
+    private generateReport;
+}
+//# sourceMappingURL=fuzzy-tester.d.ts.map

package/dist/src/fuzzy-tester.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fuzzy-tester.d.ts","sourceRoot":"","sources":["../../src/fuzzy-tester.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGrD,MAAM,WAAW,gBAAgB;IAC/B,iDAAiD;IACjD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,+DAA+D;IAC/D,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,4CAA4C;IAC5C,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,yDAAyD;IACzD,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,mCAAmC;IACnC,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,EAAE,CAAC;IACzB,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,OAAO,EAAE;QACP,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QAClE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACpC,CAAC;CACH;AAED,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,OAAO,CAA6B;gBAEhC,MAAM,EAAE,aAAa,EAAE,OAAO,GAAE,gBAAqB;IAWjE;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,eAAe,CAAC;IAiB9C;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAY5B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAmB/B;;OAEG;IACH,OAAO,CAAC,cAAc;IAItB;;OAEG;IACH,OAAO,CAAC,QAAQ;IAIhB;;OAEG;YACW,eAAe;IAsC7B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAexB;;OAEG;IACH,OAAO,CAAC,6BAA6B;IAqDrC;;OAEG;IACH,OAAO,CAAC,6BAA6B;IAerC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAoB1B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAsBxB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAa1B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAsC/B;;OAEG;YACW,WAAW;IA0CzB;;OAEG;IACH,OAAO,CAAC,cAAc;CAuCvB"}

package/dist/src/index.d.ts

@@ -0,0 +1,7 @@
+export { ArgParserBase, ArgParserError } from "./ArgParserBase";
+export { ArgParser, type McpTransportConfig, type McpSubCommandOptions } from "./ArgParser";
+export { zodFlagSchema, type IFlagCore, type IFlag, type ProcessedFlagCore, type ProcessedFlag, type TParsedArgsTypeFromFlagDef, type FlagsArray, type ResolveType, type ExtractFlagType, type TParsedArgs, type IHandlerContext, type MainHandler, type ISubCommand, type ArgParserInstance, } from "./types";
+export { generateMcpToolsFromArgParser, type IMcpToolStructure, type GenerateMcpToolsOptions, type IParseExecutionResult, } from "./mcp-integration";
+export { ArgParserFuzzyTester } from "./fuzzy-tester";
+export type { FuzzyTestOptions, TestResult, FuzzyTestReport } from "./fuzzy-tester";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAChE,OAAO,EACL,SAAS,EACT,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EAC1B,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,aAAa,EACb,KAAK,SAAS,EACd,KAAK,KAAK,EACV,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,0BAA0B,EAC/B,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,iBAAiB,GACvB,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,6BAA6B,EAC7B,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,GAC3B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AACtD,YAAY,EAAE,gBAAgB,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/src/mcp-integration.d.ts

@@ -0,0 +1,31 @@
+import type { ZodTypeAny } from "zod";
+import { ArgParserBase } from "./ArgParserBase";
+import type { ProcessedFlag, TParsedArgs } from "./";
+export interface IMcpToolStructure {
+    name: string;
+    description?: string;
+    inputSchema: ZodTypeAny;
+    outputSchema?: ZodTypeAny;
+    execute: (args: any) => Promise<any>;
+}
+export interface GenerateMcpToolsOptions {
+    outputSchemaMap?: Record<string, ZodTypeAny>;
+    defaultOutputSchema?: ZodTypeAny;
+    generateToolName?: (commandPath: string[], appName?: string) => string;
+    includeSubCommands?: boolean;
+    toolNamePrefix?: string;
+    toolNameSuffix?: string;
+}
+interface ISpecialParseResultProps {
+    $commandChain?: string[];
+    $error?: {
+        type: string;
+        message: string;
+        details?: any;
+    };
+    handlerResponse?: any;
+}
+export type IParseExecutionResult = TParsedArgs<ProcessedFlag[]> & ISpecialParseResultProps;
+export declare function generateMcpToolsFromArgParser(rootParser: ArgParserBase, options?: GenerateMcpToolsOptions): IMcpToolStructure[];
+export {};
+//# sourceMappingURL=mcp-integration.d.ts.map

package/dist/src/mcp-integration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-integration.d.ts","sourceRoot":"","sources":["../../src/mcp-integration.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAe,UAAU,EAAE,MAAM,KAAK,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,EAA0B,aAAa,EAAE,WAAW,EAAE,MAAM,IAAI,CAAC;AAK7E,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,UAAU,CAAC;IACxB,YAAY,CAAC,EAAE,UAAU,CAAC;IAC1B,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;CACtC;AAqID,MAAM,WAAW,uBAAuB;IACtC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAC7C,mBAAmB,CAAC,EAAE,UAAU,CAAC;IACjC,gBAAgB,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IACvE,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,UAAU,wBAAwB;IAChC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,MAAM,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,GAAG,CAAA;KAAE,CAAC;IAC1D,eAAe,CAAC,EAAE,GAAG,CAAC;CACvB;AACD,MAAM,MAAM,qBAAqB,GAAG,WAAW,CAAC,aAAa,EAAE,CAAC,GAC9D,wBAAwB,CAAC;AAE3B,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,aAAa,EACzB,OAAO,CAAC,EAAE,uBAAuB,GAChC,iBAAiB,EAAE,CAmerB"}

package/dist/src/types.d.ts

@@ -0,0 +1,165 @@
+import { z } from "zod";
+export type ArgParserInstance = any;
+export declare const zodFlagSchema: z.ZodEffects<z.ZodObject<{
+    name: z.ZodString;
+    allowLigature: z.ZodDefault<z.ZodBoolean>;
+    allowMultiple: z.ZodDefault<z.ZodBoolean>;
+    description: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    options: z.ZodArray<z.ZodString, "many">;
+    defaultValue: z.ZodOptional<z.ZodAny>;
+    type: z.ZodDefault<z.ZodUnion<[z.ZodEffects<z.ZodAny, any, any>, z.ZodEffects<z.ZodAny, any, any>, z.ZodEffects<z.ZodAny, any, any>, z.ZodEffects<z.ZodAny, any, any>, z.ZodEffects<z.ZodAny, any, any>, z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodAny>, z.ZodEffects<z.ZodString, string, string>]>>;
+    mandatory: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodBoolean>]>>;
+    flagOnly: z.ZodDefault<z.ZodBoolean>;
+    validate: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodOptional<z.ZodAny>, z.ZodOptional<z.ZodAny>], z.ZodUnknown>, z.ZodUnion<[z.ZodBoolean, z.ZodString, z.ZodVoid, z.ZodPromise<z.ZodUnion<[z.ZodBoolean, z.ZodString, z.ZodVoid]>>]>>>;
+    enum: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    name: z.ZodString;
+    allowLigature: z.ZodDefault<z.ZodBoolean>;
+    allowMultiple: z.ZodDefault<z.ZodBoolean>;
+    description: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    options: z.ZodArray<z.ZodString, "many">;
+    defaultValue: z.ZodOptional<z.ZodAny>;
+    type: z.ZodDefault<z.ZodUnion<[z.ZodEffects<z.ZodAny, any, any>, z.ZodEffects<z.ZodAny, any, any>, z.ZodEffects<z.ZodAny, any, any>, z.ZodEffects<z.ZodAny, any, any>, z.ZodEffects<z.ZodAny, any, any>, z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodAny>, z.ZodEffects<z.ZodString, string, string>]>>;
+    mandatory: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodBoolean>]>>;
+    flagOnly: z.ZodDefault<z.ZodBoolean>;
+    validate: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodOptional<z.ZodAny>, z.ZodOptional<z.ZodAny>], z.ZodUnknown>, z.ZodUnion<[z.ZodBoolean, z.ZodString, z.ZodVoid, z.ZodPromise<z.ZodUnion<[z.ZodBoolean, z.ZodString, z.ZodVoid]>>]>>>;
+    enum: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    name: z.ZodString;
+    allowLigature: z.ZodDefault<z.ZodBoolean>;
+    allowMultiple: z.ZodDefault<z.ZodBoolean>;
+    description: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    options: z.ZodArray<z.ZodString, "many">;
+    defaultValue: z.ZodOptional<z.ZodAny>;
+    type: z.ZodDefault<z.ZodUnion<[z.ZodEffects<z.ZodAny, any, any>, z.ZodEffects<z.ZodAny, any, any>, z.ZodEffects<z.ZodAny, any, any>, z.ZodEffects<z.ZodAny, any, any>, z.ZodEffects<z.ZodAny, any, any>, z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodAny>, z.ZodEffects<z.ZodString, string, string>]>>;
+    mandatory: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodBoolean>]>>;
+    flagOnly: z.ZodDefault<z.ZodBoolean>;
+    validate: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodOptional<z.ZodAny>, z.ZodOptional<z.ZodAny>], z.ZodUnknown>, z.ZodUnion<[z.ZodBoolean, z.ZodString, z.ZodVoid, z.ZodPromise<z.ZodUnion<[z.ZodBoolean, z.ZodString, z.ZodVoid]>>]>>>;
+    enum: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+}, z.ZodTypeAny, "passthrough">>, {
+    [key: string]: any;
+}, z.objectInputType<{
+    name: z.ZodString;
+    allowLigature: z.ZodDefault<z.ZodBoolean>;
+    allowMultiple: z.ZodDefault<z.ZodBoolean>;
+    description: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    options: z.ZodArray<z.ZodString, "many">;
+    defaultValue: z.ZodOptional<z.ZodAny>;
+    type: z.ZodDefault<z.ZodUnion<[z.ZodEffects<z.ZodAny, any, any>, z.ZodEffects<z.ZodAny, any, any>, z.ZodEffects<z.ZodAny, any, any>, z.ZodEffects<z.ZodAny, any, any>, z.ZodEffects<z.ZodAny, any, any>, z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodAny>, z.ZodEffects<z.ZodString, string, string>]>>;
+    mandatory: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodBoolean>]>>;
+    flagOnly: z.ZodDefault<z.ZodBoolean>;
+    validate: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodOptional<z.ZodAny>, z.ZodOptional<z.ZodAny>], z.ZodUnknown>, z.ZodUnion<[z.ZodBoolean, z.ZodString, z.ZodVoid, z.ZodPromise<z.ZodUnion<[z.ZodBoolean, z.ZodString, z.ZodVoid]>>]>>>;
+    enum: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+}, z.ZodTypeAny, "passthrough">>;
+/**
+ * The raw input type for defining a flag, before Zod processing (aliases, defaults).
+ */
+export type IFlagCore = z.input<typeof zodFlagSchema>;
+/**
+ * The type of the `type` property in a ProcessedFlagCore object.
+ * This represents all valid forms the `type` property can take after Zod processing.
+ */
+export type TParsedArgsTypeFromFlagDef = StringConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor | ((value: string) => any) | "string" | "number" | "boolean" | "array" | "object";
+/**
+ * The core type of a flag after Zod processing (defaults applied, aliases resolved),
+ * but before some properties are made more specific (like `type` constructor to actual type).
+ * This type is output by `zodFlagSchema.parse()`.
+ */
+export type ProcessedFlagCore = Omit<z.output<typeof zodFlagSchema>, "type"> & {
+    type: TParsedArgsTypeFromFlagDef;
+};
+/**
+ * The user-facing type for defining a flag. It includes aliases like `default` and `required`.
+ * The `handler` property is removed as handlers are typically associated with commands/subcommands, not individual flags.
+ */
+export type IFlag = IFlagCore & {
+    /** @alias defaultValue */
+    default?: any;
+    /** @alias mandatory */
+    required?: boolean | ((parsedArgs: TParsedArgs<any>) => boolean);
+};
+/**
+ * A more refined type for a flag after it has been fully processed by ArgParser,
+ * particularly its `type` property and validation/enum/mandatory functions.
+ * This is the type that ArgParser would internally work with for parsing and type extraction.
+ */
+export type ProcessedFlag = Omit<ProcessedFlagCore, "validate" | "enum" | "mandatory"> & {
+    validate?: (value: any, parsedArgs?: TParsedArgs<ProcessedFlag[]>) => boolean | string | void | Promise<boolean | string | void>;
+    enum?: any[];
+    mandatory?: boolean | ((parsedArgs: TParsedArgs<ProcessedFlag[]>) => boolean);
+};
+/**
+ * Resolves the TypeScript type from a flag's `type` definition.
+ */
+export type ResolveType<T extends TParsedArgsTypeFromFlagDef> = T extends StringConstructor ? string : T extends NumberConstructor ? number : T extends BooleanConstructor ? boolean : T extends ArrayConstructor ? any[] : T extends ObjectConstructor ? Record<string, any> : T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : T extends "array" ? any[] : T extends "object" ? Record<string, any> : T extends (value: string) => infer R ? R : any;
+/**
+ * Extracts the final TypeScript type for a flag's value based on its definition,
+ * considering `flagOnly` and `allowMultiple` properties.
+ */
+export type ExtractFlagType<TFlag extends ProcessedFlag> = TFlag["flagOnly"] extends true ? TFlag["allowMultiple"] extends true ? boolean[] : boolean : TFlag["allowMultiple"] extends true ? Array<ResolveType<TFlag["type"]>> : ResolveType<TFlag["type"]>;
+/**
+ * Represents the structured object of parsed arguments.
+ * Keys are flag names, and values are their parsed and typed values.
+ * `TFlags` should be the array of `ProcessedFlag` definitions for the specific command.
+ */
+export type TParsedArgs<TFlags extends readonly ProcessedFlag[]> = {
+    [K in TFlags[number]["name"]]: ExtractFlagType<Extract<TFlags[number], {
+        name: K;
+    }>>;
+};
+/**
+ * Generic context object passed to command handlers.
+ * @template TCurrentCommandArgs Shape of `args` for the current command, derived from its flags.
+ * @template TParentCommandArgs Shape of `parentArgs` from the parent command, if any.
+ */
+export type IHandlerContext<TCurrentCommandArgs extends Record<string, any> = Record<string, any>, TParentCommandArgs extends Record<string, any> = Record<string, any>> = {
+    /** Parsed arguments specific to the current command. */
+    args: TCurrentCommandArgs;
+    /** Parsed arguments from the parent command, if this is a subcommand. */
+    parentArgs?: TParentCommandArgs;
+    /** The sequence of command names that led to this handler. */
+    commandChain: string[];
+    /** The `ArgParser` instance that invoked this handler (could be a subcommand's parser). */
+    parser: ArgParserInstance;
+    /** The parent `ArgParser` instance, if this is a subcommand handler. */
+    parentParser?: ArgParserInstance;
+    /** Optional: The root `ArgParser` instance of the CLI. */
+    /** Indicates if the handler is being called from MCP mode (true) or CLI mode (false). */
+    isMcp?: boolean;
+};
+/**
+ * Generic type for the collection of processed flags that an ArgParser instance manages.
+ */
+export type FlagsArray = readonly ProcessedFlag[];
+/**
+ * Defines a subcommand within an ArgParser setup.
+ * @template TSubCommandFlags Flags defined specifically FOR this subcommand.
+ * @template TParentCommandFlags Flags defined for the PARENT of this subcommand.
+ * @template THandlerReturn The expected return type of the subcommand's handler.
+ */
+export interface ISubCommand<TSubCommandFlags extends FlagsArray = FlagsArray, TParentCommandFlags extends FlagsArray = FlagsArray, THandlerReturn = any> {
+    name: string;
+    description?: string;
+    /** The ArgParser instance for this subcommand, typed with its own flags. */
+    parser: ArgParserInstance;
+    /** Handler function for this subcommand. */
+    handler?: (ctx: IHandlerContext<TParsedArgs<TSubCommandFlags>, TParsedArgs<TParentCommandFlags>>) => THandlerReturn | Promise<THandlerReturn>;
+    /** Internal flag to identify MCP subcommands for proper exclusion from tool generation */
+    isMcp?: boolean;
+    /** MCP server information for DXT generation */
+    mcpServerInfo?: {
+        name: string;
+        version: string;
+        description?: string;
+    };
+    /** MCP tool generation options for DXT generation */
+    mcpToolOptions?: any;
+}
+/**
+ * Type for the main handler of an ArgParser instance (root command or a command defined by an ArgParser).
+ * @template TParserFlags Flags defined for this ArgParser instance.
+ * @template TParentParserFlags Flags of the parent parser, if this parser is used as a subcommand.
+ * @template THandlerReturn The expected return type of the handler.
+ */
+export type MainHandler<TParserFlags extends FlagsArray = FlagsArray, TParentParserFlags extends FlagsArray = FlagsArray, THandlerReturn = any> = (ctx: IHandlerContext<TParsedArgs<TParserFlags>, TParsedArgs<TParentParserFlags>>) => THandlerReturn | Promise<THandlerReturn>;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"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"}