@alcyone-labs/arg-parser 2.1.0 → 2.1.1

package/dist/core/types.d.ts

@@ -0,0 +1,355 @@
+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);
+    /** Environment variables that should be set from this flag's value in DXT packages */
+    env?: string | string[];
+};
+/**
+ * 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[];
+/**
+ * Converts a flag type to a JSON Schema type string.
+ * This function handles all possible flag type formats and returns a valid JSON Schema type.
+ *
+ * @param flagType - The flag type from IFlag or ProcessedFlag
+ * @returns A JSON Schema type string: "string" | "number" | "boolean" | "array" | "object"
+ *
+ * @example
+ * ```typescript
+ * getJsonSchemaTypeFromFlag(String) // returns "string"
+ * getJsonSchemaTypeFromFlag("number") // returns "number"
+ * getJsonSchemaTypeFromFlag((val) => parseInt(val)) // returns "string" (fallback for custom functions)
+ * ```
+ */
+export declare function getJsonSchemaTypeFromFlag(flagType: TParsedArgsTypeFromFlagDef): "string" | "number" | "boolean" | "array" | "object";
+/**
+ * Common output schema patterns for typical CLI/MCP tool responses
+ */
+export declare const OutputSchemaPatterns: {
+    /**
+     * Simple success/error response pattern
+     * @example { success: true, message: "Operation completed" }
+     */
+    readonly successError: () => z.ZodObject<{
+        success: z.ZodBoolean;
+        message: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        success: boolean;
+        message?: string | undefined;
+        error?: string | undefined;
+    }, {
+        success: boolean;
+        message?: string | undefined;
+        error?: string | undefined;
+    }>;
+    /**
+     * Success response with data payload
+     * @example { success: true, data: {...}, message: "Data retrieved" }
+     */
+    readonly successWithData: (dataSchema?: z.ZodTypeAny) => z.ZodObject<{
+        success: z.ZodBoolean;
+        data: z.ZodTypeAny;
+        message: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        success: boolean;
+        message?: string | undefined;
+        error?: string | undefined;
+        data?: any;
+    }, {
+        success: boolean;
+        message?: string | undefined;
+        error?: string | undefined;
+        data?: any;
+    }>;
+    /**
+     * List/array response pattern
+     * @example { items: [...], count: 5, hasMore: false }
+     */
+    readonly list: (itemSchema?: z.ZodTypeAny) => z.ZodObject<{
+        items: z.ZodArray<z.ZodTypeAny, "many">;
+        count: z.ZodOptional<z.ZodNumber>;
+        hasMore: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        items: any[];
+        count?: number | undefined;
+        hasMore?: boolean | undefined;
+    }, {
+        items: any[];
+        count?: number | undefined;
+        hasMore?: boolean | undefined;
+    }>;
+    /**
+     * File operation response pattern
+     * @example { path: "/path/to/file", size: 1024, created: true }
+     */
+    readonly fileOperation: () => z.ZodObject<{
+        path: z.ZodString;
+        size: z.ZodOptional<z.ZodNumber>;
+        created: z.ZodOptional<z.ZodBoolean>;
+        modified: z.ZodOptional<z.ZodBoolean>;
+        exists: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        size?: number | undefined;
+        created?: boolean | undefined;
+        modified?: boolean | undefined;
+        exists?: boolean | undefined;
+    }, {
+        path: string;
+        size?: number | undefined;
+        created?: boolean | undefined;
+        modified?: boolean | undefined;
+        exists?: boolean | undefined;
+    }>;
+    /**
+     * Process execution response pattern
+     * @example { exitCode: 0, stdout: "output", stderr: "", duration: 1500 }
+     */
+    readonly processExecution: () => z.ZodObject<{
+        exitCode: z.ZodNumber;
+        stdout: z.ZodOptional<z.ZodString>;
+        stderr: z.ZodOptional<z.ZodString>;
+        duration: z.ZodOptional<z.ZodNumber>;
+        command: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        exitCode: number;
+        stdout?: string | undefined;
+        stderr?: string | undefined;
+        duration?: number | undefined;
+        command?: string | undefined;
+    }, {
+        exitCode: number;
+        stdout?: string | undefined;
+        stderr?: string | undefined;
+        duration?: number | undefined;
+        command?: string | undefined;
+    }>;
+};
+/**
+ * Type for output schema pattern names with auto-completion support
+ */
+export type OutputSchemaPatternName = keyof typeof OutputSchemaPatterns;
+/**
+ * Type for output schema configuration - supports pattern names, Zod schemas, or schema definition objects
+ */
+export type OutputSchemaConfig = OutputSchemaPatternName | z.ZodTypeAny | Record<string, z.ZodTypeAny>;
+/**
+ * Creates a Zod output schema from a pattern or custom definition
+ *
+ * @param pattern - Either a predefined pattern name, a Zod schema, or a schema definition object
+ * @returns A Zod schema for output validation
+ *
+ * @example
+ * ```typescript
+ * // Using a predefined pattern
+ * const schema1 = createOutputSchema('successError');
+ *
+ * // Using a custom Zod schema
+ * const schema2 = createOutputSchema(z.object({ result: z.string() }));
+ *
+ * // Using a schema definition object
+ * const schema3 = createOutputSchema({
+ *   result: z.string().describe("The result"),
+ *   timestamp: z.string().describe("When the operation completed")
+ * });
+ * ```
+ */
+export declare function createOutputSchema(pattern: OutputSchemaConfig): z.ZodTypeAny;
+/**
+ * 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;
+}
+/**
+ * Result of parsing operations that replaces process.exit() calls.
+ * Provides structured information about the parsing outcome.
+ */
+export interface ParseResult<T = any> {
+    /** Whether the parsing was successful */
+    success: boolean;
+    /** Exit code that would have been used with process.exit() */
+    exitCode: number;
+    /** The parsed data/result when successful */
+    data?: T;
+    /** Human-readable message about the result */
+    message?: string;
+    /** Whether the process should exit (for help, version, etc.) */
+    shouldExit?: boolean;
+    /** Type of result for better handling */
+    type?: 'success' | 'error' | 'help' | 'version' | 'debug';
+}
+/**
+ * Configuration options for ArgParser behavior
+ * @deprecated Use IArgParserParams for full configuration options. This interface will be removed in v3.0.
+ */
+export interface ArgParserOptions {
+    /** Whether to automatically call process.exit() based on ParseResult (default: true for backward compatibility) */
+    autoExit?: boolean;
+    /** Whether to handle errors by exiting or throwing (default: true for backward compatibility) */
+    handleErrors?: boolean;
+}
+/**
+ * Configuration options for ArgParser runtime behavior
+ * This is a more clearly named version of ArgParserOptions
+ */
+export interface ArgParserBehaviorOptions {
+    /** Whether to automatically call process.exit() based on ParseResult (default: true for backward compatibility) */
+    autoExit?: boolean;
+    /** Whether to handle errors by exiting or throwing (default: true for backward compatibility) */
+    handleErrors?: boolean;
+}
+/**
+ * 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/core/types.d.ts.map

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

package/dist/dxt/DxtGenerator.d.ts

@@ -0,0 +1,111 @@
+import type { ParseResult } from "../core/types";
+/**
+ * DxtGenerator handles the generation of DXT (Desktop Extension) packages
+ * for MCP servers created from ArgParser instances.
+ */
+export declare class DxtGenerator {
+    private argParserInstance;
+    constructor(argParserInstance: any);
+    /**
+     * Helper method to handle exit logic based on autoExit setting
+     */
+    private _handleExit;
+    /**
+     * Handles the --s-build-dxt system flag to generate DXT packages for MCP servers
+     */
+    handleBuildDxtFlag(processArgs: string[], buildDxtIndex: number): Promise<boolean | ParseResult>;
+    /**
+     * Handles DXT generation in test mode by creating mock DXT package structure
+     */
+    private handleTestModeDxtGeneration;
+    /**
+     * Generates a DXT package for the unified MCP server
+     * Now supports both withMcp() configuration and legacy addMcpSubCommand()
+     */
+    generateDxtPackage(mcpSubCommand?: any, outputDir?: string): Promise<void>;
+    /**
+     * Reads package.json to extract fallback information for DXT manifest
+     */
+    private readPackageJsonInfo;
+    /**
+     * Extracts server information from MCP configuration
+     * Now supports both withMcp() configuration and legacy addMcpSubCommand()
+     */
+    private extractMcpServerInfo;
+    private generateMcpToolsForDxt;
+    private createDxtManifest;
+    private validateDxtManifest;
+    private createServerScript;
+    private createDxtPackageJson;
+    /**
+     * Creates a .dxtignore file to exclude build artifacts and unnecessary files
+     */
+    private createDxtIgnore;
+    /**
+     * Creates a simple build script that uses TSDown bundling and Anthropic's dxt pack
+     */
+    private createSimpleBuildScript;
+    private createDxtReadme;
+    /**
+     * Maps ArgParser flag types to DXT user config types
+     */
+    private mapFlagTypeToUserConfigType;
+    /**
+     * Generates CLI arguments for DXT manifest based on ArgParser flags
+     */
+    private generateCliArgsForDxt;
+    /**
+     * Generates environment variables and user config for DXT manifest
+     */
+    private generateEnvAndUserConfig;
+    /**
+     * Generates a user-friendly title for user config fields
+     */
+    private generateUserConfigTitle;
+    /**
+     * Checks if a field should be marked as sensitive in user config
+     */
+    private isSensitiveField;
+    /**
+     * Adds the logo to the build folder if available
+     * @returns The filename of the logo that was added, or undefined if no logo was added
+     */
+    private addLogoToFolder;
+    /**
+     * Processes CLI source code to replace global console with MCP-compliant Logger
+     */
+    private processCliSourceForMcp;
+    /**
+     * Adds the original CLI source to the build folder for handler execution
+     */
+    private addOriginalCliToFolder;
+    /**
+     * Builds a complete DXT package using TSDown CLI for autonomous execution
+     */
+    private buildDxtWithTsdown;
+    /**
+     * Bundles the original CLI using TSDown for autonomous execution (legacy method)
+     */
+    private bundleOriginalCliWithTsdown;
+    /**
+     * Checks if a module ID is a Node.js built-in
+     */
+    private isNodeBuiltin;
+    /**
+     * Gets the TSDown configuration content as a string
+     */
+    private getTsdownConfigContent;
+    /**
+     * Gets the path to the .dxtignore template file in assets
+     */
+    private getDxtIgnoreTemplatePath;
+    /**
+     * Sets up DXT package files (manifest.json) in the dxt output directory
+     */
+    private setupDxtPackageFiles;
+    /**
+     * Manually copy logo since TSDown's copy option doesn't work programmatically
+     */
+    private copyLogoManually;
+}
+//# sourceMappingURL=DxtGenerator.d.ts.map

