@zapier/zapier-sdk-cli 0.0.3 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk-cli",
-  "version": "0.0.3",
+  "version": "0.1.1",
   "description": "Command line interface for Zapier SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,7 +25,7 @@
     "inquirer": "^12.6.3",
     "ora": "^8.2.0",
     "zod": "^3.25.67",
-    "@zapier/zapier-sdk": "0.0.3"
+    "@zapier/zapier-sdk": "0.1.1"
   },
   "devDependencies": {
     "@types/inquirer": "^9.0.8",
@@ -35,7 +35,9 @@
   },
   "scripts": {
     "test": "vitest",
-    "build": "tsc --project tsconfig.build.json",
+    "build": "rm -rf dist && tsc --project tsconfig.build.json",
+    "clean": "rm -rf dist",
+    "rebuild": "pnpm clean && pnpm build",
     "dev": "tsx src/cli.ts",
     "typecheck": "tsc --project tsconfig.build.json --noEmit"
   }

package/src/cli.ts

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 import { Command } from "commander";
-import { createActionsSdk } from "@zapier/zapier-sdk";
-import { generateCliCommands, enhanceCommandHelp } from "./utils/cli-generator";
+import { createZapierSdk } from "@zapier/zapier-sdk";
+import { generateCliCommands } from "./utils/cli-generator";
 
 const program = new Command();
 
@@ -18,7 +18,7 @@ const isDebugMode =
 
 // Create SDK instance for CLI operations
 // Auth will be resolved from environment variables or command options
