@zapier/zapier-sdk-cli 0.59.1 → 0.59.2

package/dist/src/utils/cli-generator.js

@@ -1,831 +0,0 @@
-import { Option } from "commander";
-import { z } from "zod";
-import { isPositional, runWithCallerContext, } from "@zapier/zapier-sdk";
-import { SchemaParameterResolver } from "./parameter-resolver";
-import chalk from "chalk";
-import inquirer from "inquirer";
-import { ZapierCliError, ZapierCliExitError, ZapierCliMissingParametersError, ZapierCliValidationError, } from "./errors";
-import { SHARED_COMMAND_CLI_OPTIONS } from "./cli-options";
-import { buildCliCommandExecutedEvent } from "../telemetry/builders";
-import { createJsonRenderer, createInteractiveRenderer } from "./cli-renderer";
-import { toKebabCase } from "./string-utils";
-const CLI_COMMAND_EXECUTED_EVENT_SUBJECT = "platform.sdk.CliCommandExecutedEvent";
-const PAGINATION_PARAM_NAMES = new Set(["maxItems", "pageSize", "cursor"]);
-// Flags whose values may contain secrets and must not appear in telemetry
-const SENSITIVE_FLAGS = [
-    "--credentials",
-    "--credentials-client-secret",
-    "--credentials-client-id",
-    "--credentials-base-url",
-    "--user",
-    "--header",
-    "-H",
-    "-u",
-];
-export function sanitizeCliArguments(args) {
-    const sanitized = [];
-    let skipNext = false;
-    for (const arg of args) {
-        if (skipNext) {
-            skipNext = false;
-            sanitized.push("[REDACTED]");
-            continue;
-        }
-        if (SENSITIVE_FLAGS.some((flag) => arg.startsWith(flag + "="))) {
-            sanitized.push(arg.split("=")[0] + "=[REDACTED]");
-        }
-        else if (SENSITIVE_FLAGS.includes(arg)) {
-            sanitized.push(arg);
-            skipNext = true;
-        }
-        else {
-            sanitized.push(arg);
-        }
-    }
-    return sanitized;
-}
-function getNormalizedResult(result, { isListCommand }) {
-    if (result instanceof Response) {
-        return { kind: "response", value: result };
-    }
-    if (isListCommand) {
-        const sdkResult = result;
-        if (!Array.isArray(sdkResult?.data)) {
-            throw new Error(`List command returned unexpected shape (expected { data: [] }): ${JSON.stringify(result).slice(0, 200)}`);
-        }
-        return {
-            kind: "list",
-            data: sdkResult.data,
-            nextCursor: sdkResult.nextCursor,
-        };
-    }
-    const sdkResult = result;
-    return {
-        kind: "item",
-        value: result !== null && typeof result === "object" && "data" in result
-            ? sdkResult.data
-            : result,
-    };
-}
-function hasItems(sdkResult) {
-    return (sdkResult != null &&
-        typeof sdkResult.items === "function");
-}
-function hasPages(sdkResult) {
-    return (sdkResult != null &&
-        typeof sdkResult[Symbol.asyncIterator] === "function");
-}
-async function* toItemsStream(sdkResult) {
-    if (hasItems(sdkResult)) {
-        yield* sdkResult.items();
-        return;
-    }
-    if (hasPages(sdkResult)) {
-        for await (const page of sdkResult) {
-            yield* page.data ?? [];
-        }
-        return;
-    }
-    throw new ZapierCliExitError(`SDK method returned a value that is not async-iterable. Got: ${typeof sdkResult}. ` +
-        `List methods must return an AsyncIterable or an object with an items() method.`, 1);
-}
-async function collectItemsFromResult({ sdkResult, maxItems, }) {
-    const items = [];
-    for await (const item of toItemsStream(sdkResult)) {
-        items.push(item);
-        if (maxItems !== undefined && items.length >= maxItems)
-            break;
-    }
-    return maxItems !== undefined ? items.slice(0, maxItems) : items;
-}
-const CONFIRM_MESSAGES = {
-    "create-secret": {
-        messageBefore: "You are about to create a sensitive secret that will be displayed as plain text.\n" +
-            "Once created, you cannot retrieve it again.",
-        messageAfter: "Please treat this secret like a password and store it securely!",
-    },
-    delete: (itemType) => ({
-        messageBefore: `You are about to delete the ${itemType || "item"}.`,
-    }),
-};
-async function promptConfirm(confirmType, itemType) {
-    if (!confirmType || !CONFIRM_MESSAGES[confirmType]) {
-        return { confirmed: true }; // No confirmation needed
-    }
-    const configOrFn = CONFIRM_MESSAGES[confirmType];
-    const { messageBefore, messageAfter } = typeof configOrFn === "function" ? configOrFn(itemType) : configOrFn;
-    console.log(chalk.yellow(`\n${messageBefore}\n`));
-    const { confirmed } = await inquirer.prompt([
-        {
-            type: "confirm",
-            name: "confirmed",
-            message: "Continue?",
-            default: false,
-        },
-    ]);
-    return { confirmed, messageAfter };
-}
-function emitDeprecationWarning({ cliCommandName, deprecation, }) {
-    if (!deprecation) {
-        return;
-    }
-    console.warn();
-    console.warn(chalk.yellow.bold("⚠️  DEPRECATION WARNING") +
-        chalk.yellow(` - \`${cliCommandName}\` is deprecated.`));
-    console.warn(chalk.yellow(`   ${deprecation.message}`));
-    console.warn();
-}
-function emitParamDeprecationWarnings({ options, parameters, }) {
-    for (const param of parameters) {
-        if (!param.isDeprecated)
-            continue;
-        const value = options[param.name];
-        if (value === undefined)
-            continue;
-        if (Array.isArray(value) && value.length === 0)
-            continue;
-        console.warn();
-        console.warn(chalk.yellow.bold("⚠️  DEPRECATION WARNING") +
-            chalk.yellow(` - \`${toKebabCase(param.name)}\` is deprecated and may be removed in a future release.`));
-        if (param.deprecationMessage) {
-            console.warn(chalk.yellow(`   ${param.deprecationMessage}`));
-        }
-        console.warn();
-    }
-}
-function resolveOutputMode({ isListCommand, hasPaginationParams, hasUserSpecifiedMaxItems, }) {
-    if (!isListCommand || !hasPaginationParams)
-        return "single";
-    if (hasUserSpecifiedMaxItems)
-        return "collect";
-    return "paginate";
-}
-/** Extract the aliases map from a schema's metadata (e.g., { appKey: "app" }). */
-function getSchemaAliases(schema) {
-    return schema?.meta?.()?.aliases;
-}
-// ============================================================================
-// Schema Analysis
-// ============================================================================
-function analyzeZodSchema(schema, functionInfo) {
-    const parameters = [];
-    // Handle ZodEffects (schemas with .refine(), .transform(), etc.)
-    // In Zod, effects have type "effect" and inner schema is accessed via innerType
-    const schemaDef = schema._zod?.def;
-    if (schemaDef?.type === "effect" && schemaDef.innerType) {
-        return analyzeZodSchema(schemaDef.innerType, functionInfo);
-    }
-    if (schema instanceof z.ZodObject) {
-        const shape = schema.shape;
-        for (const [key, fieldSchema] of Object.entries(shape)) {
-            const param = analyzeZodField(key, fieldSchema, functionInfo);
-            if (param) {
-                parameters.push(param);
-            }
-        }
-    }
-    return parameters;
-}
-function analyzeZodField(name, schema, functionInfo) {
-    let baseSchema = schema;
-    let required = true;
-    let defaultValue = undefined;
-    let isDeprecated = false;
-    let deprecationMessage;
-    // Unwrap optional, default, and nullable wrappers - keep unwrapping until we get to the base type.
-    // Check .meta()?.deprecated at each level since it doesn't propagate through wrappers.
-    while (true) {
-        const meta = baseSchema.meta?.();
-        if (meta?.deprecated) {
-            isDeprecated = true;
-        }
-        if (meta?.deprecationMessage && !deprecationMessage) {
-            deprecationMessage = meta.deprecationMessage;
-        }
-        if (baseSchema instanceof z.ZodOptional) {
-            required = false;
-            baseSchema = baseSchema._zod.def.innerType;
-        }
-        else if (baseSchema instanceof z.ZodDefault) {
-            required = false;
-            const defValue = baseSchema._zod.def.defaultValue;
-            defaultValue = typeof defValue === "function" ? defValue() : defValue;
-            baseSchema = baseSchema._zod.def.innerType;
-        }
-        else {
-            // Check for ZodNullable - nullable doesn't affect CLI required status, but we need to unwrap it to get the base type
-            // Use _zod.def.type for Zod 4 compatibility (matches patterns elsewhere in codebase)
-            const zodDef = baseSchema._zod?.def;
-            if (zodDef?.type === "nullable" && zodDef.innerType) {
-                baseSchema = zodDef.innerType;
-                continue;
-            }
-            // No more wrappers to unwrap
-            break;
-        }
-    }
-    // Some schema kinds aren't expressible as CLI flags and would
-    // otherwise fall through to a bogus `--name <string>` flag:
-    //   - z.function() — onMessage / onError-style callbacks
-    //   - z.custom<AbortSignal>() and other custom predicates — passed
-    //     programmatically by callers, or filled in by a CLI-side
-    //     decorator plugin (closure-capture + override).
-    // Skip them so the auto-generated CLI surface stays clean.
-    const baseSchemaDef = baseSchema._zod?.def;
-    if (baseSchema instanceof z.ZodFunction || baseSchemaDef?.type === "custom") {
-        return null;
-    }
-    // Determine parameter type
-    let paramType = "string";
-    let elementType;
-    let choices;
-    if (baseSchema instanceof z.ZodString) {
-        paramType = "string";
-    }
-    else if (baseSchema instanceof z.ZodNumber) {
-        paramType = "number";
-    }
-    else if (baseSchema instanceof z.ZodBoolean) {
-        paramType = "boolean";
-    }
-    else if (baseSchema instanceof z.ZodArray) {
-        paramType = "array";
-        const elementSchema = baseSchema._zod.def.element;
-        if (elementSchema instanceof z.ZodObject ||
-            elementSchema instanceof z.ZodRecord) {
-            elementType = "object";
-        }
-        else if (elementSchema instanceof z.ZodNumber) {
-            elementType = "number";
-        }
-        else if (elementSchema instanceof z.ZodBoolean) {
-            elementType = "boolean";
-        }
-    }
-    else if (baseSchema instanceof z.ZodEnum) {
-        paramType = "string";
-        choices = baseSchema.options;
-    }
-    else if (baseSchema instanceof z.ZodObject ||
-        baseSchema instanceof z.ZodRecord) {
-        // User passes a JSON string; convertValue will parse it to an object
-        paramType = "object";
-    }
-    // Check if this parameter has a resolver
-    let paramHasResolver = false;
-    // Check function-specific resolvers first
-    if (functionInfo?.resolvers?.[name]) {
-        paramHasResolver = true;
-    }
-    // Extract resolver metadata
-    return {
-        name,
-        type: paramType,
-        required,
-        description: schema.description,
-        default: defaultValue,
-        choices,
-        hasResolver: paramHasResolver,
-        isPositional: isPositional(schema),
-        elementType,
-        deprecationMessage,
-        isDeprecated,
-    };
-}
-/**
- * Analyze inputParameters (used by multi-parameter functions like fetch) into flat CLI parameters.
- * Simple-type params become positional args; object-type params have their properties flattened into flags.
- */
-function analyzeInputParameters(inputParameters, functionInfo) {
-    const cliParams = [];
-    for (const param of inputParameters) {
-        let schema = param.schema;
-        let isOptional = false;
-        // Unwrap optional wrapper
-        if (schema instanceof z.ZodOptional) {
-            isOptional = true;
-            schema = schema._zod.def.innerType;
-        }
-        if (schema instanceof z.ZodObject) {
-            // Flatten object properties into individual CLI flags
-            const shape = schema.shape;
-            for (const [key, fieldSchema] of Object.entries(shape)) {
-                const analyzed = analyzeZodField(key, fieldSchema, functionInfo);
-                if (analyzed) {
-                    if (isOptional) {
-                        analyzed.required = false;
-                    }
-                    cliParams.push(analyzed);
-                }
-            }
-        }
-        else {
-            // Simple type — treat as positional argument
-            const analyzed = analyzeZodField(param.name, param.schema, functionInfo);
-            if (analyzed) {
-                analyzed.required = !isOptional;
-                analyzed.isPositional = true;
-                cliParams.push(analyzed);
-            }
-        }
-    }
-    return cliParams;
-}
-/**
- * Reconstruct positional arguments for SDK invocation from a flat params record.
- * Used when calling multi-parameter SDK functions (inputParameters) from the CLI.
- */
-function reconstructPositionalArgs(inputParameters, flatParams) {
-    const args = [];
-    for (const param of inputParameters) {
-        let schema = param.schema;
-        if (schema instanceof z.ZodOptional) {
-            schema = schema._zod.def.innerType;
-        }
-        if (schema instanceof z.ZodObject) {
-            const shape = schema.shape;
-            const obj = {};
-            let hasValues = false;
-            for (const key of Object.keys(shape)) {
-                if (key in flatParams && flatParams[key] !== undefined) {
-                    obj[key] = flatParams[key];
-                    hasValues = true;
-                }
-            }
-            args.push(hasValues ? obj : undefined);
-        }
-        else {
-            args.push(flatParams[param.name]);
-        }
-    }
-    return args;
-}
-// ============================================================================
-// CLI Structure Derivation - Purely Generic
-// ============================================================================
-/**
- * Convert SDK method name directly to CLI command
- * e.g., listApps -> list-apps, getApp -> get-app, generateTypes -> generate-types
- */
-function methodNameToCliCommand(methodName) {
-    return toKebabCase(methodName);
-}
-// ============================================================================
-// CLI Command Generation - Completely Generic
-// ============================================================================
-export function generateCliCommands(program, sdk) {
-    // Check if SDK has registry
-    if (typeof sdk.getRegistry !== "function") {
-        console.error("SDK registry not available");
-        return;
-    }
-    const registry = sdk.getRegistry({ package: "cli" });
-    // Create all commands first
-    registry.functions.forEach((fnInfo) => {
-        if (!fnInfo.inputSchema && !fnInfo.inputParameters) {
-            console.warn(`Schema not found for ${fnInfo.name}`);
-            return;
-        }
-        // Convert methodName to kebab-case CLI command
-        const cliCommandName = methodNameToCliCommand(fnInfo.name);
-        const config = createCommandConfig(cliCommandName, fnInfo, sdk);
-        addCommand(program, cliCommandName, config);
-    });
-    // Override the help display to show commands grouped by category
-    program.configureHelp({
-        formatHelp: (cmd, helper) => {
-            const helpWidth = helper.helpWidth || 80;
-            let output = helper.commandUsage(cmd) + "\n";
-            if (cmd.description()) {
-                output += helper.wrap(cmd.description(), helpWidth, 0) + "\n";
-            }
-            // Add options section
-            const options = helper.visibleOptions(cmd);
-            if (options.length > 0) {
-                output += "\nOptions:\n";
-                const longestOptionLength = Math.max(...options.map((opt) => helper.optionTerm(opt).length));
-                options.forEach((option) => {
-                    const term = helper.optionTerm(option);
-                    const padding = " ".repeat(Math.max(2, longestOptionLength - term.length + 4));
-                    output += `  ${term}${padding}${helper.optionDescription(option)}\n`;
-                });
-            }
-            // Add categorized commands section
-            const commands = helper.visibleCommands(cmd);
-            if (commands.length > 0) {
-                output += "\nCommands:\n";
-                // Collect all SDK commands that belong to categories
-                const categorizedCommands = new Set();
-                // Group SDK commands by categories
-                registry.categories.forEach((category) => {
-                    const categoryCommands = commands.filter((command) => category.functions.some((functionName) => {
-                        const cliCommandName = methodNameToCliCommand(functionName);
-                        return command.name() === cliCommandName;
-                    }));
-                    if (categoryCommands.length > 0) {
-                        output += `\n  ${category.titlePlural}:\n`;
-                        categoryCommands.forEach((command) => {
-                            output += `    ${helper.subcommandTerm(command)}\n`;
-                            categorizedCommands.add(command.name());
-                        });
-                    }
-                });
-                // Add any remaining commands that aren't part of SDK categories
-                const otherCommands = commands.filter((command) => !categorizedCommands.has(command.name()));
-                if (otherCommands.length > 0) {
-                    output += `\n  Other:\n`;
-                    otherCommands.forEach((command) => {
-                        output += `    ${helper.subcommandTerm(command)}\n`;
-                    });
-                }
-            }
-            return output;
-        },
-    });
-}
-function createCommandConfig(cliCommandName, functionInfo, sdk) {
-    const usesInputParameters = !functionInfo.inputSchema && !!functionInfo.inputParameters;
-    const schema = functionInfo.inputSchema;
-    const parameters = usesInputParameters
-        ? analyzeInputParameters(functionInfo.inputParameters, functionInfo)
-        : analyzeZodSchema(schema, functionInfo);
-    // Mark params that are aliases for other params (e.g., appKey is an alias for app).
-    const schemaAliases = getSchemaAliases(schema);
-    if (schemaAliases) {
-        const aliasedNames = new Set(Object.keys(schemaAliases));
-        for (const param of parameters) {
-            if (aliasedNames.has(param.name)) {
-                param.isAlias = true;
-            }
-        }
-    }
-    const baseDescription = functionInfo.description ||
-        schema?.description ||
-        `${cliCommandName} command`;
-    // Mark experimental commands clearly in --help so users know what they're
-    // touching. The command only reaches here at all when the experimental SDK
-    // factory is loaded, so we don't need to gate help visibility separately.
-    const description = functionInfo.experimental
-        ? `${baseDescription} (experimental)`
-        : baseDescription;
-    const handler = async (...args) => {
-        const startTime = Date.now();
-        let success = true;
-        let errorMessage = null;
-        // `resolvedParams` is populated below either by `resolveParameters` or
-        // by copying `rawParams`. The renderer captures this object by
-        // reference and reads from it inside formatter callbacks, so we
-        // mutate it in place (via `Object.assign`) once params are resolved
-        // rather than reassigning the binding, which would leave the
-        // renderer holding the empty initial object.
-        const resolvedParams = {};
-        // The last argument is always the command object with parsed options
-        const commandObj = args[args.length - 1];
-        const options = commandObj.opts();
-        // interactiveMode is true by default; --json disables it
-        const interactiveMode = !options.json;
-        const renderer = interactiveMode
-            ? createInteractiveRenderer({
-                sdk,
-                params: resolvedParams,
-            })
-            : createJsonRenderer();
-        try {
-            emitDeprecationWarning({
-                cliCommandName,
-                deprecation: functionInfo.deprecation,
-            });
-            emitParamDeprecationWarnings({ options, parameters });
-            // Check if this is a list command for pagination
-            const isListCommand = functionInfo.type === "list";
-            const hasPaginationParams = parameters.some((p) => PAGINATION_PARAM_NAMES.has(p.name));
-            const hasUserSpecifiedMaxItems = "maxItems" in options && options.maxItems !== undefined;
-            const outputMode = resolveOutputMode({
-                isListCommand,
-                hasPaginationParams,
-                hasUserSpecifiedMaxItems,
-            });
-            const rawParams = convertCliArgsToSdkParams(parameters, args.slice(0, -1), options);
-            // Remap aliased parameter names (e.g., authenticationId → connectionId)
-            const schemaAliases = getSchemaAliases(schema);
-            if (schemaAliases) {
-                for (const [oldName, newName] of Object.entries(schemaAliases)) {
-                    if (oldName in rawParams && !(newName in rawParams)) {
-                        rawParams[newName] = rawParams[oldName];
-                        delete rawParams[oldName];
-                    }
-                }
-            }
-            if (schema && !usesInputParameters) {
-                const resolver = new SchemaParameterResolver();
-                const resolved = (await resolver.resolveParameters(schema, rawParams, sdk, functionInfo.name, {
-                    interactiveMode,
-                    debug: !!options.debug ||
-                        process.env.DEBUG === "true" ||
-                        process.argv.includes("--debug"),
-                }));
-                Object.assign(resolvedParams, resolved);
-            }
-            else {
-                Object.assign(resolvedParams, rawParams);
-            }
-            const confirm = functionInfo.confirm;
-            let confirmMessageAfter;
-            if (confirm && interactiveMode) {
-                const confirmResult = await promptConfirm(confirm, functionInfo.itemType);
-                if (!confirmResult.confirmed) {
-                    console.log(chalk.yellow("Operation cancelled."));
-                    return;
-                }
-                confirmMessageAfter = confirmResult.messageAfter;
-            }
-            const sdkMethod = sdk[functionInfo.name];
-            switch (outputMode) {
-                case "paginate": {
-                    const source = sdkMethod(resolvedParams);
-                    await renderer.renderPaginatedList(source, functionInfo);
-                    break;
-                }
-                case "collect": {
-                    const maxItems = resolvedParams.maxItems;
-                    const sdkResult = sdkMethod({ ...resolvedParams, maxItems });
-                    const allItems = await collectItemsFromResult({
-                        sdkResult,
-                        maxItems,
-                    });
-                    await renderer.renderCollectedList(allItems, {
-                        maxItems,
-                        userSpecifiedMaxItems: hasUserSpecifiedMaxItems,
-                        functionInfo,
-                    });
-                    break;
-                }
-                case "single": {
-                    const callSdkMethod = () => {
-                        if (usesInputParameters) {
-                            const positionalArgs = reconstructPositionalArgs(functionInfo.inputParameters, resolvedParams);
-                            return sdkMethod(...positionalArgs);
-                        }
-                        return sdkMethod(resolvedParams);
-                    };
-                    const outputFile = resolvedParams.output;
-                    if (outputFile) {
-                        await callSdkMethod();
-                        renderer.renderItem(null, {
-                            outputFile,
-                            commandName: cliCommandName,
-                        });
-                        break;
-                    }
-                    const result = await callSdkMethod();
-                    const normalizedResult = getNormalizedResult(result, {
-                        isListCommand,
-                    });
-                    if (normalizedResult.kind === "response") {
-                        await renderer.renderResponse(normalizedResult.value);
-                    }
-                    else if (normalizedResult.kind === "list") {
-                        await renderer.renderCollectedList(normalizedResult.data, {
-                            maxItems: resolvedParams.maxItems,
-                            userSpecifiedMaxItems: hasUserSpecifiedMaxItems,
-                            functionInfo,
-                        });
-                    }
-                    else {
-                        renderer.renderItem(normalizedResult.value);
-                    }
-                    if (confirmMessageAfter) {
-                        console.log(chalk.yellow(`\n${confirmMessageAfter}`));
-                    }
-                    break;
-                }
-            }
-        }
-        catch (error) {
-            success = false;
-            errorMessage = error instanceof Error ? error.message : String(error);
-            if (error instanceof ZapierCliMissingParametersError) {
-                renderer.renderError(error);
-            }
-            else if (error instanceof ZapierCliValidationError) {
-                renderer.renderError(error);
-            }
-            else if (error instanceof ZapierCliError) {
-                throw error;
-            }
-            else {
-                renderer.renderError(error);
-            }
-        }
-        finally {
-            try {
-                const event = buildCliCommandExecutedEvent({
-                    data: {
-                        cli_primary_command: cliCommandName,
-                        success_flag: success,
-                        execution_duration_ms: Date.now() - startTime,
-                        exit_code: success ? 0 : 1,
-                        error_message: errorMessage,
-                        command_category: functionInfo.categories?.[0] ?? null,
-                        requires_auth: null,
-                        cli_arguments: sanitizeCliArguments(process.argv.slice(2)),
-                    },
-                    context: {
-                        selected_api: resolvedParams.app ?? null,
-                    },
-                });
-                sdk.context.eventEmission.emit(CLI_COMMAND_EXECUTED_EVENT_SUBJECT, event);
-            }
-            catch {
-                // Never let telemetry failures affect command execution
-            }
-        }
-    };
-    const handlerWithCallerContext = async (...args) => {
-        return runWithCallerContext({ packageOperation: cliCommandName }, () => handler(...args));
-    };
-    return {
-        description,
-        parameters,
-        handler: handlerWithCallerContext,
-        hidden: !!functionInfo.deprecation,
-        aliases: functionInfo.aliases,
-        supportsJsonOutput: functionInfo.supportsJsonOutput,
-    };
-}
-// Collect function for repeatable options (e.g., -d foo -d bar → ['foo', 'bar'])
-function collect(value, previous = []) {
-    previous.push(value);
-    return previous;
-}
-function addCommand(program, commandName, config) {
-    const command = program
-        .command(commandName, { hidden: config.hidden ?? false })
-        .description(config.description);
-    // Track whether we've already used a positional array parameter
-    let hasPositionalArray = false;
-    // Add parameters to command
-    config.parameters.forEach((param) => {
-        const kebabName = toKebabCase(param.name);
-        if (param.hasResolver && param.required) {
-            // Required parameters with resolvers become optional positional arguments (resolver handles prompting)
-            command.argument(`[${kebabName}]`, param.description || `${kebabName} parameter`);
-        }
-        else if (param.required &&
-            param.type === "array" &&
-            !hasPositionalArray) {
-            // First required array parameter becomes a variadic positional argument
-            hasPositionalArray = true;
-            command.argument(`<${kebabName}...>`, param.description || `${kebabName} parameter`);
-        }
-        else if (param.required && param.type === "array") {
-            // Subsequent required array parameters become required flags (repeatable)
-            const flags = [`--${kebabName}`];
-            const flagSignature = flags.join(", ") + ` <value>`;
-            command.requiredOption(flagSignature, param.description || `${kebabName} parameter (required, repeatable)`, collect, []);
-        }
-        else if (param.required) {
-            // Required parameters without resolvers become required positional arguments
-            command.argument(`<${kebabName}>`, param.description || `${kebabName} parameter`);
-        }
-        else if (param.isPositional && !param.isDeprecated && !param.isAlias) {
-            // Optional parameters marked as positional become optional positional arguments
-            command.argument(`[${kebabName}]`, param.description || `${kebabName} parameter`);
-        }
-        else {
-            // Optional parameters become flags (whether they have resolvers or not)
-            const flags = [];
-            // Add short alias if defined (single-letter aliases only)
-            const alias = config.aliases?.[param.name];
-            if (alias && alias.length === 1) {
-                flags.push(`-${alias}`);
-            }
-            flags.push(`--${kebabName}`);
-            if (param.type === "boolean") {
-                const opt = new Option(flags.join(", "), param.description);
-                if (param.isDeprecated)
-                    opt.hideHelp();
-                command.addOption(opt);
-            }
-            else if (param.type === "array") {
-                // For arrays, use collect pattern for repeatable flags (e.g., -d foo -d bar)
-                const flagSignature = flags.join(", ") + ` <value>`;
-                const opt = new Option(flagSignature, param.description || "");
-                opt.default([]);
-                opt.argParser((value, previous) => (previous || []).concat([value]));
-                if (param.isDeprecated)
-                    opt.hideHelp();
-                command.addOption(opt);
-            }
-            else {
-                const flagSignature = flags.join(", ") + ` <${param.type}>`;
-                const opt = new Option(flagSignature, param.description || "");
-                if (param.default !== undefined) {
-                    opt.default(param.default);
-                }
-                if (param.isDeprecated)
-                    opt.hideHelp();
-                command.addOption(opt);
-            }
-        }
-    });
-    // Add shared command options (if not already included or excluded by interactive mode)
-    const paramNames = new Set(config.parameters.map((p) => p.name));
-    SHARED_COMMAND_CLI_OPTIONS.forEach((opt) => {
-        if (paramNames.has(opt.name))
-            return;
-        if (config.supportsJsonOutput === false && opt.name === "json")
-            return;
-        command.option(opt.flag, opt.description);
-    });
-    command.action(config.handler);
-}
-// ============================================================================
-// Parameter Conversion
-// ============================================================================
-function convertCliArgsToSdkParams(parameters, positionalArgs, options) {
-    const sdkParams = {};
-    // Handle positional arguments (required parameters or optional positional parameters)
-    let argIndex = 0;
-    parameters.forEach((param) => {
-        if ((param.required ||
-            (param.isPositional && !param.isDeprecated && !param.isAlias)) &&
-            argIndex < positionalArgs.length) {
-            // Use the original camelCase parameter name for the SDK
-            sdkParams[param.name] = convertValue(positionalArgs[argIndex], param.type, param.elementType);
-            argIndex++;
-        }
-    });
-    // Handle option flags
-    Object.entries(options).forEach(([key, value]) => {
-        // Convert kebab-case back to camelCase
-        const camelKey = key.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
-        const param = parameters.find((p) => p.name === camelKey);
-        if (param && value !== undefined) {
-            // Skip empty arrays — Commander initializes repeatable options with []
-            // so an empty array means the user didn't pass the flag. Omitting it
-            // lets Zod's .default() supply the intended default value.
-            if (param.type === "array" &&
-                Array.isArray(value) &&
-                value.length === 0) {
-                return;
-            }
-            sdkParams[camelKey] = convertValue(value, param.type, param.elementType);
-        }
-    });
-    return sdkParams;
-}
-function convertValue(value, type, elementType) {
-    // Don't convert undefined values - let the resolver system handle them
-    if (value === undefined) {
-        return undefined;
-    }
-    switch (type) {
-        case "number":
-            return Number(value);
-        case "boolean":
-            return Boolean(value);
-        case "array": {
-            const arr = Array.isArray(value) ? value : [value];
-            if (elementType !== "object")
-                return arr;
-            return arr.flatMap((item) => {
-                if (typeof item === "string" &&
-                    (item.startsWith("{") || item.startsWith("["))) {
-                    try {
-                        return JSON.parse(item);
-                    }
-                    catch {
-                        return item;
-                    }
-                }
-                return item;
-            });
-        }
-        case "string":
-            return value;
-        case "object":
-            // Parse JSON string to object for z.record() and similar types
-            if (typeof value === "string") {
-                try {
-                    return JSON.parse(value);
-                }
-                catch {
-                    return value;
-                }
-            }
-            return value;
-        default:
-            // Unknown schema types - try to parse if it looks like JSON
-            if (typeof value === "string" &&
-                (value.startsWith("{") || value.startsWith("["))) {
-                try {
-                    return JSON.parse(value);
-                }
-                catch {
-                    return value;
-                }
-            }
-            return value;
-    }
-}