package/dist/dxt/DxtGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DxtGenerator.d.ts","sourceRoot":"","sources":["../../src/dxt/DxtGenerator.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAIjD;;;GAGG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,iBAAiB,CAAM;gBAEnB,iBAAiB,EAAE,GAAG;IAIlC;;OAEG;IACH,OAAO,CAAC,WAAW;IAiBnB;;OAEG;IACU,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,WAAW,CAAC;IAmC7G;;OAEG;YACW,2BAA2B;IA2EzC;;;OAGG;IACU,kBAAkB,CAAC,aAAa,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA0FvF;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAoB3B;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IA8B5B,OAAO,CAAC,sBAAsB;IA8D9B,OAAO,CAAC,iBAAiB;IAiFzB,OAAO,CAAC,mBAAmB;IAuC3B,OAAO,CAAC,kBAAkB;IAqC1B,OAAO,CAAC,oBAAoB;IA8D5B;;OAEG;IACH,OAAO,CAAC,eAAe;IA4CvB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAqF/B,OAAO,CAAC,eAAe;IAkGvB;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAwBnC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAc7B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IA8DhC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAO/B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAUxB;;;OAGG;YACW,eAAe;IAqF7B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IA2D9B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAmJ9B;;OAEG;YACW,kBAAkB;IAuHhC;;OAEG;YACW,2BAA2B;IAiIzC;;OAEG;IACH,OAAO,CAAC,aAAa;IAarB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAyD9B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IA4BhC;;OAEG;YACW,oBAAoB;IA8JlC;;OAEG;YACW,gBAAgB;CAgC/B"}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { ArgParserBase, ArgParserError, type IParseOptions } from "./core/ArgParserBase";
+export { ArgParser, type McpTransportConfig, type McpSubCommandOptions, type DxtServerInfo, type McpServerOptions, type WithMcpOptions, type ArgParserWithMcpOptions, type McpToolConfig, type ToolConfig } from "./core/ArgParser";
+export { ArgParserMcp, createMcpArgParser } from "./mcp/ArgParserMcp";
+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, getJsonSchemaTypeFromFlag, OutputSchemaPatterns, type OutputSchemaPatternName, type OutputSchemaConfig, createOutputSchema, type ArgParserOptions, type ArgParserBehaviorOptions, } from "./core/types";
+export { generateMcpToolsFromArgParser, type IMcpToolStructure, type GenerateMcpToolsOptions, type IParseExecutionResult, type SimplifiedToolResponse, extractSimplifiedResponse, convertFlagToJsonSchemaProperty, convertFlagsToJsonSchema, convertFlagsToZodSchema, createMcpSuccessResponse, createMcpErrorResponse, type McpResponse, } from "./mcp/mcp-integration";
+export { type IConfigPlugin, ConfigPlugin, JsonConfigPlugin, EnvConfigPlugin, ConfigPluginRegistry, globalConfigPluginRegistry, enableOptionalConfigPlugins, enableOptionalConfigPluginsAsync, enableConfigPlugins, TomlConfigPlugin, createTomlPlugin, createTomlPluginAsync, YamlConfigPlugin, createYamlPlugin, createYamlPluginAsync, } from "./config/plugins";
+export { ArgParserFuzzyTester } from "./testing/fuzzy-tester";
+export type { FuzzyTestOptions, TestResult, FuzzyTestReport } from "./testing/fuzzy-tester";
+export { default as SimpleChalk } from "@alcyone-labs/simple-chalk";
+export { Logger, logger, createMcpLogger, createCliLogger, type LogLevel, type LoggerConfig } from "@alcyone-labs/simple-mcp-logger";
+//# sourceMappingURL=index.d.ts.map

