@zapier/zapier-sdk-cli 0.5.0 → 0.6.1

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

@@ -108,12 +108,13 @@ function methodNameToCliCommand(methodName) {
 // ============================================================================
 export function generateCliCommands(program, sdk) {
     // Check if SDK has registry
-    if (!sdk.__registry) {
+    if (typeof sdk.getRegistry !== "function") {
         console.error("SDK registry not available");
         return;
     }
-    // Generate one flat command for each function in the registry
-    sdk.__registry.forEach((fnInfo) => {
+    const registry = sdk.getRegistry();
+    // Create all commands first
+    registry.functions.forEach((fnInfo) => {
         if (!fnInfo.inputSchema) {
             console.warn(`Schema not found for ${fnInfo.name}`);
             return;
@@ -123,6 +124,57 @@ export function generateCliCommands(program, sdk) {
         const config = createCommandConfig(cliCommandName, fnInfo.name, fnInfo.inputSchema, 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, sdkMethodName, schema, sdk) {
     const parameters = analyzeZodSchema(schema);

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

@@ -214,28 +214,31 @@ export class SchemaParameterResolver {
             throw new Error(`No resolver found for parameter: ${param.name}`);
         }
         console.log(chalk.blue(`\n🔍 Resolving ${param.name}...`));
-        if (resolver.type === "static") {
+        const typedResolver = resolver;
+        if (typedResolver.type === "static") {
             // Static resolver - just prompt for input
             const promptConfig = {
-                type: resolver.inputType === "password" ? "password" : "input",
+                type: typedResolver.inputType === "password" ? "password" : "input",
                 name: param.name,
                 message: `Enter ${param.name}:`,
-                ...(resolver.placeholder && { default: resolver.placeholder }),
+                ...(typedResolver.placeholder && {
+                    default: typedResolver.placeholder,
+                }),
             };
             const answers = await inquirer.prompt([promptConfig]);
             return answers[param.name];
         }
-        else if (resolver.type === "dynamic") {
+        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 resolver.fetch(context.sdk, context.resolvedParams);
+                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 = resolver.prompt(safeItems, context.resolvedParams);
+                const promptConfig = typedResolver.prompt(safeItems, context.resolvedParams);
                 const answers = await inquirer.prompt([promptConfig]);
                 return answers[param.name];
             }
@@ -244,13 +247,14 @@ export class SchemaParameterResolver {
                 throw error;
             }
         }
-        else if (resolver.type === "fields") {
+        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;
@@ -266,7 +270,7 @@ export class SchemaParameterResolver {
                 },
             };
             console.log(chalk.gray(`Fetching input fields for ${param.name}${iteration > 1 ? ` (iteration ${iteration})` : ""}...`));
-            const fields = await resolver.fetch(updatedContext.sdk, updatedContext.resolvedParams);
+            const fields = await typedResolver.fetch(updatedContext.sdk, updatedContext.resolvedParams);
             if (!fields || fields.length === 0) {
                 if (iteration === 1) {
                     console.log(chalk.yellow(`No input fields required for this action.`));

package/dist/src/utils/schema-formatter.d.ts

@@ -1,2 +1,2 @@
 import { z } from "zod";
-export declare function formatItemsFromSchema(inputSchema: z.ZodType, items: any[]): void;
+export declare function formatItemsFromSchema(inputSchema: z.ZodType, items: unknown[]): void;

package/dist/src/utils/schema-formatter.js

@@ -1,6 +1,7 @@
 import chalk from "chalk";
 function getFormatMetadata(schema) {
-    return schema?._def?.formatMeta;
+    return schema?._def
+        ?.formatMeta;
 }
 function getOutputSchema(schema) {
     return schema?._def?.outputSchema;
@@ -61,10 +62,11 @@ function applyStyle(value, style) {
 function formatItemsGeneric(items) {
     // Fallback formatting for items without schema metadata
     items.forEach((item, index) => {
-        const name = item.title || item.name || item.key || item.id || "Item";
+        const itemObj = item;
+        const name = itemObj.title || itemObj.name || itemObj.key || itemObj.id || "Item";
         console.log(`${chalk.gray(`${index + 1}.`)} ${chalk.cyan(name)}`);
-        if (item.description) {
-            console.log(`   ${chalk.dim(item.description)}`);
+        if (itemObj.description) {
+            console.log(`   ${chalk.dim(itemObj.description)}`);
         }
         console.log();
     });