-const sdk = createActionsSdk({
+const sdk = createZapierSdk({
   // Token will be picked up from ZAPIER_TOKEN env var or provided via options
   debug: isDebugMode,
 });
@@ -26,7 +26,4 @@ const sdk = createActionsSdk({
 // Generate CLI commands from SDK schemas
 generateCliCommands(program, sdk);
 
-// Add enhanced help information
-enhanceCommandHelp(program);
-
 program.parse();

package/src/utils/cli-generator.ts

@@ -1,6 +1,6 @@
 import { Command } from "commander";
 import { z } from "zod";
-import { ActionsSdk, SdkSchemas } from "@zapier/zapier-sdk";
+import { ZapierSdk, hasResolver, isPositional } from "@zapier/zapier-sdk";
 import { SchemaParameterResolver } from "./parameter-resolver";
 import { createPager } from "./pager";
 import { formatItemsFromSchema } from "./schema-formatter";
@@ -45,7 +45,8 @@ interface CliParameter {
   description?: string;
   default?: any;
   choices?: string[];
-  resolverMeta?: any;
+  hasResolver?: boolean;
+  isPositional?: boolean;
 }
 
 // ============================================================================
@@ -110,8 +111,6 @@ function analyzeZodField(
   }
 
   // Extract resolver metadata
-  const resolverMeta = (schema._def as any).resolverMeta;
-
   return {
     name,
     type: paramType,
@@ -119,84 +118,80 @@ function analyzeZodField(
     description: schema.description,
     default: defaultValue,
     choices,
-    resolverMeta,
+    hasResolver: hasResolver(name),
+    isPositional: isPositional(schema),
   };
 }
 
 // ============================================================================
-// CLI Command Generation
+// CLI Structure Derivation - Purely Generic
+// ============================================================================
+
+/**
+ * Convert camelCase to kebab-case
+ * e.g., listApps -> list-apps, generateTypes -> generate-types
+ */
+function toKebabCase(str: string): string {
+  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: string): string {
+  return toKebabCase(methodName);
+}
+
+// ============================================================================
+// CLI Command Generation - Completely Generic
 // ============================================================================
 
-export function generateCliCommands(program: Command, sdk: ActionsSdk): void {
-  // Check if SdkSchemas is available
-  if (!SdkSchemas) {
-    console.error("SdkSchemas not available");
+export function generateCliCommands(program: Command, sdk: ZapierSdk): void {
+  // Check if SDK has registry
+  if (!sdk.__registry) {
+    console.error("SDK registry not available");
     return;
   }
 
-  // Generate namespace commands (apps, actions, auths, fields)
-  Object.entries(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 as z.ZodSchema,
-          sdk,
-        );
-        addSubCommand(namespaceCommand, method, config);
-      });
-    }
-  });
+    // Convert methodName to kebab-case CLI command
+    const cliCommandName = methodNameToCliCommand(fnInfo.name);
 
-  // Generate root tool commands
-  if (SdkSchemas.generate) {
-    const generateConfig = createCommandConfig(
-      "",
-      "generate",
-      SdkSchemas.generate,
+    const config = createCommandConfig(
+      cliCommandName,
+      fnInfo.name,
+      fnInfo.inputSchema as z.ZodSchema,
       sdk,
     );
-    addSubCommand(program, "generate", generateConfig);
-  }
 
-  if (SdkSchemas.bundle) {
-    const bundleConfig = createCommandConfig(
-      "",
-      "bundle",
-      SdkSchemas.bundle,
-      sdk,
-    );
-    addSubCommand(program, "bundle", bundleConfig);
-  }
+    addCommand(program, cliCommandName, config);
+  });
 }
 
 function createCommandConfig(
-  namespace: string,
-  method: string,
+  cliCommandName: string,
+  sdkMethodName: string,
   schema: z.ZodSchema,
-  sdk: ActionsSdk,
+  sdk: ZapierSdk,
 ): CliCommandConfig {
   const parameters = analyzeZodSchema(schema);
-  const description = schema.description || `${namespace} ${method} command`;
+  const description = schema.description || `${cliCommandName} command`;
 
   const handler = async (...args: any[]) => {
     try {
       // The last argument is always the command object with parsed options
-      const command = args[args.length - 1];
-      const options = command.opts();
+      const commandObj = args[args.length - 1];
+      const options = commandObj.opts();
 
-      // Check if this is a list command with pagination support
-      const isListCommand = method === "list";
+      // 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",
       );
@@ -213,7 +208,7 @@ function createCommandConfig(
         options,
       );
 
-      // NEW: Resolve missing parameters interactively using schema metadata
+      // Resolve missing parameters interactively using schema metadata
       const resolver = new SchemaParameterResolver();
       const resolvedParams = await resolver.resolveParameters(
         schema,
@@ -223,22 +218,13 @@ function createCommandConfig(
 
       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: any;
-        if (namespace === "") {
-          // Root tool (generate, bundle)
-          result = await (sdk as any)[method](resolvedParams);
-        } else {
-          // Regular namespace method
-          result = await (sdk as any)[namespace][method](resolvedParams);
-        }
+        // Call the SDK method directly
+        const result: any = await (sdk as any)[sdkMethodName](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;
+        // Special handling for commands that write to files
+        const hasOutputFile = resolvedParams.output;
 
         // Output result (JSON or formatted)
         if (!hasOutputFile && (shouldUseJson || !isListCommand)) {
@@ -251,25 +237,45 @@ function createCommandConfig(
         } else if (!hasOutputFile) {
           // Format list results nicely (non-paginated)
           formatNonPaginatedResults(
-            namespace,
             result,
             resolvedParams.limit,
             hasUserSpecifiedLimit,
             shouldUseJson,
+            schema,
+            sdkMethodName,
           );
         } else if (hasOutputFile) {
           // Show success message for file output instead of printing generated content
-          console.log(chalk.green(`✅ ${method} completed successfully!`));
+          console.log(
+            chalk.green(`✅ ${cliCommandName} completed successfully!`),
+          );
           console.log(
             chalk.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.red("❌ Validation Error:"));
+          validationErrors.forEach((err: any) => {
+            const field = err.path?.join(".") || "unknown";
+            console.error(chalk.yellow(`  • ${field}: ${err.message}`));
+          });
+          console.error(
+            "\n" + chalk.dim(`Use --help to see available options`),
+          );
+        } catch {
+          console.error(chalk.red("Error:"), error.message);
+        }
+      } else {
+        console.error(
+          chalk.red("Error:"),
+          error instanceof Error ? error.message : "Unknown error",
+        );
+      }
       process.exit(1);
     }
   };
@@ -281,32 +287,39 @@ function createCommandConfig(
   };
 }
 
-function addSubCommand(
-  parentCommand: Command,
-  name: string,
+function addCommand(
+  program: Command,
+  commandName: string,
   config: CliCommandConfig,
 ): void {
-  const command = parentCommand.command(name).description(config.description);
+  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`,
+        `[${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`,
+        `<${kebabName}>`,
+        param.description || `${kebabName} parameter`,
+      );
+    } else if (param.isPositional) {
+      // 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 = [
-        `--${param.name.replace(/([A-Z])/g, "-$1").toLowerCase()}`,
-      ];
+      const flags = [`--${kebabName}`];
 
       if (param.type === "boolean") {
         command.option(flags.join(", "), param.description);
@@ -334,10 +347,14 @@ function convertCliArgsToSdkParams(
 ): Record<string, any> {
   const sdkParams: Record<string, any> = {};
 
-  // Handle positional arguments (required parameters only, whether they have resolvers or not)
+  // Handle positional arguments (required parameters or optional positional parameters)
   let argIndex = 0;
   parameters.forEach((param) => {
-    if (param.required && argIndex < positionalArgs.length) {
+    if (
+      (param.required || param.isPositional) &&
+      argIndex < positionalArgs.length
+    ) {
+      // Use the original camelCase parameter name for the SDK
       sdkParams[param.name] = convertValue(
         positionalArgs[argIndex],
         param.type,
@@ -390,13 +407,13 @@ function convertValue(value: any, type: CliParameter["type"]): any {
 // ============================================================================
 
 async function handlePaginatedList(
-  namespace: string,
-  method: string,
+  sdkMethodName: string,
   baseParams: any,
-  sdk: ActionsSdk,
+  sdk: ZapierSdk,
+  schema: z.ZodSchema,
 ): Promise<void> {
   const limit = baseParams.limit || 20;
-  const itemName = getItemName(namespace);
+  const itemName = getItemNameFromMethod(sdkMethodName);
 
   console.log(chalk.blue(`📋 Fetching ${itemName}...`));
 
@@ -414,22 +431,16 @@ async function handlePaginatedList(
     if (items.length > 0) {
       console.clear();
     }
-    console.log(chalk.blue(`📋 ${getListTitle(namespace)}\n`));
+    console.log(chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName)}\n`));
 
     if (items.length === 0) {
       console.log(chalk.yellow(`No ${itemName} found.`));
       return;
     }
 
-    // Get the schema for this namespace/method to extract formatting info
-    const schema = SdkSchemas[namespace as keyof typeof SdkSchemas];
-    const listSchema =
-      schema && typeof schema === "object" && "list" in schema
-        ? schema.list
-        : null;
-
-    if (listSchema) {
-      formatItemsFromSchema(listSchema as z.ZodType, items);
+    // Use schema for formatting
+    if (schema) {
+      formatItemsFromSchema(schema as z.ZodType, items);
     } else {
       // Fallback to generic formatting
       formatItemsGeneric(items);
@@ -445,7 +456,7 @@ async function handlePaginatedList(
 
   await pager.paginate(
     (params) =>
-      (sdk as any)[namespace][method]({
+      (sdk as any)[sdkMethodName]({
         ...baseParams,
         ...params,
       }),
@@ -455,11 +466,12 @@ async function handlePaginatedList(
 }
 
 function formatNonPaginatedResults(
-  namespace: string,
   result: any[],
   requestedLimit?: number,
   userSpecifiedLimit?: boolean,
   useRawJson?: boolean,
+  schema?: z.ZodSchema,
+  methodName?: string,
 ): void {
   if (!Array.isArray(result)) {
     if (useRawJson) {
@@ -475,7 +487,7 @@ function formatNonPaginatedResults(
     return;
   }
 
-  const itemName = getItemName(namespace);
+  const itemName = methodName ? getItemNameFromMethod(methodName) : "items";
 
   if (result.length === 0) {
     console.log(chalk.yellow(`No ${itemName} found.`));
@@ -484,15 +496,9 @@ function formatNonPaginatedResults(
 
   console.log(chalk.green(`\n✅ Found ${result.length} ${itemName}:\n`));
 
-  // Get the schema for this namespace/method to extract formatting info
-  const schema = SdkSchemas[namespace as keyof typeof SdkSchemas];
-  const listSchema =
-    schema && typeof schema === "object" && "list" in schema
-      ? schema.list
-      : null;
-
-  if (listSchema) {
-    formatItemsFromSchema(listSchema as z.ZodType, result);
+  // Use schema for formatting
+  if (schema) {
+    formatItemsFromSchema(schema as z.ZodType, result);
   } else {
     // Fallback to generic formatting
     formatItemsGeneric(result);
@@ -522,56 +528,23 @@ function formatItemsGeneric(items: any[]): void {
   });
 }
 
-function getItemName(namespace: string): string {
-  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: string): string {
+  // Extract from method name: listApps -> apps, listActions -> actions
+  const listMatch = methodName.match(/^list(.+)$/);
+  if (listMatch) {
+    return listMatch[1].toLowerCase();
   }
-}
 
-function getListTitle(namespace: string): string {
-  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";
-  }
+  // Fallback to generic
+  return "items";
 }
 
-// ============================================================================
-// Help Text Enhancement
-// ============================================================================
+function getListTitleFromMethod(methodName: string): string {
+  const itemName = getItemNameFromMethod(methodName);
+  if (itemName === "items") return "Available Items";
 
-export function enhanceCommandHelp(program: Command): void {
-  // 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("");
-  });
+  // Capitalize first letter: apps -> Apps
+  const capitalized = itemName.charAt(0).toUpperCase() + itemName.slice(1);
+  return `Available ${capitalized}`;
 }