package/dist/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,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACzF,OAAO,EACL,SAAS,EACT,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,KAAK,aAAa,EAClB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAEtE,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,EACtB,yBAAyB,EACzB,oBAAoB,EACpB,KAAK,uBAAuB,EAC5B,KAAK,kBAAkB,EACvB,kBAAkB,EAClB,KAAK,gBAAgB,EACrB,KAAK,wBAAwB,GAC9B,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,6BAA6B,EAC7B,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC3B,yBAAyB,EACzB,+BAA+B,EAC/B,wBAAwB,EACxB,uBAAuB,EACvB,wBAAwB,EACxB,sBAAsB,EACtB,KAAK,WAAW,GACjB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,KAAK,aAAa,EAClB,YAAY,EACZ,gBAAgB,EAChB,eAAe,EACf,oBAAoB,EACpB,0BAA0B,EAC1B,2BAA2B,EAC3B,gCAAgC,EAChC,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,YAAY,EAAE,gBAAgB,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAG5F,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAGpE,OAAO,EACL,MAAM,EACN,MAAM,EACN,eAAe,EACf,eAAe,EACf,KAAK,QAAQ,EACb,KAAK,YAAY,EAClB,MAAM,iCAAiC,CAAC"}

package/dist/mcp/ArgParserMcp.d.ts

