@zapier/zapier-sdk-cli 0.0.2 → 0.1.0

package/src/utils/parameter-resolver.ts

@@ -1,9 +1,12 @@
 import inquirer from "inquirer";
 import chalk from "chalk";
 import { z } from "zod";
-import { ActionsSdk } from "@zapier/zapier-sdk";
-
-// For editor-like prompts, we'll use a regular input prompt with multiline support
+import { ZapierSdk } from "@zapier/zapier-sdk";
+import {
+  getResolver,
+  hasResolver,
+  getResolutionOrderForParams,
+} from "@zapier/zapier-sdk";
 
 // ============================================================================
 // Types
@@ -14,12 +17,11 @@ interface ResolvableParameter {
   path: string[];
   schema: z.ZodType;
   description?: string;
-  resolverMeta?: any;
   isRequired: boolean;
 }
 
 interface ResolverContext {
-  sdk: ActionsSdk;
+  sdk: ZapierSdk;
   currentParams: any;
   resolvedParams: any;
 }
@@ -32,44 +34,57 @@ export class SchemaParameterResolver {
   async resolveParameters(
     schema: z.ZodSchema,
     providedParams: any,
-    sdk: ActionsSdk,
+    sdk: ZapierSdk,
   ): Promise<any> {
     // 1. Try to parse with current parameters
     const parseResult = schema.safeParse(providedParams);
 
-    // Even if parsing succeeds, check if we should resolve optional but important parameters
-    const allResolvable = this.findAllResolvableParameters(schema);
-    const shouldResolveAnyway = allResolvable.filter((param) => {
+    // Get all schema parameters to check which ones have resolvers
+    const allParams = this.extractParametersFromSchema(schema);
+    const resolvableParams = allParams.filter((param) =>
+      hasResolver(param.name),
+    );
+
+    // Get all missing parameters that have resolvers
+    const missingResolvable = resolvableParams.filter((param) => {
       const hasValue =
         this.getNestedValue(providedParams, param.path) !== undefined;
-      // Resolve any parameters with resolvers even if optional, unless explicitly provided
-      return !hasValue && param.resolverMeta?.resolver;
+      return !hasValue;
     });
 
-    if (parseResult.success && shouldResolveAnyway.length === 0) {
-      return parseResult.data;
-    }
+    // Determine which parameters are "functionally required" vs truly optional
+    // For run-action: appKey, actionType, actionKey are schema-required
+    // authenticationId and inputs are schema-optional but functionally needed
+    const functionallyRequired = missingResolvable.filter((param) => {
+      // Schema-required parameters are always functionally required
+      if (param.isRequired) return true;
 
-    // 2. Analyze what's missing and can be resolved
-    let missingResolvable: ResolvableParameter[];
+      // For run-action, inputs and authenticationId are functionally required
+      // even though schema-optional
+      if (param.name === "inputs" || param.name === "authenticationId") {
+        return true;
+      }
 
-    if (!parseResult.success) {
-      missingResolvable = this.findResolvableParameters(
-        schema,
-        parseResult.error,
-        providedParams,
-      );
-    } else {
-      // Schema parsing succeeded, but we want to resolve optional important parameters
-      missingResolvable = shouldResolveAnyway;
+      return false;
+    });
+
+    const trulyOptional = missingResolvable.filter(
+      (param) => !functionallyRequired.includes(param),
+    );
+
+    if (parseResult.success && functionallyRequired.length === 0) {
+      return parseResult.data;
     }
 
-    if (missingResolvable.length === 0) {
-      // No resolvable parameters, throw original error
-      throw parseResult.error;
+    if (functionallyRequired.length === 0) {
+      // No functionally required parameters missing, but check if we can parse
+      if (!parseResult.success) {
+        throw parseResult.error;
+      }
+      return parseResult.data;
     }
 
-    // 3. Resolve missing parameters interactively
+    // 2. Resolve functionally required parameters first
     const resolvedParams = { ...providedParams };
     const context: ResolverContext = {
       sdk,
@@ -77,27 +92,77 @@ export class SchemaParameterResolver {
       resolvedParams,
     };
 
-    // Sort by dependency order (parameters that depend on others go last)
-    const sortedMissing = this.sortByDependencies(missingResolvable);
+    if (functionallyRequired.length > 0) {
+      const requiredParamNames = functionallyRequired.map((p) => p.name);
+      const requiredResolutionOrder =
+        getResolutionOrderForParams(requiredParamNames);
 
-    for (const missing of sortedMissing) {
-      try {
-        const value = await this.resolveParameter(missing, context);
-        this.setNestedValue(resolvedParams, missing.path, value);
+      const orderedRequiredParams = requiredResolutionOrder
+        .map((paramName) =>
+          functionallyRequired.find((p) => p.name === paramName),
+        )
+        .filter((param): param is ResolvableParameter => param !== undefined);
 
-        // Update context with newly resolved value
-        context.resolvedParams = resolvedParams;
-      } catch (error) {
-        if (this.isUserCancellation(error)) {
-          console.log(chalk.yellow("\n\nOperation cancelled by user"));
-          process.exit(0);
+      for (const param of orderedRequiredParams) {
+        try {
+          const value = await this.resolveParameter(param, context);
+          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"));
+            process.exit(0);
+          }
+          console.error(chalk.red(`Failed to resolve ${param.name}:`), error);
+          throw error;
         }
-        console.error(chalk.red(`Failed to resolve ${missing.name}:`), error);
-        throw error;
       }
     }
 
-    // 4. Validate final parameters
+    // 3. 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 =
+          getResolutionOrderForParams(optionalParamNames);
+
+        const orderedOptionalParams = optionalResolutionOrder
+          .map((paramName) => trulyOptional.find((p) => p.name === paramName))
+          .filter((param): param is ResolvableParameter => param !== undefined);
+
+        for (const param of orderedOptionalParams) {
+          try {
+            const value = await this.resolveParameter(param, context);
+            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"));
+              process.exit(0);
+            }
+            console.error(chalk.red(`Failed to resolve ${param.name}:`), error);
+            throw error;
+          }
+        }
+      }
+    }
+
+    // 3. Validate final parameters
     const finalResult = schema.safeParse(resolvedParams);
 
     if (!finalResult.success) {
@@ -110,410 +175,230 @@ export class SchemaParameterResolver {
     return finalResult.data;
   }
 
-  private findAllResolvableParameters(
+  private extractParametersFromSchema(
     schema: z.ZodSchema,
   ): ResolvableParameter[] {
-    const resolvable: ResolvableParameter[] = [];
-    this.analyzeSchema(schema, [], resolvable);
-    return resolvable;
-  }
+    const parameters: ResolvableParameter[] = [];
 
-  private findResolvableParameters(
-    schema: z.ZodSchema,
-    error: z.ZodError,
-    providedParams: any,
-  ): ResolvableParameter[] {
-    const resolvable = this.findAllResolvableParameters(schema);
-
-    // Filter to only include parameters that are actually missing/invalid
-    const errorPaths = new Set(
-      error.issues.map((issue) => issue.path.join(".")),
-    );
-
-    return resolvable.filter((param) => {
-      const paramPath = param.path.join(".");
-      const isErrorPath = errorPaths.has(paramPath);
-      const hasValue =
-        this.getNestedValue(providedParams, param.path) !== undefined;
-
-      // Include if there's an error for this path or if it's required and missing
-      // Also include optional parameters that have resolvers and aren't provided
-      const shouldResolve =
-        isErrorPath ||
-        (param.isRequired && !hasValue) ||
-        (!param.isRequired && !hasValue && param.resolverMeta?.resolver);
-
-      return shouldResolve;
-    });
-  }
-
-  private analyzeSchema(
-    schema: z.ZodType,
-    currentPath: string[],
-    resolvable: ResolvableParameter[],
-  ): void {
-    // Handle different Zod types
+    // Only handle ZodObject at the top level
     if (schema instanceof z.ZodObject) {
       const shape = schema.shape;
-
-      Object.entries(shape).forEach(([key, fieldSchema]) => {
-        const fieldPath = [...currentPath, key];
-        this.analyzeSchemaField(
-          key,
-          fieldSchema as z.ZodType,
-          fieldPath,
-          resolvable,
-        );
-      });
-    } else if (schema instanceof z.ZodOptional) {
-      this.analyzeSchema(schema.unwrap(), currentPath, resolvable);
-    } else if (schema instanceof z.ZodDefault) {
-      this.analyzeSchema(schema.removeDefault(), currentPath, resolvable);
+      for (const [key, fieldSchema] of Object.entries<z.ZodSchema>(shape)) {
+        const param = this.analyzeFieldSchema(key, fieldSchema);
+        if (param) {
+          parameters.push(param);
+        }
+      }
     }
+
+    return parameters;
   }
 
-  private analyzeSchemaField(
-    name: string,
-    schema: z.ZodType,
-    path: string[],
-    resolvable: ResolvableParameter[],
-  ): void {
-    const resolverMeta = (schema._def as any).resolverMeta;
-
-    if (resolverMeta?.resolver) {
-      resolvable.push({
-        name,
-        path,
-        schema,
-        description: schema.description,
-        resolverMeta,
-        isRequired: !schema.isOptional(),
-      });
+  private analyzeFieldSchema(
+    fieldName: string,
+    fieldSchema: z.ZodSchema,
+  ): ResolvableParameter | null {
+    let baseSchema = fieldSchema;
+    let isRequired = true;
+
+    // Check if field is optional or has default
+    if (baseSchema instanceof z.ZodOptional) {
+      isRequired = false;
+      baseSchema = baseSchema._def.innerType;
     }
 
-    // Recursively analyze nested objects
-    if (schema instanceof z.ZodObject) {
-      this.analyzeSchema(schema, path, resolvable);
-    } else if (schema instanceof z.ZodOptional) {
-      this.analyzeSchemaField(name, schema.unwrap(), path, resolvable);
-    } else if (schema instanceof z.ZodDefault) {
-      this.analyzeSchemaField(name, schema.removeDefault(), path, resolvable);
+    if (baseSchema instanceof z.ZodDefault) {
+      isRequired = false;
+      baseSchema = baseSchema._def.innerType;
     }
-  }
-
-  private sortByDependencies(
-    parameters: ResolvableParameter[],
-  ): ResolvableParameter[] {
-    // Simple topological sort based on 'depends' field
-    const sorted: ResolvableParameter[] = [];
-    const remaining = [...parameters];
-
-    while (remaining.length > 0) {
-      const canResolve = remaining.filter((param) => {
-        const depends = param.resolverMeta?.resolver?.depends || [];
-        return depends.every((dep: string) =>
-          sorted.some((resolved) => resolved.name === dep),
-        );
-      });
-
-      if (canResolve.length === 0) {
-        // No more resolvable parameters, add remaining ones (circular dependency or no dependencies)
-        sorted.push(...remaining);
-        break;
-      }
 
-      sorted.push(...canResolve);
-      canResolve.forEach((param) => {
-        const index = remaining.indexOf(param);
-        remaining.splice(index, 1);
-      });
-    }
+    return this.createResolvableParameter([fieldName], baseSchema, isRequired);
+  }
 
-    return sorted;
+  private createResolvableParameter(
+    path: string[],
+    schema: z.ZodSchema,
+    isRequired: boolean,
+  ): ResolvableParameter | null {
+    if (path.length === 0) return null;
+
+    const name = path[path.length - 1];
+
+    return {
+      name,
+      path,
+      schema,
+      description: schema.description,
+      isRequired,
+    };
   }
 
   private async resolveParameter(
-    paramInfo: ResolvableParameter,
+    param: ResolvableParameter,
     context: ResolverContext,
   ): Promise<any> {
-    const resolver = paramInfo.resolverMeta?.resolver;
-
+    const resolver = getResolver(param.name);
     if (!resolver) {
-      return await this.promptStaticInput(paramInfo);
+      throw new Error(`No resolver found for parameter: ${param.name}`);
     }
 
-    if (resolver.type === "static") {
-      return await this.promptStaticInput(paramInfo, resolver);
-    }
-
-    if (resolver.type === "dynamic") {
-      return await this.resolveDynamicParameter(paramInfo, resolver, context);
-    }
-
-    if (resolver.type === "fields") {
-      return await this.resolveFieldsParameter(paramInfo, resolver, context);
-    }
-
-    throw new Error(`Unknown resolver type: ${resolver.type}`);
-  }
-
-  private async promptStaticInput(
-    paramInfo: ResolvableParameter,
-    resolver?: any,
-  ): Promise<any> {
-    const promptConfig: any = {
-      type:
-        resolver?.inputType === "editor"
-          ? "input"
-          : resolver?.inputType || "input",
-      name: "value",
-      message: `Enter ${paramInfo.description || paramInfo.name}${paramInfo.isRequired ? "" : " (optional)"}:`,
-    };
-
-    // Only use placeholder as default for required parameters
-    if (resolver?.placeholder && paramInfo.isRequired) {
-      promptConfig.default = resolver.placeholder;
-    }
+    console.log(chalk.blue(`\n🔍 Resolving ${param.name}...`));
 
-    // Add validation for required parameters
-    if (paramInfo.isRequired) {
-      promptConfig.validate = (input: any) => {
-        if (!input || (typeof input === "string" && input.trim() === "")) {
-          return "This field is required. Please enter a value.";
-        }
-        return true;
+    if (resolver.type === "static") {
+      // Static resolver - just prompt for input
+      const promptConfig = {
+        type: resolver.inputType === "password" ? "password" : "input",
+        name: param.name,
+        message: `Enter ${param.name}:`,
+        ...(resolver.placeholder && { default: resolver.placeholder }),
       };
-    }
 
-    // For editor-like prompts, provide helpful instructions
-    if (resolver?.inputType === "editor") {
-      promptConfig.message += " (JSON format)";
-    }
-
-    try {
-      const result = await inquirer.prompt([promptConfig]);
-
-      // For optional parameters, treat empty input as undefined
-      if (
-        !paramInfo.isRequired &&
-        (!result.value || result.value.trim() === "")
-      ) {
-        return undefined;
-      }
+      const answers = await inquirer.prompt([promptConfig as any]);
+      return answers[param.name];
+    } else if (resolver.type === "dynamic") {
+      // Dynamic resolver - fetch options and prompt for selection
+      try {
+        console.log(chalk.gray(`Fetching options for ${param.name}...`));
+        const items = await resolver.fetch(context.sdk, context.resolvedParams);
 
-      // Try to parse JSON if it looks like JSON
-      if (
-        typeof result.value === "string" &&
-        result.value.trim().startsWith("{")
-      ) {
-        try {
-          return JSON.parse(result.value);
-        } catch {
-          console.warn(
-            chalk.yellow("Warning: Could not parse as JSON, using as string"),
-          );
-          return result.value;
+        if (!items || items.length === 0) {
+          throw new Error(`No options available for ${param.name}`);
         }
-      }
-
-      return result.value;
-    } catch (error) {
-      if (this.isUserCancellation(error)) {
-        console.log(chalk.yellow("\n\nOperation cancelled by user"));
-        process.exit(0);
-      }
-      throw error;
-    }
-  }
-
-  private async resolveDynamicParameter(
-    paramInfo: ResolvableParameter,
-    resolver: any,
-    context: ResolverContext,
-  ): Promise<any> {
-    console.log(chalk.gray(`Fetching options for ${paramInfo.name}...`));
-
-    try {
-      // Use the new fetch function approach
-      const options = await resolver.fetch(context.sdk, context.resolvedParams);
-
-      if (options.length === 0) {
-        console.log(chalk.yellow(`No options available for ${paramInfo.name}`));
-        return await this.promptStaticInput(paramInfo);
-      }
-
-      // Generate prompt configuration
-      const promptConfig = resolver.prompt(options, context.resolvedParams);
 
-      // Execute the prompt
-      let result;
-      try {
-        result = await inquirer.prompt([promptConfig]);
+        const promptConfig = resolver.prompt(items, context.resolvedParams);
+        const answers = await inquirer.prompt([promptConfig as any]);
+        return answers[param.name];
       } catch (error) {
-        if (this.isUserCancellation(error)) {
-          console.log(chalk.yellow("\n\nOperation cancelled by user"));
-          process.exit(0);
-        }
+        console.error(
+          chalk.red(`Failed to fetch options for ${param.name}:`),
+          error instanceof Error ? error.message : error,
+        );
         throw error;
       }
-      let value = result[promptConfig.name || "value"];
+    } else if ((resolver as any).type === "fields") {
+      // Fields resolver - fetch field definitions and prompt for each input
+      try {
+        console.log(chalk.gray(`Fetching input fields for ${param.name}...`));
+        const fields = await (resolver as any).fetch(
+          context.sdk,
+          context.resolvedParams,
+        );
 
-      // Handle JSON parsing if the value looks like JSON
-      if (typeof value === "string" && value.trim().startsWith("{")) {
-        try {
-          value = JSON.parse(value);
-        } catch {
-          console.warn(
-            chalk.yellow("Warning: Could not parse as JSON, using as string"),
+        if (!fields || fields.length === 0) {
+          console.log(
+            chalk.yellow(`No input fields required for this action.`),
           );
+          return {};
         }
-      }
 
-      return value;
-    } catch (error) {
-      if (this.isUserCancellation(error)) {
-        console.log(chalk.yellow("\n\nOperation cancelled by user"));
-        process.exit(0);
-      }
-      if (error instanceof Error && error.message.includes("401")) {
-        console.log(
-          chalk.yellow(
-            `⚠️  Invalid auth token, falling back to manual input for ${paramInfo.name}`,
-          ),
-        );
-      } else {
-        console.error(
-          chalk.red(`Failed to fetch options for ${paramInfo.name}:`),
-          error,
-        );
-        console.log(chalk.yellow("Falling back to manual input..."));
-      }
-      return await this.promptStaticInput(paramInfo);
-    }
-  }
+        const inputs: Record<string, any> = {};
 
-  private async resolveFieldsParameter(
-    paramInfo: ResolvableParameter,
-    resolver: any,
-    context: ResolverContext,
-  ): Promise<any> {
-    console.log(
-      chalk.gray(`Fetching field definitions for ${paramInfo.name}...`),
-    );
+        // Separate required and optional fields
+        const requiredFields = fields.filter((field: any) => field.required);
+        const optionalFields = fields.filter((field: any) => !field.required);
 
-    try {
-      // Fetch field definitions using the resolver's fetch function
-      const fields = await resolver.fetch(context.sdk, context.resolvedParams);
-
-      if (fields.length === 0) {
-        console.log(chalk.yellow(`No input fields required for this action`));
-        return {};
-      }
-
-      console.log(
-        chalk.blue(
-          `\nConfiguring inputs for ${context.resolvedParams.app} ${context.resolvedParams.type} ${context.resolvedParams.action}:`,
-        ),
-      );
-
-      const inputs: Record<string, any> = {};
-
-      // Separate required and optional fields
-      const requiredFields = fields.filter((field: any) => field.required);
-      const optionalFields = fields.filter((field: any) => !field.required);
-
-      // First, prompt for all required fields
-      if (requiredFields.length > 0) {
-        console.log(
-          chalk.cyan(`\nRequired fields (${requiredFields.length}):`),
-        );
-        for (const field of requiredFields) {
-          await this.promptForField(field, inputs);
+        // First, prompt for all required fields
+        if (requiredFields.length > 0) {
+          console.log(
+            chalk.blue(
+              `\n📝 Please provide values for the following input fields:`,
+            ),
+          );
+          for (const field of requiredFields) {
+            await this.promptForField(field, inputs);
+          }
         }
-      }
 
-      // Then ask if user wants to configure optional fields
-      if (optionalFields.length > 0) {
-        console.log(
-          chalk.gray(
-            `\nThere are ${optionalFields.length} optional field(s) available.`,
-          ),
-        );
+        // Then ask if user wants to configure optional fields
+        if (optionalFields.length > 0) {
+          console.log(
+            chalk.gray(
+              `\nThere are ${optionalFields.length} optional field(s) available.`,
+            ),
+          );
 
-        let shouldConfigureOptional;
-        try {
-          shouldConfigureOptional = await inquirer.prompt([
-            {
-              type: "confirm",
-              name: "configure",
-              message: "Would you like to configure optional fields?",
-              default: false,
-            },
-          ]);
-        } catch (error) {
-          if (this.isUserCancellation(error)) {
-            console.log(chalk.yellow("\n\nOperation cancelled by user"));
-            process.exit(0);
+          let shouldConfigureOptional;
+          try {
+            shouldConfigureOptional = await inquirer.prompt([
+              {
+                type: "confirm",
+                name: "configure",
+                message: "Would you like to configure optional fields?",
+                default: false,
+              },
+            ]);
+          } catch (error) {
+            if (this.isUserCancellation(error)) {
+              console.log(chalk.yellow("\n\nOperation cancelled by user"));
+              process.exit(0);
+            }
+            throw error;
           }
-          throw error;
-        }
 
-        if (shouldConfigureOptional.configure) {
-          console.log(chalk.cyan(`\nOptional fields:`));
-          for (const field of optionalFields) {
-            await this.promptForField(field, inputs);
+          if (shouldConfigureOptional.configure) {
+            console.log(chalk.cyan(`\nOptional fields:`));
+            for (const field of optionalFields) {
+              await this.promptForField(field, inputs);
+            }
           }
         }
-      }
 
-      return inputs;
-    } catch (error) {
-      if (this.isUserCancellation(error)) {
-        console.log(chalk.yellow("\n\nOperation cancelled by user"));
-        process.exit(0);
+        return inputs;
+      } catch (error) {
+        console.error(
+          chalk.red(`Failed to fetch fields for ${param.name}:`),
+          error instanceof Error ? error.message : error,
+        );
+        throw error;
       }
-      console.error(
-        chalk.red(`Failed to fetch field definitions for ${paramInfo.name}:`),
-        error,
-      );
-      console.log(chalk.yellow("Falling back to manual JSON input..."));
-      return await this.promptStaticInput(paramInfo);
     }
+
+    throw new Error(`Unknown resolver type for ${param.name}`);
+  }
+
+  private getNestedValue(obj: any, path: string[]): any {
+    return path.reduce((current, key) => current?.[key], obj);
+  }
+
+  private setNestedValue(obj: any, path: string[], value: any): void {
+    const lastKey = path[path.length - 1];
+    const parent = path.slice(0, -1).reduce((current, key) => {
+      if (!(key in current)) {
+        current[key] = {};
+      }
+      return current[key];
+    }, obj);
+    parent[lastKey] = value;
   }
 
   private async promptForField(
     field: any,
     inputs: Record<string, any>,
   ): Promise<void> {
-    const fieldPrompt: any = {
-      type: "input",
+    const fieldPrompt = {
+      type: field.type === "boolean" ? "confirm" : "input",
       name: field.key,
       message: `${field.label || field.key}${field.required ? " (required)" : " (optional)"}:`,
+      ...(field.helpText && { prefix: chalk.gray(`ℹ ${field.helpText}\n`) }),
+      ...(field.default && { default: field.default }),
     };
 
-    // Add description/help text if available
-    if (field.help_text || field.description) {
-      fieldPrompt.message += `\n  ${chalk.dim(field.help_text || field.description)}`;
+    if (field.choices && field.choices.length > 0) {
+      fieldPrompt.type = "list";
+      (fieldPrompt as any).choices = field.choices.map((choice: any) => ({
+        name: choice.label || choice.value,
+        value: choice.value,
+      }));
     }
 
-    // Set default value
-    if (field.default !== undefined) {
-      fieldPrompt.default = field.default;
-    }
-
-    // Add validation for required fields
-    if (field.required) {
-      fieldPrompt.validate = (input: any) => {
-        if (!input || (typeof input === "string" && input.trim() === "")) {
-          return "This field is required. Please enter a value.";
-        }
-        return true;
-      };
-    }
-
-    let result;
     try {
-      result = await inquirer.prompt([fieldPrompt]);
+      const answer = await inquirer.prompt([fieldPrompt as any]);
+
+      if (answer[field.key] !== undefined && answer[field.key] !== "") {
+        inputs[field.key] = answer[field.key];
+      } else if (field.required) {
+        throw new Error(`Required field ${field.key} cannot be empty`);
+      }
     } catch (error) {
       if (this.isUserCancellation(error)) {
         console.log(chalk.yellow("\n\nOperation cancelled by user"));
@@ -521,53 +406,13 @@ export class SchemaParameterResolver {
       }
       throw error;
     }
-
-    // Only include non-empty values
-    if (result[field.key] !== undefined && result[field.key] !== "") {
-      let value = result[field.key];
-
-      // Try to parse as appropriate type
-      if (field.type === "integer" && typeof value === "string") {
-        const parsed = parseInt(value, 10);
-        if (!isNaN(parsed)) value = parsed;
-      } else if (field.type === "number" && typeof value === "string") {
-        const parsed = parseFloat(value);
-        if (!isNaN(parsed)) value = parsed;
-      } else if (field.type === "boolean" && typeof value === "string") {
-        value = value.toLowerCase() === "true" || value === "1";
-      }
-
-      inputs[field.key] = value;
-    }
-  }
-
-  private getNestedValue(obj: any, path: string[]): any {
-    return path.reduce((current, key) => current?.[key], obj);
-  }
-
-  private setNestedValue(obj: any, path: string[], value: any): void {
-    const lastKey = path[path.length - 1];
-    const parentPath = path.slice(0, -1);
-
-    const parent = parentPath.reduce((current, key) => {
-      if (!current[key]) {
-        current[key] = {};
-      }
-      return current[key];
-    }, obj);
-
-    parent[lastKey] = value;
   }
 
   private isUserCancellation(error: any): boolean {
-    // Check for various ways user cancellation can be detected
     return (
-      error &&
-      (error.name === "ExitPromptError" ||
-        error.message?.includes("User force closed the prompt") ||
-        error.message?.includes("SIGINT") ||
-        error.code === "SIGINT" ||
-        error.signal === "SIGINT")
+      error?.name === "ExitPromptError" ||
+      error?.message?.includes("User force closed") ||
+      error?.isTTYError
     );
   }
 }