@zapier/zapier-sdk-cli 0.0.3 → 0.1.0

package/dist/cli.js

@@ -14,12 +14,10 @@ program
 const isDebugMode = process.env.DEBUG === "true" || process.argv.includes("--debug");
 // Create SDK instance for CLI operations
 // Auth will be resolved from environment variables or command options
-const sdk = (0, zapier_sdk_1.createActionsSdk)({
+const sdk = (0, zapier_sdk_1.createZapierSdk)({
     // Token will be picked up from ZAPIER_TOKEN env var or provided via options
     debug: isDebugMode,
 });
 // Generate CLI commands from SDK schemas
 (0, cli_generator_1.generateCliCommands)(program, sdk);
-// Add enhanced help information
-(0, cli_generator_1.enhanceCommandHelp)(program);
 program.parse();

package/dist/utils/cli-generator.d.ts

@@ -1,4 +1,3 @@
 import { Command } from "commander";
-import { ActionsSdk } from "@zapier/zapier-sdk";
-export declare function generateCliCommands(program: Command, sdk: ActionsSdk): void;
-export declare function enhanceCommandHelp(program: Command): void;
+import { ZapierSdk } from "@zapier/zapier-sdk";
+export declare function generateCliCommands(program: Command, sdk: ZapierSdk): void;

package/dist/utils/cli-generator.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateCliCommands = generateCliCommands;
-exports.enhanceCommandHelp = enhanceCommandHelp;
 const zod_1 = require("zod");
 const zapier_sdk_1 = require("@zapier/zapier-sdk");
 const parameter_resolver_1 = require("./parameter-resolver");
@@ -80,7 +79,6 @@ function analyzeZodField(name, schema) {
         paramType = "string";
     }
     // Extract resolver metadata
-    const resolverMeta = schema._def.resolverMeta;
     return {
         name,
         type: paramType,
@@ -88,81 +86,75 @@ function analyzeZodField(name, schema) {
         description: schema.description,
         default: defaultValue,
         choices,
-        resolverMeta,
+        hasResolver: (0, zapier_sdk_1.hasResolver)(name),
     };
 }
 // ============================================================================
-// CLI Command Generation
+// CLI Structure Derivation - Purely Generic
+// ============================================================================
+/**
+ * Convert camelCase to kebab-case
+ * e.g., listApps -> list-apps, generateTypes -> generate-types
+ */
+function toKebabCase(str) {
+    return str.replace(/([A-Z])/g, "-$1").toLowerCase();
+}
+/**
+ * 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
 // ============================================================================
 function generateCliCommands(program, sdk) {
-    // Check if SdkSchemas is available
-    if (!zapier_sdk_1.SdkSchemas) {
-        console.error("SdkSchemas not available");
+    // Check if SDK has registry
+    if (!sdk.__registry) {
+        console.error("SDK registry not available");
         return;
     }
-    // Generate namespace commands (apps, actions, auths, fields)
-    Object.entries(zapier_sdk_1.SdkSchemas).forEach(([namespace, methods]) => {
-        if (namespace === "generate" || namespace === "bundle") {
-            // Handle root tools separately
+    // Generate one flat command for each function in the registry
+    sdk.__registry.forEach((fnInfo) => {
+        if (!fnInfo.inputSchema) {
+            console.warn(`Schema not found for ${fnInfo.name}`);
             return;
         }
-        const namespaceCommand = program
-            .command(namespace)
-            .description(`${namespace} management commands`);
-        if (typeof methods === "object" && methods !== null) {
-            Object.entries(methods).forEach(([method, schema]) => {
-                const config = createCommandConfig(namespace, method, schema, sdk);
-                addSubCommand(namespaceCommand, method, config);
-            });
-        }
+        // Convert methodName to kebab-case CLI command
+        const cliCommandName = methodNameToCliCommand(fnInfo.name);
+        const config = createCommandConfig(cliCommandName, fnInfo.name, fnInfo.inputSchema, sdk);
+        addCommand(program, cliCommandName, config);
     });
-    // Generate root tool commands
-    if (zapier_sdk_1.SdkSchemas.generate) {
-        const generateConfig = createCommandConfig("", "generate", zapier_sdk_1.SdkSchemas.generate, sdk);
-        addSubCommand(program, "generate", generateConfig);
-    }
-    if (zapier_sdk_1.SdkSchemas.bundle) {
-        const bundleConfig = createCommandConfig("", "bundle", zapier_sdk_1.SdkSchemas.bundle, sdk);
-        addSubCommand(program, "bundle", bundleConfig);
-    }
 }
-function createCommandConfig(namespace, method, schema, sdk) {
+function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
     const parameters = analyzeZodSchema(schema);
-    const description = schema.description || `${namespace} ${method} command`;
+    const description = schema.description || `${cliCommandName} command`;
     const handler = async (...args) => {
         try {
             // The last argument is always the command object with parsed options
-            const command = args[args.length - 1];
-            const options = command.opts();
-            // Check if this is a list command with pagination support
-            const isListCommand = method === "list";
+            const commandObj = args[args.length - 1];
+            const options = commandObj.opts();
+            // Check if this is a list command for pagination
+            const isListCommand = cliCommandName.startsWith("list-");
             const hasPaginationParams = parameters.some((p) => p.name === "limit" || p.name === "offset");
             const hasUserSpecifiedLimit = "limit" in options && options.limit !== undefined;
             const shouldUsePaging = isListCommand && hasPaginationParams && !hasUserSpecifiedLimit;
             const shouldUseJson = options.json;
             // Convert CLI args to SDK method parameters
             const rawParams = convertCliArgsToSdkParams(parameters, args.slice(0, -1), options);
-            // NEW: Resolve missing parameters interactively using schema metadata
+            // Resolve missing parameters interactively using schema metadata
             const resolver = new parameter_resolver_1.SchemaParameterResolver();
             const resolvedParams = await resolver.resolveParameters(schema, rawParams, sdk);
             if (shouldUsePaging && !shouldUseJson) {
                 // Use interactive paging for list commands
-                await handlePaginatedList(namespace, method, resolvedParams, sdk);
+                await handlePaginatedList(sdkMethodName, resolvedParams, sdk, schema);
             }
             else {
-                // Call the appropriate SDK method with complete, validated parameters
-                let result;
-                if (namespace === "") {
-                    // Root tool (generate, bundle)
-                    result = await sdk[method](resolvedParams);
-                }
-                else {
-                    // Regular namespace method
-                    result = await sdk[namespace][method](resolvedParams);
-                }
-                // Special handling for generate and bundle commands - don't output to console if writing to file
-                const isRootCommandWithOutput = namespace === "" && (method === "generate" || method === "bundle");
-                const hasOutputFile = isRootCommandWithOutput && resolvedParams.output;
+                // Call the SDK method directly
+                const result = await sdk[sdkMethodName](resolvedParams);
+                // Special handling for commands that write to files
+                const hasOutputFile = resolvedParams.output;
                 // Output result (JSON or formatted)
                 if (!hasOutputFile && (shouldUseJson || !isListCommand)) {
                     // Use raw JSON if --json flag is specified, otherwise use pretty formatting
@@ -175,17 +167,34 @@ function createCommandConfig(namespace, method, schema, sdk) {
                 }
                 else if (!hasOutputFile) {
                     // Format list results nicely (non-paginated)
-                    formatNonPaginatedResults(namespace, result, resolvedParams.limit, hasUserSpecifiedLimit, shouldUseJson);
+                    formatNonPaginatedResults(result, resolvedParams.limit, hasUserSpecifiedLimit, shouldUseJson, schema, sdkMethodName);
                 }
                 else if (hasOutputFile) {
                     // Show success message for file output instead of printing generated content
-                    console.log(chalk_1.default.green(`✅ ${method} completed successfully!`));
+                    console.log(chalk_1.default.green(`✅ ${cliCommandName} completed successfully!`));
                     console.log(chalk_1.default.gray(`Output written to: ${resolvedParams.output}`));
                 }
             }
         }
         catch (error) {
-            console.error("Error:", error instanceof Error ? error.message : "Unknown error");
+            // Handle Zod validation errors more gracefully
+            if (error instanceof Error && error.message.includes('"code"')) {
+                try {
+                    const validationErrors = JSON.parse(error.message);
+                    console.error(chalk_1.default.red("❌ Validation Error:"));
+                    validationErrors.forEach((err) => {
+                        const field = err.path?.join(".") || "unknown";
+                        console.error(chalk_1.default.yellow(`  • ${field}: ${err.message}`));
+                    });
+                    console.error("\n" + chalk_1.default.dim(`Use --help to see available options`));
+                }
+                catch {
+                    console.error(chalk_1.default.red("Error:"), error.message);
+                }
+            }
+            else {
+                console.error(chalk_1.default.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+            }
             process.exit(1);
         }
     };
@@ -195,23 +204,23 @@ function createCommandConfig(namespace, method, schema, sdk) {
         handler,
     };
 }
-function addSubCommand(parentCommand, name, config) {
-    const command = parentCommand.command(name).description(config.description);
+function addCommand(program, commandName, config) {
+    const command = program.command(commandName).description(config.description);
     // Add parameters to command
     config.parameters.forEach((param) => {
-        if (param.resolverMeta?.resolver && param.required) {
+        // Convert camelCase to kebab-case for CLI display
+        const kebabName = param.name.replace(/([A-Z])/g, "-$1").toLowerCase();
+        if (param.hasResolver && param.required) {
             // Required parameters with resolvers become optional positional arguments (resolver handles prompting)
-            command.argument(`[${param.name}]`, param.description || `${param.name} parameter`);
+            command.argument(`[${kebabName}]`, param.description || `${kebabName} parameter`);
         }
         else if (param.required) {
             // Required parameters without resolvers become required positional arguments
-            command.argument(`<${param.name}>`, param.description || `${param.name} parameter`);
+            command.argument(`<${kebabName}>`, param.description || `${kebabName} parameter`);
         }
         else {
             // Optional parameters become flags (whether they have resolvers or not)
-            const flags = [
-                `--${param.name.replace(/([A-Z])/g, "-$1").toLowerCase()}`,
-            ];
+            const flags = [`--${kebabName}`];
             if (param.type === "boolean") {
                 command.option(flags.join(", "), param.description);
             }
@@ -234,6 +243,7 @@ function convertCliArgsToSdkParams(parameters, positionalArgs, options) {
     let argIndex = 0;
     parameters.forEach((param) => {
         if (param.required && argIndex < positionalArgs.length) {
+            // Use the original camelCase parameter name for the SDK
             sdkParams[param.name] = convertValue(positionalArgs[argIndex], param.type);
             argIndex++;
         }
@@ -275,9 +285,9 @@ function convertValue(value, type) {
 // ============================================================================
 // Pagination Handlers
 // ============================================================================
-async function handlePaginatedList(namespace, method, baseParams, sdk) {
+async function handlePaginatedList(sdkMethodName, baseParams, sdk, schema) {
     const limit = baseParams.limit || 20;
-    const itemName = getItemName(namespace);
+    const itemName = getItemNameFromMethod(sdkMethodName);
     console.log(chalk_1.default.blue(`📋 Fetching ${itemName}...`));
     const pager = (0, pager_1.createPager)({
         pageSize: Math.min(limit, 20),
@@ -288,18 +298,14 @@ async function handlePaginatedList(namespace, method, baseParams, sdk) {
         if (items.length > 0) {
             console.clear();
         }
-        console.log(chalk_1.default.blue(`📋 ${getListTitle(namespace)}\n`));
+        console.log(chalk_1.default.blue(`📋 ${getListTitleFromMethod(sdkMethodName)}\n`));
         if (items.length === 0) {
             console.log(chalk_1.default.yellow(`No ${itemName} found.`));
             return;
         }
-        // Get the schema for this namespace/method to extract formatting info
-        const schema = zapier_sdk_1.SdkSchemas[namespace];
-        const listSchema = schema && typeof schema === "object" && "list" in schema
-            ? schema.list
-            : null;
-        if (listSchema) {
-            (0, schema_formatter_1.formatItemsFromSchema)(listSchema, items);
+        // Use schema for formatting
+        if (schema) {
+            (0, schema_formatter_1.formatItemsFromSchema)(schema, items);
         }
         else {
             // Fallback to generic formatting
@@ -310,12 +316,12 @@ async function handlePaginatedList(namespace, method, baseParams, sdk) {
             : "";
         console.log(chalk_1.default.green(`\n✅ Showing ${totalShown}${totalInfo} ${itemName}`));
     };
-    await pager.paginate((params) => sdk[namespace][method]({
+    await pager.paginate((params) => sdk[sdkMethodName]({
         ...baseParams,
         ...params,
     }), {}, displayFunction);
 }
-function formatNonPaginatedResults(namespace, result, requestedLimit, userSpecifiedLimit, useRawJson) {
+function formatNonPaginatedResults(result, requestedLimit, userSpecifiedLimit, useRawJson, schema, methodName) {
     if (!Array.isArray(result)) {
         if (useRawJson) {
             console.log(JSON.stringify(result, null, 2));
@@ -329,19 +335,15 @@ function formatNonPaginatedResults(namespace, result, requestedLimit, userSpecif
         console.log(JSON.stringify(result, null, 2));
         return;
     }
-    const itemName = getItemName(namespace);
+    const itemName = methodName ? getItemNameFromMethod(methodName) : "items";
     if (result.length === 0) {
         console.log(chalk_1.default.yellow(`No ${itemName} found.`));
         return;
     }
     console.log(chalk_1.default.green(`\n✅ Found ${result.length} ${itemName}:\n`));
-    // Get the schema for this namespace/method to extract formatting info
-    const schema = zapier_sdk_1.SdkSchemas[namespace];
-    const listSchema = schema && typeof schema === "object" && "list" in schema
-        ? schema.list
-        : null;
-    if (listSchema) {
-        (0, schema_formatter_1.formatItemsFromSchema)(listSchema, result);
+    // Use schema for formatting
+    if (schema) {
+        (0, schema_formatter_1.formatItemsFromSchema)(schema, result);
     }
     else {
         // Fallback to generic formatting
@@ -366,49 +368,21 @@ function formatItemsGeneric(items) {
         console.log();
     });
 }
-function getItemName(namespace) {
-    switch (namespace) {
-        case "apps":
-            return "apps";
-        case "actions":
-            return "actions";
-        case "auths":
-            return "authentications";
-        case "fields":
-            return "fields";
-        default:
-            return "items";
+// Generic helper functions that infer from schema description or method name
+function getItemNameFromMethod(methodName) {
+    // Extract from method name: listApps -> apps, listActions -> actions
+    const listMatch = methodName.match(/^list(.+)$/);
+    if (listMatch) {
+        return listMatch[1].toLowerCase();
     }
+    // Fallback to generic
+    return "items";
 }
-function getListTitle(namespace) {
-    switch (namespace) {
-        case "apps":
-            return "Available Apps";
-        case "actions":
-            return "Available Actions";
-        case "auths":
-            return "Available Authentications";
-        case "fields":
-            return "Available Fields";
-        default:
-            return "Available Items";
-    }
-}
-// ============================================================================
-// Help Text Enhancement
-// ============================================================================
-function enhanceCommandHelp(program) {
-    // Add custom help that shows schema-driven nature
-    program.on("--help", () => {
-        console.log("");
-        console.log("Commands are automatically generated from SDK schemas.");
-        console.log("Each command maps directly to an SDK method with the same parameters.");
-        console.log("");
-        console.log("Examples:");
-        console.log("  zapier-sdk apps list --category=productivity --limit=10");
-        console.log('  zapier-sdk actions run slack search user_by_email --inputs=\'{"email":"user@example.com"}\'');
-        console.log("  zapier-sdk generate my-app --output=./generated/");
-        console.log("  zsdk apps list --limit=5  # Using the shorter alias");
-        console.log("");
-    });
+function getListTitleFromMethod(methodName) {
+    const itemName = getItemNameFromMethod(methodName);
+    if (itemName === "items")
+        return "Available Items";
+    // Capitalize first letter: apps -> Apps
+    const capitalized = itemName.charAt(0).toUpperCase() + itemName.slice(1);
+    return `Available ${capitalized}`;
 }

package/dist/utils/parameter-resolver.d.ts

@@ -1,18 +1,13 @@
 import { z } from "zod";
-import { ActionsSdk } from "@zapier/zapier-sdk";
+import { ZapierSdk } from "@zapier/zapier-sdk";
 export declare class SchemaParameterResolver {
-    resolveParameters(schema: z.ZodSchema, providedParams: any, sdk: ActionsSdk): Promise<any>;
-    private findAllResolvableParameters;
-    private findResolvableParameters;
-    private analyzeSchema;
-    private analyzeSchemaField;
-    private sortByDependencies;
+    resolveParameters(schema: z.ZodSchema, providedParams: any, sdk: ZapierSdk): Promise<any>;
+    private extractParametersFromSchema;
+    private analyzeFieldSchema;
+    private createResolvableParameter;
     private resolveParameter;
-    private promptStaticInput;
-    private resolveDynamicParameter;
-    private resolveFieldsParameter;
-    private promptForField;
     private getNestedValue;
     private setNestedValue;
+    private promptForField;
     private isUserCancellation;
 }