@zapier/zapier-sdk-cli 0.19.0 → 0.22.0

package/dist/src/utils/parameter-resolver.js

@@ -1,699 +0,0 @@
-import inquirer from "inquirer";
-import chalk from "chalk";
-import { z } from "zod";
-import { ZapierCliUserCancellationError } from "./errors";
-// ============================================================================
-// Local Resolution Helper Functions
-// ============================================================================
-/**
- * Resolve dependency chain for a parameter using local resolvers
- * Returns parameters in the order they need to be resolved
- */
-function getLocalResolutionOrder(paramName, resolvers, resolved = new Set()) {
-    const resolver = resolvers[paramName];
-    if (!resolver || resolver.type === "static") {
-        return [paramName];
-    }
-    const order = [];
-    if ("depends" in resolver && resolver.depends) {
-        for (const dependency of resolver.depends) {
-            if (!resolved.has(dependency)) {
-                order.push(...getLocalResolutionOrder(dependency, resolvers, resolved));
-                resolved.add(dependency);
-            }
-        }
-    }
-    if (!resolved.has(paramName)) {
-        order.push(paramName);
-        resolved.add(paramName);
-    }
-    return order;
-}
-/**
- * Get resolution order for multiple parameters using local resolvers
- */
-function getLocalResolutionOrderForParams(paramNames, resolvers) {
-    const resolved = new Set();
-    const order = [];
-    for (const paramName of paramNames) {
-        const paramOrder = getLocalResolutionOrder(paramName, resolvers, resolved);
-        for (const param of paramOrder) {
-            if (!order.includes(param)) {
-                order.push(param);
-            }
-        }
-    }
-    return order;
-}
-// ============================================================================
-// Schema Parameter Resolver
-// ============================================================================
-export class SchemaParameterResolver {
-    async resolveParameters(schema, providedParams, sdk, functionName) {
-        // 1. Try to parse with current parameters
-        const parseResult = schema.safeParse(providedParams);
-        // Get all schema parameters to check which ones have resolvers
-        const allParams = this.extractParametersFromSchema(schema);
-        const resolvableParams = allParams.filter((param) => this.hasResolver(param.name, sdk, functionName));
-        // Get all missing parameters that have resolvers
-        const missingResolvable = resolvableParams.filter((param) => {
-            const hasValue = this.getNestedValue(providedParams, param.path) !== undefined;
-            return !hasValue;
-        });
-        // Determine parameter resolution categories:
-        // - functionally required: must be provided (inputs)
-        // - always prompt: should be prompted for but can be skipped (authenticationId)
-        // - truly optional: only ask if user wants to be prompted
-        const functionallyRequired = missingResolvable.filter((param) => {
-            // Schema-required parameters are always functionally required
-            if (param.isRequired)
-                return true;
-            // Only inputs is functionally required for run-action
-            if (param.name === "inputs") {
-                return true;
-            }
-            return false;
-        });
-        // Parameters that should always be prompted for directly, but can be skipped
-        const alwaysPrompt = missingResolvable.filter((param) => {
-            if (functionallyRequired.includes(param))
-                return false;
-            // authenticationId should always be prompted for (since it's usually needed)
-            // but can be skipped with "Continue without authentication"
-            if (param.name === "authenticationId") {
-                return true;
-            }
-            return false;
-        });
-        const trulyOptional = missingResolvable.filter((param) => !functionallyRequired.includes(param) && !alwaysPrompt.includes(param));
-        if (parseResult.success &&
-            functionallyRequired.length === 0 &&
-            alwaysPrompt.length === 0) {
-            return parseResult.data;
-        }
-        if (functionallyRequired.length === 0 && alwaysPrompt.length === 0) {
-            // No functionally required parameters missing, but check if we can parse
-            if (!parseResult.success) {
-                throw parseResult.error;
-            }
-            return parseResult.data;
-        }
-        // 2. Resolve functionally required parameters first
-        const resolvedParams = { ...providedParams };
-        const context = {
-            sdk,
-            currentParams: providedParams,
-            resolvedParams,
-            functionName,
-        };
-        // Get local resolvers for this function
-        const localResolvers = this.getLocalResolvers(sdk, functionName);
-        if (functionallyRequired.length > 0) {
-            const requiredParamNames = functionallyRequired.map((p) => p.name);
-            const requiredResolutionOrder = getLocalResolutionOrderForParams(requiredParamNames, localResolvers);
-            // Find all parameters that need to be resolved (including dependencies)
-            // from the available resolvable parameters
-            const orderedRequiredParams = requiredResolutionOrder
-                .map((paramName) => {
-                // First try to find in functionally required
-                let param = functionallyRequired.find((p) => p.name === paramName);
-                // If not found, try always prompt (for dependencies like authenticationId)
-                if (!param) {
-                    param = alwaysPrompt.find((p) => p.name === paramName);
-                }
-                // If not found, try truly optional (for other dependencies)
-                if (!param) {
-                    param = trulyOptional.find((p) => p.name === paramName);
-                }
-                return param;
-            })
-                .filter((param) => param !== undefined);
-            for (const param of orderedRequiredParams) {
-                try {
-                    const value = await this.resolveParameter(param, context, functionName);
-                    this.setNestedValue(resolvedParams, param.path, value);
-                    // Update context with newly resolved value
-                    context.resolvedParams = resolvedParams;
-                }
-                catch (error) {
-                    if (this.isUserCancellation(error)) {
-                        console.log(chalk.yellow("\n\nOperation cancelled by user"));
-                        throw new ZapierCliUserCancellationError();
-                    }
-                    throw error;
-                }
-            }
-            // Remove resolved dependencies from other categories to avoid double-prompting
-            const resolvedParamNames = new Set(orderedRequiredParams.map((p) => p.name));
-            alwaysPrompt.splice(0, alwaysPrompt.length, ...alwaysPrompt.filter((p) => !resolvedParamNames.has(p.name)));
-            trulyOptional.splice(0, trulyOptional.length, ...trulyOptional.filter((p) => !resolvedParamNames.has(p.name)));
-        }
-        // 3. Resolve parameters that should always be prompted for (but can be skipped)
-        if (alwaysPrompt.length > 0) {
-            const alwaysPromptNames = alwaysPrompt.map((p) => p.name);
-            const alwaysPromptResolutionOrder = getLocalResolutionOrderForParams(alwaysPromptNames, localResolvers);
-            const orderedAlwaysPromptParams = alwaysPromptResolutionOrder
-                .map((paramName) => alwaysPrompt.find((p) => p.name === paramName))
-                .filter((param) => param !== undefined);
-            for (const param of orderedAlwaysPromptParams) {
-                try {
-                    const value = await this.resolveParameter(param, context, functionName);
-                    this.setNestedValue(resolvedParams, param.path, value);
-                    // Update context with newly resolved value
-                    context.resolvedParams = resolvedParams;
-                }
-                catch (error) {
-                    if (this.isUserCancellation(error)) {
-                        console.log(chalk.yellow("\n\nOperation cancelled by user"));
-                        throw new ZapierCliUserCancellationError();
-                    }
-                    throw error;
-                }
-            }
-        }
-        // 4. Ask user if they want to resolve truly optional parameters
-        if (trulyOptional.length > 0) {
-            const optionalNames = trulyOptional.map((p) => p.name).join(", ");
-            const shouldResolveOptional = await inquirer.prompt([
-                {
-                    type: "confirm",
-                    name: "resolveOptional",
-                    message: `Would you like to be prompted for optional parameters (${optionalNames})?`,
-                    default: false,
-                },
-            ]);
-            if (shouldResolveOptional.resolveOptional) {
-                // Resolve optional parameters using their resolvers
-                const optionalParamNames = trulyOptional.map((p) => p.name);
-                const optionalResolutionOrder = getLocalResolutionOrderForParams(optionalParamNames, localResolvers);
-                const orderedOptionalParams = optionalResolutionOrder
-                    .map((paramName) => trulyOptional.find((p) => p.name === paramName))
-                    .filter((param) => param !== undefined);
-                for (const param of orderedOptionalParams) {
-                    try {
-                        const value = await this.resolveParameter(param, context, functionName);
-                        this.setNestedValue(resolvedParams, param.path, value);
-                        // Update context with newly resolved value
-                        context.resolvedParams = resolvedParams;
-                    }
-                    catch (error) {
-                        if (this.isUserCancellation(error)) {
-                            console.log(chalk.yellow("\n\nOperation cancelled by user"));
-                            throw new ZapierCliUserCancellationError();
-                        }
-                        throw error;
-                    }
-                }
-            }
-        }
-        // 3. Validate final parameters
-        const finalResult = schema.safeParse(resolvedParams);
-        if (!finalResult.success) {
-            console.error(chalk.red("❌ Parameter validation failed after resolution:"));
-            throw finalResult.error;
-        }
-        return finalResult.data;
-    }
-    extractParametersFromSchema(schema) {
-        const parameters = [];
-        // Only handle ZodObject at the top level
-        if (schema instanceof z.ZodObject) {
-            const shape = schema.shape;
-            for (const [key, fieldSchema] of Object.entries(shape)) {
-                const param = this.analyzeFieldSchema(key, fieldSchema);
-                if (param) {
-                    parameters.push(param);
-                }
-            }
-        }
-        return parameters;
-    }
-    analyzeFieldSchema(fieldName, fieldSchema) {
-        let baseSchema = fieldSchema;
-        let isRequired = true;
-        // Check if field is optional or has default
-        if (baseSchema instanceof z.ZodOptional) {
-            isRequired = false;
-            baseSchema = baseSchema._zod.def.innerType;
-        }
-        if (baseSchema instanceof z.ZodDefault) {
-            isRequired = false;
-            baseSchema = baseSchema._zod.def.innerType;
-        }
-        return this.createResolvableParameter([fieldName], baseSchema, isRequired);
-    }
-    createResolvableParameter(path, schema, isRequired) {
-        if (path.length === 0)
-            return null;
-        const name = path[path.length - 1];
-        return {
-            name,
-            path,
-            schema,
-            description: schema.description,
-            isRequired,
-        };
-    }
-    async resolveParameter(param, context, functionName) {
-        const resolver = this.getResolver(param.name, context.sdk, functionName);
-        if (!resolver) {
-            throw new Error(`No resolver found for parameter: ${param.name}`);
-        }
-        console.log(chalk.blue(`\n🔍 Resolving ${param.name}...`));
-        const typedResolver = resolver;
-        if (typedResolver.type === "static") {
-            // Static resolver - just prompt for input
-            const promptConfig = {
-                type: typedResolver.inputType === "password" ? "password" : "input",
-                name: param.name,
-                message: `Enter ${param.name}:`,
-                ...(typedResolver.placeholder && {
-                    default: typedResolver.placeholder,
-                }),
-            };
-            const answers = await inquirer.prompt([promptConfig]);
-            return answers[param.name];
-        }
-        else if (typedResolver.type === "dynamic") {
-            // Dynamic resolver - fetch options and prompt for selection
-            try {
-                // Only show "Fetching..." for required parameters that typically have many options
-                if (param.isRequired && param.name !== "authenticationId") {
-                    console.log(chalk.gray(`Fetching options for ${param.name}...`));
-                }
-                const items = await typedResolver.fetch(context.sdk, context.resolvedParams);
-                // Let the resolver's prompt handle empty lists (e.g., authenticationId can show "skip authentication")
-                const safeItems = items || [];
-                const promptConfig = typedResolver.prompt(safeItems, context.resolvedParams);
-                const answers = await inquirer.prompt([promptConfig]);
-                return answers[param.name];
-            }
-            catch (error) {
-                // Let the main CLI error handler display user-friendly errors
-                throw error;
-            }
-        }
-        else if (typedResolver.type === "fields") {
-            // Fields resolver - fetch field definitions and prompt for each input with recursive field resolution
-            return await this.resolveFieldsRecursively(resolver, context, param);
-        }
-        throw new Error(`Unknown resolver type for ${param.name}`);
-    }
-    async resolveFieldsRecursively(resolver, context, param) {
-        const typedResolver = resolver;
-        const inputs = {};
-        let processedFieldKeys = new Set();
-        let iteration = 0;
-        const maxIterations = 10; // Prevent infinite loops
-        while (iteration < maxIterations) {
-            iteration++;
-            // Update context with current inputs so they're passed to listInputFields
-            const updatedContext = {
-                ...context,
-                resolvedParams: {
-                    ...context.resolvedParams,
-                    inputs,
-                },
-            };
-            console.log(chalk.gray(`Fetching input fields for ${param.name}${iteration > 1 ? ` (iteration ${iteration})` : ""}...`));
-            const rootFieldItems = await typedResolver.fetch(updatedContext.sdk, updatedContext.resolvedParams);
-            if (!rootFieldItems || rootFieldItems.length === 0) {
-                if (iteration === 1) {
-                    console.log(chalk.yellow(`No input fields required for this action.`));
-                }
-                break;
-            }
-            // Process fields recursively, maintaining fieldset structure
-            const fieldStats = await this.processFieldItems(rootFieldItems, inputs, processedFieldKeys, [], iteration, updatedContext);
-            // If no new fields were processed, we're done
-            if (fieldStats.newRequired === 0 && fieldStats.newOptional === 0) {
-                break;
-            }
-            // If we only processed optional fields and skipped them, no need to re-fetch
-            if (fieldStats.newRequired === 0 && fieldStats.optionalSkipped) {
-                break;
-            }
-        }
-        if (iteration >= maxIterations) {
-            console.log(chalk.yellow(`\n⚠️  Maximum field resolution iterations reached. Some dynamic fields may not have been discovered.`));
-        }
-        return inputs;
-    }
-    /**
-     * Recursively processes fieldsets and their fields, maintaining natural structure
-     * and creating nested inputs as needed (e.g., fieldset "foo" becomes inputs.foo = [{}])
-     */
-    async processFieldItems(items, targetInputs, processedFieldKeys, fieldsetPath = [], iteration = 1, context) {
-        let newRequiredCount = 0;
-        let newOptionalCount = 0;
-        let optionalSkipped = false;
-        for (const item of items) {
-            const typedItem = item;
-            if (typedItem.type === "fieldset" && typedItem.fields && typedItem.key) {
-                // Show fieldset context to user
-                const fieldsetTitle = typedItem.title || typedItem.key;
-                const pathDisplay = fieldsetPath.length > 0 ? ` (in ${fieldsetPath.join(" > ")})` : "";
-                console.log(chalk.cyan(`\n📁 Processing fieldset: ${fieldsetTitle}${pathDisplay}`));
-                // Create fieldset array in target inputs if it doesn't exist
-                if (!targetInputs[typedItem.key]) {
-                    targetInputs[typedItem.key] = [{}];
-                }
-                // Process fields within this fieldset recursively
-                const fieldsetTarget = targetInputs[typedItem.key][0];
-                const nestedPath = [...fieldsetPath, fieldsetTitle];
-                const nestedStats = await this.processFieldItems(typedItem.fields, fieldsetTarget, processedFieldKeys, nestedPath, iteration, context);
-                newRequiredCount += nestedStats.newRequired;
-                newOptionalCount += nestedStats.newOptional;
-                if (nestedStats.optionalSkipped) {
-                    optionalSkipped = true;
-                }
-            }
-            else if (typedItem.type === "input_field" && typedItem.key) {
-                // Skip if already processed
-                if (processedFieldKeys.has(typedItem.key)) {
-                    continue;
-                }
-                const isRequired = typedItem.is_required || false;
-                if (isRequired) {
-                    // Process required field immediately
-                    newRequiredCount++;
-                    if (newRequiredCount === 1 && fieldsetPath.length === 0) {
-                        // Only show this message once at root level
-                        console.log(chalk.blue(`\n📝 Please provide values for the following ${iteration === 1 ? "" : "additional "}input fields:`));
-                    }
-                    await this.promptForField(typedItem, targetInputs, context);
-                    processedFieldKeys.add(typedItem.key);
-                }
-                else {
-                    // Collect optional fields for batch processing
-                    newOptionalCount++;
-                }
-            }
-            // Skip info fields - they're for display only
-        }
-        // Handle optional fields after processing all required fields
-        if (newOptionalCount > 0) {
-            const optionalFields = items.filter((item) => {
-                const typedItem = item;
-                return (typedItem.type === "input_field" &&
-                    typedItem.key &&
-                    !typedItem.is_required &&
-                    !processedFieldKeys.has(typedItem.key));
-            });
-            if (optionalFields.length > 0) {
-                const pathContext = fieldsetPath.length > 0 ? ` in ${fieldsetPath.join(" > ")}` : "";
-                console.log(chalk.gray(`\nThere are ${optionalFields.length} ${iteration === 1 ? "" : "additional "}optional field(s) available${pathContext}.`));
-                try {
-                    const shouldConfigureOptional = await inquirer.prompt([
-                        {
-                            type: "confirm",
-                            name: "configure",
-                            message: `Would you like to configure ${iteration === 1 ? "" : "these additional "}optional fields${pathContext}?`,
-                            default: false,
-                        },
-                    ]);
-                    if (shouldConfigureOptional.configure) {
-                        console.log(chalk.cyan(`\nOptional fields${pathContext}:`));
-                        for (const field of optionalFields) {
-                            await this.promptForField(field, targetInputs, context);
-                            const typedField = field;
-                            processedFieldKeys.add(typedField.key);
-                        }
-                    }
-                    else {
-                        optionalSkipped = true;
-                        // Mark these fields as processed even if skipped to avoid re-asking
-                        optionalFields.forEach((field) => {
-                            const typedField = field;
-                            processedFieldKeys.add(typedField.key);
-                        });
-                    }
-                }
-                catch (error) {
-                    if (this.isUserCancellation(error)) {
-                        console.log(chalk.yellow("\n\nOperation cancelled by user"));
-                        throw new ZapierCliUserCancellationError();
-                    }
-                    throw error;
-                }
-            }
-        }
-        return {
-            newRequired: newRequiredCount,
-            newOptional: newOptionalCount,
-            optionalSkipped,
-        };
-    }
-    getNestedValue(obj, path) {
-        return path.reduce((current, key) => current?.[key], obj);
-    }
-    setNestedValue(obj, path, value) {
-        const lastKey = path[path.length - 1];
-        const parent = path.slice(0, -1).reduce((current, key) => {
-            const currentObj = current;
-            if (!(key in currentObj)) {
-                currentObj[key] = {};
-            }
-            return currentObj[key];
-        }, obj);
-        parent[lastKey] = value;
-    }
-    /**
-     * Extract and normalize field metadata from raw field object
-     */
-    extractFieldMetadata(field) {
-        const fieldObj = field;
-        const valueType = fieldObj.value_type || "string";
-        return {
-            key: fieldObj.key,
-            title: fieldObj.title || fieldObj.label || fieldObj.key,
-            description: fieldObj.description || fieldObj.helpText,
-            isRequired: fieldObj.is_required || false,
-            defaultValue: fieldObj.default_value ?? fieldObj.default,
-            valueType,
-            hasDropdown: fieldObj.format === "SELECT",
-            isMultiSelect: Boolean(valueType === "array" ||
-                (fieldObj.items && fieldObj.items.type !== undefined)),
-        };
-    }
-    /**
-     * Fetch a page of choices for a dropdown field
-     */
-    async fetchChoices(fieldMeta, inputs, context, cursor) {
-        try {
-            console.log(chalk.gray(cursor
-                ? `  Fetching more choices...`
-                : `  Fetching choices for ${fieldMeta.title}...`));
-            const page = await context.sdk.listInputFieldChoices({
-                appKey: context.resolvedParams.appKey,
-                actionKey: context.resolvedParams.actionKey,
-                actionType: context.resolvedParams.actionType,
-                authenticationId: context.resolvedParams.authenticationId,
-                inputFieldKey: fieldMeta.key,
-                inputs,
-                ...(cursor && { cursor }),
-            });
-            const choices = page.data.map((choice) => ({
-                label: choice.label || choice.key || String(choice.value),
-                value: choice.value ?? choice.key,
-            }));
-            if (choices.length === 0 && !cursor) {
-                console.log(chalk.yellow(`  No choices available for ${fieldMeta.title}`));
-            }
-            return {
-                choices,
-                nextCursor: page.nextCursor,
-            };
-        }
-        catch (error) {
-            console.warn(chalk.yellow(`  ⚠️  Failed to fetch choices for ${fieldMeta.title}:`), error);
-            return { choices: [] };
-        }
-    }
-    /**
-     * Prompt user with choices (handles both single and multi-select with pagination)
-     */
-    async promptWithChoices({ fieldMeta, choices: initialChoices, nextCursor: initialCursor, inputs, context, }) {
-        const choices = [...initialChoices];
-        let nextCursor = initialCursor;
-        const LOAD_MORE_SENTINEL = Symbol("LOAD_MORE");
-        // Progressive loading loop
-        while (true) {
-            const promptChoices = choices.map((choice) => ({
-                name: choice.label,
-                value: choice.value,
-            }));
-            // Add "(Load more...)" option if there are more pages
-            if (nextCursor) {
-                promptChoices.push({
-                    name: chalk.dim("(Load more...)"),
-                    value: LOAD_MORE_SENTINEL,
-                });
-            }
-            // Add skip option for optional fields (single-select only)
-            if (!fieldMeta.isRequired && !fieldMeta.isMultiSelect) {
-                promptChoices.push({ name: "(Skip)", value: undefined });
-            }
-            const promptConfig = {
-                type: fieldMeta.isMultiSelect ? "checkbox" : "list",
-                name: fieldMeta.key,
-                message: `${fieldMeta.title}${fieldMeta.isRequired ? " (required)" : " (optional)"}:`,
-                choices: promptChoices,
-                ...(fieldMeta.isMultiSelect && {
-                    validate: (input) => {
-                        if (fieldMeta.isRequired && (!input || input.length === 0)) {
-                            return "At least one selection is required";
-                        }
-                        return true;
-                    },
-                }),
-            };
-            const answer = await inquirer.prompt([promptConfig]);
-            let selectedValue = answer[fieldMeta.key];
-            // Check if user selected "Load more..."
-            const wantsMore = fieldMeta.isMultiSelect
-                ? Array.isArray(selectedValue) &&
-                    selectedValue.includes(LOAD_MORE_SENTINEL)
-                : selectedValue === LOAD_MORE_SENTINEL;
-            if (wantsMore && nextCursor && context) {
-                // Remove sentinel from multi-select
-                if (fieldMeta.isMultiSelect && Array.isArray(selectedValue)) {
-                    selectedValue = selectedValue.filter((v) => v !== LOAD_MORE_SENTINEL);
-                }
-                // Fetch next page
-                const result = await this.fetchChoices(fieldMeta, inputs, context, nextCursor);
-                choices.push(...result.choices);
-                nextCursor = result.nextCursor;
-                // Re-prompt with updated choices
-                continue;
-            }
-            return selectedValue;
-        }
-    }
-    /**
-     * Prompt user for free-form input (text or boolean)
-     */
-    async promptFreeForm(fieldMeta) {
-        const promptConfig = {
-            name: fieldMeta.key,
-            message: `${fieldMeta.title}${fieldMeta.isRequired ? " (required)" : " (optional)"}:`,
-        };
-        if (fieldMeta.valueType === "boolean") {
-            promptConfig.type = "confirm";
-            promptConfig.default =
-                fieldMeta.defaultValue !== undefined
-                    ? Boolean(fieldMeta.defaultValue)
-                    : undefined;
-        }
-        else {
-            promptConfig.type = "input";
-            promptConfig.default = fieldMeta.defaultValue;
-            promptConfig.validate = (input) => {
-                if (fieldMeta.isRequired && !input) {
-                    return "This field is required";
-                }
-                return true;
-            };
-        }
-        // Add help text if available
-        if (fieldMeta.description) {
-            promptConfig.prefix = chalk.gray(`ℹ  ${fieldMeta.description}\n`);
-        }
-        try {
-            const answer = await inquirer.prompt([promptConfig]);
-            return answer[fieldMeta.key];
-        }
-        catch (error) {
-            if (this.isUserCancellation(error)) {
-                console.log(chalk.yellow("\n\nOperation cancelled by user"));
-                throw new ZapierCliUserCancellationError();
-            }
-            throw error;
-        }
-    }
-    /**
-     * Store field value in inputs object with validation
-     */
-    storeFieldValue(inputs, key, value, isRequired) {
-        try {
-            if (value !== undefined && value !== "") {
-                inputs[key] = value;
-            }
-            else if (isRequired) {
-                throw new Error(`Required field ${key} cannot be empty`);
-            }
-        }
-        catch (error) {
-            if (this.isUserCancellation(error)) {
-                console.log(chalk.yellow("\n\nOperation cancelled by user"));
-                throw new ZapierCliUserCancellationError();
-            }
-            throw error;
-        }
-    }
-    async promptForField(field, inputs, context) {
-        const fieldMeta = this.extractFieldMetadata(field);
-        // Fetch choices if field has dropdown
-        let choices = [];
-        let nextCursor;
-        if (fieldMeta.hasDropdown && context) {
-            const result = await this.fetchChoices(fieldMeta, inputs, context);
-            choices = result.choices;
-            nextCursor = result.nextCursor;
-        }
-        // Prompt user based on field type
-        let selectedValue;
-        if (choices.length > 0) {
-            selectedValue = await this.promptWithChoices({
-                fieldMeta,
-                choices,
-                nextCursor,
-                inputs,
-                context,
-            });
-        }
-        else {
-            selectedValue = await this.promptFreeForm(fieldMeta);
-        }
-        // Store result
-        this.storeFieldValue(inputs, fieldMeta.key, selectedValue, fieldMeta.isRequired);
-    }
-    isUserCancellation(error) {
-        const errorObj = error;
-        return (errorObj?.name === "ExitPromptError" ||
-            errorObj?.message?.includes("User force closed") ||
-            errorObj?.isTTYError === true);
-    }
-    hasResolver(paramName, sdk, functionName) {
-        // Check plugin-specific resolvers first
-        if (functionName && typeof sdk.getRegistry === "function") {
-            const registry = sdk.getRegistry({ package: "cli" });
-            const functionInfo = registry.functions.find((f) => f.name === functionName);
-            if (functionInfo && functionInfo.resolvers?.[paramName]) {
-                return true;
-            }
-        }
-        // No global registry fallback
-        return false;
-    }
-    getResolver(paramName, sdk, functionName) {
-        // Check plugin-specific resolvers first
-        if (functionName && typeof sdk.getRegistry === "function") {
-            const registry = sdk.getRegistry({ package: "cli" });
-            const functionInfo = registry.functions.find((f) => f.name === functionName);
-            if (functionInfo && functionInfo.resolvers?.[paramName]) {
-                return functionInfo.resolvers[paramName];
-            }
-        }
-        // No global registry fallback
-        return null;
-    }
-    getLocalResolvers(sdk, functionName) {
-        if (!functionName || typeof sdk.getRegistry !== "function") {
-            return {};
-        }
-        const registry = sdk.getRegistry();
-        const functionInfo = registry.functions.find((f) => f.name === functionName);
-        return functionInfo?.resolvers || {};
-    }
-}