@@ -0,0 +1,21 @@
+import { ArgParser } from "../core/ArgParser";
+import type { IArgParserParams } from "../core/ArgParserBase";
+import type { IFlag } from "../core/types";
+/**
+ * MCP-optimized ArgParser that excludes config file functionality
+ * This version doesn't load any config plugins, making it suitable for
+ * autonomous builds where TOML/YAML dependencies cause bundling issues.
+ */
+export declare class ArgParserMcp<THandlerReturn = any> extends ArgParser<THandlerReturn> {
+    constructor(params?: IArgParserParams<THandlerReturn>, initialFlags?: IFlag[]);
+    /**
+     * Override parse to skip config file processing
+     */
+    parse(processArgs: string[], options?: any): any;
+}
+/**
+ * Convenience function to create MCP-optimized ArgParser
+ * This is the recommended way to create ArgParser instances for MCP servers
+ */
+export declare function createMcpArgParser<THandlerReturn = any>(params?: IArgParserParams<THandlerReturn>, initialFlags?: IFlag[]): ArgParserMcp<THandlerReturn>;
+//# sourceMappingURL=ArgParserMcp.d.ts.map

package/dist/mcp/ArgParserMcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArgParserMcp.d.ts","sourceRoot":"","sources":["../../src/mcp/ArgParserMcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAE3C;;;;GAIG;AACH,qBAAa,YAAY,CAAC,cAAc,GAAG,GAAG,CAAE,SAAQ,SAAS,CAAC,cAAc,CAAC;gBACnE,MAAM,CAAC,EAAE,gBAAgB,CAAC,cAAc,CAAC,EAAE,YAAY,CAAC,EAAE,KAAK,EAAE;IAS7E;;OAEG;IACI,KAAK,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,GAAG;CAUxD;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,cAAc,GAAG,GAAG,EACrD,MAAM,CAAC,EAAE,gBAAgB,CAAC,cAAc,CAAC,EACzC,YAAY,CAAC,EAAE,KAAK,EAAE,GACrB,YAAY,CAAC,cAAc,CAAC,CAE9B"}

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

@@ -0,0 +1,86 @@
+import type { ZodTypeAny } from "zod";
+import { ArgParserBase } from "../core/ArgParserBase";
+import type { IFlag, ProcessedFlag, TParsedArgs } from "../core/types";
+/**
+ * Standard MCP response format
+ */
+export interface McpResponse {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+    structuredContent?: any;
+}
+/**
+ * Create a standardized MCP success response
+ */
+export declare function createMcpSuccessResponse(data: any): McpResponse;
+/**
+ * Create a standardized MCP error response
+ */
+export declare function createMcpErrorResponse(error: string | Error): McpResponse;
+/**
+ * Convert a single ArgParser flag to JSON Schema property
+ */
+export declare function convertFlagToJsonSchemaProperty(flag: IFlag | ProcessedFlag): {
+    property: any;
+    isRequired: boolean;
+};
+/**
+ * Convert ArgParser flags to MCP JSON Schema
+ */
+export declare function convertFlagsToJsonSchema(flags: readonly (IFlag | ProcessedFlag)[]): {
+    type: "object";
+    properties: Record<string, any>;
+    required: string[];
+};
+/**
+ * Convert ArgParser flags to Zod schema for MCP tools
+ */
+export declare function convertFlagsToZodSchema(flags: readonly (IFlag | ProcessedFlag)[]): ZodTypeAny;
+/**
+ * Simplified response format for testing and validation
+ */
+export interface SimplifiedToolResponse {
+    success: boolean;
+    data?: any;
+    error?: string;
+    message?: string;
+    exitCode?: number;
+}
+/**
+ * Extract simplified response from MCP protocol response
+ */
+export declare function extractSimplifiedResponse(mcpResponse: any): SimplifiedToolResponse;
+export interface IMcpToolStructure {
+    name: string;
+    description?: string;
+    inputSchema: ZodTypeAny;
+    outputSchema?: ZodTypeAny;
+    execute: (args: any) => Promise<any>;
+    executeForTesting?: (args: any) => Promise<SimplifiedToolResponse>;
+}
+export interface GenerateMcpToolsOptions {
+    outputSchemaMap?: Record<string, ZodTypeAny>;
+    defaultOutputSchema?: ZodTypeAny;
+    /** Automatically generate output schemas for tools that don't have explicit schemas */
+    autoGenerateOutputSchema?: boolean | keyof typeof import("../core/types").OutputSchemaPatterns;
+    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/mcp/mcp-integration.d.ts.map

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