@cerios/openapi-to-zod 0.3.0 → 0.5.0

package/README.md

@@ -834,14 +834,14 @@ All errors include:
 
 ## API Reference
 
-### `generateZodSchemas(options: GeneratorOptions): void`
+### `generateZodSchemas(options: OpenApiGeneratorOptions): void`
 
 Main function to generate schemas.
 
 #### Options
 
 ```typescript
-interface GeneratorOptions {
+interface OpenApiGeneratorOptions {
   /**
    * Object validation mode
    * - 'strict': Uses z.strictObject() - no additional properties allowed

package/dist/cli.js

@@ -4961,6 +4961,7 @@ var require_prompts3 = __commonJS({
 // src/cli.ts
 init_cjs_shims();
 var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
 var import_commander = require("commander");
 var import_prompts = __toESM(require_prompts3());
 
@@ -5012,7 +5013,7 @@ var ConfigurationError = class extends GeneratorError {
   }
 };
 
-// src/generator.ts
+// src/openapi-generator.ts
 init_cjs_shims();
 var import_node_fs = require("fs");
 var import_node_path = require("path");
@@ -6221,8 +6222,143 @@ _PropertyGenerator.INCLUSION_RULES = {
 };
 var PropertyGenerator = _PropertyGenerator;
 
-// src/generator.ts
-var ZodSchemaGenerator = class {
+// src/utils/operation-filters.ts
+init_cjs_shims();
+var import_minimatch = require("minimatch");
+function createFilterStatistics() {
+  return {
+    totalOperations: 0,
+    includedOperations: 0,
+    filteredByTags: 0,
+    filteredByPaths: 0,
+    filteredByMethods: 0,
+    filteredByOperationIds: 0,
+    filteredByDeprecated: 0
+  };
+}
+function matchesAnyPattern(value, patterns) {
+  if (!patterns || patterns.length === 0) {
+    return false;
+  }
+  if (!value) {
+    return false;
+  }
+  return patterns.some((pattern) => (0, import_minimatch.minimatch)(value, pattern));
+}
+function containsAny(arr, values) {
+  if (!values || values.length === 0) {
+    return false;
+  }
+  if (!arr || arr.length === 0) {
+    return false;
+  }
+  return values.some((value) => arr.includes(value));
+}
+function shouldIncludeOperation(operation, path, method, filters, stats) {
+  if (!filters) {
+    return true;
+  }
+  const methodLower = method.toLowerCase();
+  const operationId = operation == null ? void 0 : operation.operationId;
+  const tags = (operation == null ? void 0 : operation.tags) || [];
+  const deprecated = (operation == null ? void 0 : operation.deprecated) === true;
+  if (filters.includeTags && filters.includeTags.length > 0) {
+    if (!containsAny(tags, filters.includeTags)) {
+      if (stats) stats.filteredByTags++;
+      return false;
+    }
+  }
+  if (filters.includePaths && filters.includePaths.length > 0) {
+    if (!matchesAnyPattern(path, filters.includePaths)) {
+      if (stats) stats.filteredByPaths++;
+      return false;
+    }
+  }
+  if (filters.includeMethods && filters.includeMethods.length > 0) {
+    const methodsLower = filters.includeMethods.map((m) => m.toLowerCase());
+    if (!methodsLower.includes(methodLower)) {
+      if (stats) stats.filteredByMethods++;
+      return false;
+    }
+  }
+  if (filters.includeOperationIds && filters.includeOperationIds.length > 0) {
+    if (!matchesAnyPattern(operationId, filters.includeOperationIds)) {
+      if (stats) stats.filteredByOperationIds++;
+      return false;
+    }
+  }
+  if (filters.excludeDeprecated === true && deprecated) {
+    if (stats) stats.filteredByDeprecated++;
+    return false;
+  }
+  if (filters.excludeTags && filters.excludeTags.length > 0) {
+    if (containsAny(tags, filters.excludeTags)) {
+      if (stats) stats.filteredByTags++;
+      return false;
+    }
+  }
+  if (filters.excludePaths && filters.excludePaths.length > 0) {
+    if (matchesAnyPattern(path, filters.excludePaths)) {
+      if (stats) stats.filteredByPaths++;
+      return false;
+    }
+  }
+  if (filters.excludeMethods && filters.excludeMethods.length > 0) {
+    const methodsLower = filters.excludeMethods.map((m) => m.toLowerCase());
+    if (methodsLower.includes(methodLower)) {
+      if (stats) stats.filteredByMethods++;
+      return false;
+    }
+  }
+  if (filters.excludeOperationIds && filters.excludeOperationIds.length > 0) {
+    if (matchesAnyPattern(operationId, filters.excludeOperationIds)) {
+      if (stats) stats.filteredByOperationIds++;
+      return false;
+    }
+  }
+  return true;
+}
+function validateFilters(stats, filters) {
+  if (!filters || stats.totalOperations === 0) {
+    return;
+  }
+  if (stats.includedOperations === 0) {
+    console.warn(
+      `\u26A0\uFE0F  Warning: All ${stats.totalOperations} operations were filtered out. Check your operationFilters configuration.`
+    );
+    const filterBreakdown = [];
+    if (stats.filteredByTags > 0) filterBreakdown.push(`${stats.filteredByTags} by tags`);
+    if (stats.filteredByPaths > 0) filterBreakdown.push(`${stats.filteredByPaths} by paths`);
+    if (stats.filteredByMethods > 0) filterBreakdown.push(`${stats.filteredByMethods} by methods`);
+    if (stats.filteredByOperationIds > 0) filterBreakdown.push(`${stats.filteredByOperationIds} by operationIds`);
+    if (stats.filteredByDeprecated > 0) filterBreakdown.push(`${stats.filteredByDeprecated} by deprecated flag`);
+    if (filterBreakdown.length > 0) {
+      console.warn(`   Filtered: ${filterBreakdown.join(", ")}`);
+    }
+  }
+}
+function formatFilterStatistics(stats) {
+  if (stats.totalOperations === 0) {
+    return "";
+  }
+  const lines = [];
+  lines.push("Operation Filtering:");
+  lines.push(`  Total operations: ${stats.totalOperations}`);
+  lines.push(`  Included operations: ${stats.includedOperations}`);
+  const filteredCount = stats.filteredByTags + stats.filteredByPaths + stats.filteredByMethods + stats.filteredByOperationIds + stats.filteredByDeprecated;
+  if (filteredCount > 0) {
+    lines.push(`  Filtered operations: ${filteredCount}`);
+    if (stats.filteredByTags > 0) lines.push(`    - By tags: ${stats.filteredByTags}`);
+    if (stats.filteredByPaths > 0) lines.push(`    - By paths: ${stats.filteredByPaths}`);
+    if (stats.filteredByMethods > 0) lines.push(`    - By methods: ${stats.filteredByMethods}`);
+    if (stats.filteredByOperationIds > 0) lines.push(`    - By operationIds: ${stats.filteredByOperationIds}`);
+    if (stats.filteredByDeprecated > 0) lines.push(`    - By deprecated: ${stats.filteredByDeprecated}`);
+  }
+  return lines.join("\n");
+}
+
+// src/openapi-generator.ts
+var OpenApiGenerator = class {
   constructor(options) {
     this.schemas = /* @__PURE__ */ new Map();
     this.types = /* @__PURE__ */ new Map();
@@ -6232,6 +6368,7 @@ var ZodSchemaGenerator = class {
     this.schemaUsageMap = /* @__PURE__ */ new Map();
     this.schemaTypeModeMap = /* @__PURE__ */ new Map();
     this.needsZodImport = false;
+    this.filterStats = createFilterStatistics();
     var _a, _b, _c;
     if (!options.input) {
       throw new ConfigurationError("Input path is required", { providedOptions: options });
@@ -6249,7 +6386,8 @@ var ZodSchemaGenerator = class {
       showStats: (_c = options.showStats) != null ? _c : true,
       nativeEnumType: options.nativeEnumType || "union",
       request: options.request,
-      response: options.response
+      response: options.response,
+      operationFilters: options.operationFilters
     };
     try {
       const fs = require("fs");
@@ -6262,19 +6400,41 @@ var ZodSchemaGenerator = class {
       }
     }
     try {
-      const yamlContent = (0, import_node_fs.readFileSync)(this.options.input, "utf-8");
-      this.spec = (0, import_yaml.parse)(yamlContent);
+      const content = (0, import_node_fs.readFileSync)(this.options.input, "utf-8");
+      try {
+        this.spec = (0, import_yaml.parse)(content);
+      } catch (yamlError) {
+        try {
+          this.spec = JSON.parse(content);
+        } catch {
+          if (yamlError instanceof Error) {
+            const errorMessage = [
+              `Failed to parse OpenAPI specification from: ${this.options.input}`,
+              "",
+              `Error: ${yamlError.message}`,
+              "",
+              "Please ensure:",
+              "  - The file exists and is readable",
+              "  - The file contains valid YAML or JSON syntax",
+              "  - The file is a valid OpenAPI 3.x specification"
+            ].join("\n");
+            throw new SpecValidationError(errorMessage, {
+              filePath: this.options.input,
+              originalError: yamlError.message
+            });
+          }
+          throw yamlError;
+        }
+      }
     } catch (error) {
+      if (error instanceof SpecValidationError) {
+        throw error;
+      }
       if (error instanceof Error) {
         const errorMessage = [
-          `Failed to parse OpenAPI specification from: ${this.options.input}`,
-          "",
-          `Error: ${error.message}`,
+          `Failed to read OpenAPI specification from: ${this.options.input}`,
           "",
-          "Please ensure:",
-          "  - The file exists and is readable",
-          "  - The file contains valid YAML syntax",
-          "  - The file is a valid OpenAPI 3.x specification"
+          `Error: ${error.message}`
         ].join("\n");
         throw new SpecValidationError(errorMessage, { filePath: this.options.input, originalError: error.message });
       }
@@ -6332,6 +6492,8 @@ var ZodSchemaGenerator = class {
       this.generateComponentSchema(name, schema);
     }
     this.generateQueryParameterSchemas();
+    this.generateHeaderParameterSchemas();
+    validateFilters(this.filterStats, this.options.operationFilters);
     const orderedSchemaNames = this.topologicalSort();
     const output = ["// Auto-generated by @cerios/openapi-to-zod", "// Do not edit this file manually", ""];
     if (this.options.showStats === true) {
@@ -6425,9 +6587,16 @@ var ZodSchemaGenerator = class {
     const requestSchemas = /* @__PURE__ */ new Set();
     const responseSchemas = /* @__PURE__ */ new Set();
     if (this.spec.paths) {
-      for (const [, pathItem] of Object.entries(this.spec.paths)) {
-        for (const [, operation] of Object.entries(pathItem)) {
+      for (const [path, pathItem] of Object.entries(this.spec.paths)) {
+        const methods = ["get", "post", "put", "patch", "delete", "head", "options"];
+        for (const method of methods) {
+          const operation = pathItem[method];
           if (typeof operation !== "object" || !operation) continue;
+          this.filterStats.totalOperations++;
+          if (!shouldIncludeOperation(operation, path, method, this.options.operationFilters, this.filterStats)) {
+            continue;
+          }
+          this.filterStats.includedOperations++;
           if ("requestBody" in operation && operation.requestBody && typeof operation.requestBody === "object" && "content" in operation.requestBody && operation.requestBody.content) {
             for (const mediaType of Object.values(operation.requestBody.content)) {
               if (mediaType && typeof mediaType === "object" && "schema" in mediaType && mediaType.schema) {
@@ -6777,12 +6946,15 @@ ${typeCode}`;
     if (!this.spec.paths) {
       return;
     }
-    for (const [_path, pathItem] of Object.entries(this.spec.paths)) {
+    for (const [path, pathItem] of Object.entries(this.spec.paths)) {
       if (!pathItem || typeof pathItem !== "object") continue;
       const methods = ["get", "post", "put", "patch", "delete", "head", "options"];
       for (const method of methods) {
         const operation = pathItem[method];
         if (!operation) continue;
+        if (!shouldIncludeOperation(operation, path, method, this.options.operationFilters)) {
+          continue;
+        }
         if (!operation.operationId || !operation.parameters || !Array.isArray(operation.parameters)) {
           continue;
         }
@@ -6843,6 +7015,80 @@ ${propsCode}
         const jsdoc = `/**
  * Query parameters for ${operation.operationId}
  */
+`;
+        const fullSchemaCode = `${jsdoc}export const ${camelCaseSchemaName} = ${schemaCode};`;
+        this.schemas.set(schemaName, fullSchemaCode);
+        this.needsZodImport = true;
+      }
+    }
+  }
+  /**
+   * Generate header parameter schemas for each operation
+   * Header parameters are always string type (HTTP header semantics)
+   */
+  generateHeaderParameterSchemas() {
+    var _a;
+    if (!this.spec.paths) {
+      return;
+    }
+    for (const [path, pathItem] of Object.entries(this.spec.paths)) {
+      if (!pathItem || typeof pathItem !== "object") continue;
+      const methods = ["get", "post", "put", "patch", "delete", "head", "options"];
+      for (const method of methods) {
+        const operation = pathItem[method];
+        if (!operation) continue;
+        if (!shouldIncludeOperation(operation, path, method, this.options.operationFilters)) {
+          continue;
+        }
+        if (!operation.operationId || !operation.parameters || !Array.isArray(operation.parameters)) {
+          continue;
+        }
+        const headerParams = operation.parameters.filter(
+          (param) => param && typeof param === "object" && param.in === "header"
+        );
+        if (headerParams.length === 0) {
+          continue;
+        }
+        const pascalOperationId = operation.operationId.includes("-") ? toPascalCase(operation.operationId) : operation.operationId.charAt(0).toUpperCase() + operation.operationId.slice(1);
+        const schemaName = `${pascalOperationId}HeaderParams`;
+        if (!this.schemaDependencies.has(schemaName)) {
+          this.schemaDependencies.set(schemaName, /* @__PURE__ */ new Set());
+        }
+        const properties = {};
+        for (const param of headerParams) {
+          const paramName = param.name;
+          const paramSchema = param.schema;
+          if (!paramSchema) continue;
+          let zodType = "z.string()";
+          if (param.description && this.requestOptions.includeDescriptions) {
+            if (this.requestOptions.useDescribe) {
+              zodType = `${zodType}.describe(${JSON.stringify(param.description)})`;
+            }
+          }
+          zodType = `${zodType}.optional()`;
+          properties[paramName] = zodType;
+          if (paramSchema.$ref) {
+            const refName = resolveRef(paramSchema.$ref);
+            (_a = this.schemaDependencies.get(schemaName)) == null ? void 0 : _a.add(refName);
+          }
+        }
+        const objectMode = this.requestOptions.mode;
+        const zodMethod = objectMode === "strict" ? "strictObject" : objectMode === "loose" ? "looseObject" : "object";
+        const propsCode = Object.entries(properties).map(([key, value]) => {
+          const needsQuotes = !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key);
+          const quotedKey = needsQuotes ? `"${key}"` : key;
+          return `  ${quotedKey}: ${value}`;
+        }).join(",\n");
+        const schemaCode = `z.${zodMethod}({
+${propsCode}
+})`;
+        const operationName = pascalOperationId;
+        const prefixedName = this.options.prefix ? `${toPascalCase(this.options.prefix)}${operationName}` : operationName;
+        const suffixedName = this.options.suffix ? `${prefixedName}${toPascalCase(this.options.suffix)}` : prefixedName;
+        const camelCaseSchemaName = `${suffixedName.charAt(0).toLowerCase() + suffixedName.slice(1)}HeaderParamsSchema`;
+        const jsdoc = `/**
+ * Header parameters for ${operation.operationId}
+ */
 `;
         const fullSchemaCode = `${jsdoc}export const ${camelCaseSchemaName} = ${schemaCode};`;
         this.schemas.set(schemaName, fullSchemaCode);
@@ -7120,15 +7366,23 @@ ${props.join("\n")}
         stats.withConstraints++;
       }
     }
-    return [
+    const output = [
       "// Generation Statistics:",
       `//   Total schemas: ${stats.totalSchemas}`,
       `//   Enums: ${stats.enums}`,
       `//   Circular references: ${stats.withCircularRefs}`,
       `//   Discriminated unions: ${stats.withDiscriminators}`,
-      `//   With constraints: ${stats.withConstraints}`,
-      `//   Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`
+      `//   With constraints: ${stats.withConstraints}`
     ];
+    if (this.options.operationFilters && this.filterStats.totalOperations > 0) {
+      output.push("//");
+      const filterStatsStr = formatFilterStatistics(this.filterStats);
+      for (const line of filterStatsStr.split("\n")) {
+        output.push(`//   ${line}`);
+      }
+    }
+    output.push(`//   Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+    return output;
   }
 };
 
@@ -7136,7 +7390,7 @@ ${props.join("\n")}
 async function processSpec(spec, index, total) {
   console.log(`Processing [${index + 1}/${total}] ${spec.input}...`);
   try {
-    const generator = new ZodSchemaGenerator(spec);
+    const generator = new OpenApiGenerator(spec);
     generator.generate();
     console.log(`\u2713 Successfully generated ${spec.output}`);
     return {
@@ -7247,7 +7501,18 @@ var RequestResponseOptionsSchema = import_zod.z.strictObject({
   typeMode: TypeModeSchema.optional(),
   nativeEnumType: NativeEnumTypeSchema.optional()
 });
-var GeneratorOptionsSchema = import_zod.z.strictObject({
+var OperationFiltersSchema = import_zod.z.strictObject({
+  includeTags: import_zod.z.array(import_zod.z.string()).optional(),
+  excludeTags: import_zod.z.array(import_zod.z.string()).optional(),
+  includePaths: import_zod.z.array(import_zod.z.string()).optional(),
+  excludePaths: import_zod.z.array(import_zod.z.string()).optional(),
+  includeMethods: import_zod.z.array(import_zod.z.string()).optional(),
+  excludeMethods: import_zod.z.array(import_zod.z.string()).optional(),
+  includeOperationIds: import_zod.z.array(import_zod.z.string()).optional(),
+  excludeOperationIds: import_zod.z.array(import_zod.z.string()).optional(),
+  excludeDeprecated: import_zod.z.boolean().optional()
+});
+var OpenApiGeneratorOptionsSchema = import_zod.z.strictObject({
   mode: import_zod.z.enum(["strict", "normal", "loose"]).optional(),
   input: import_zod.z.string(),
   output: import_zod.z.string(),
@@ -7261,7 +7526,8 @@ var GeneratorOptionsSchema = import_zod.z.strictObject({
   nativeEnumType: NativeEnumTypeSchema.optional(),
   request: RequestResponseOptionsSchema.optional(),
   response: RequestResponseOptionsSchema.optional(),
-  name: import_zod.z.string().optional()
+  name: import_zod.z.string().optional(),
+  operationFilters: OperationFiltersSchema.optional()
 });
 var ConfigFileSchema = import_zod.z.strictObject({
   defaults: import_zod.z.strictObject({
@@ -7275,9 +7541,10 @@ var ConfigFileSchema = import_zod.z.strictObject({
     showStats: import_zod.z.boolean().optional(),
     nativeEnumType: NativeEnumTypeSchema.optional(),
     request: RequestResponseOptionsSchema.optional(),
-    response: RequestResponseOptionsSchema.optional()
+    response: RequestResponseOptionsSchema.optional(),
+    operationFilters: OperationFiltersSchema.optional()
   }).optional(),
-  specs: import_zod.z.array(GeneratorOptionsSchema).min(1, "At least one spec is required"),
+  specs: import_zod.z.array(OpenApiGeneratorOptionsSchema).min(1, "At least one spec is required"),
   executionMode: import_zod.z.enum(["parallel", "sequential"]).optional()
 });
 var createTypeScriptLoader = () => {
@@ -7424,6 +7691,36 @@ program.command("init").description("Initialize a new openapi-to-zod configurati
   }
 });
 program.parse();
+function findSpecFiles() {
+  const specFolders = ["spec", "specs"];
+  const validExtensions = [".yaml", ".yml", ".json"];
+  const excludePatterns = ["node_modules", ".git", "dist", "build", "coverage"];
+  const allFiles = [];
+  for (const folder of specFolders) {
+    if (!(0, import_node_fs2.existsSync)(folder)) continue;
+    try {
+      const entries = (0, import_node_fs2.readdirSync)(folder, { recursive: true, encoding: "utf-8" });
+      for (const entry of entries) {
+        const fullPath = (0, import_node_path2.join)(folder, entry);
+        if (excludePatterns.some((pattern) => fullPath.includes(pattern))) continue;
+        try {
+          const stats = (0, import_node_fs2.statSync)(fullPath);
+          if (!stats.isFile()) continue;
+          const hasValidExt = validExtensions.some((ext) => fullPath.endsWith(ext));
+          if (!hasValidExt) continue;
+          const sizeKB = (stats.size / 1024).toFixed(2);
+          allFiles.push({ path: fullPath.replace(/\\/g, "/"), size: `${sizeKB} KB` });
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  allFiles.sort((a, b) => a.path.localeCompare(b.path));
+  const totalCount = allFiles.length;
+  const files = allFiles.slice(0, 20);
+  return { files, totalCount };
+}
 async function executeConfigMode(options) {
   let config;
   try {
@@ -7457,14 +7754,66 @@ async function initConfigFile() {
       return;
     }
   }
-  const response = await (0, import_prompts.default)([
-    {
+  const { files, totalCount } = findSpecFiles();
+  if (totalCount > 20) {
+    console.log(`Showing first 20 of ${totalCount} files found. Use manual entry to specify others.
+`);
+  }
+  let inputPath;
+  if (files.length > 0) {
+    const choices = [
+      ...files.map((f) => ({ title: `${f.path} (${f.size})`, value: f.path })),
+      { title: "\u2192 Enter manually...", value: "__MANUAL__" }
+    ];
+    const inputResponse = await (0, import_prompts.default)({
+      type: "select",
+      name: "input",
+      message: "Select OpenAPI spec file (YAML or JSON):",
+      choices
+    });
+    if (!inputResponse.input) {
+      console.log("\nInitialization cancelled.");
+      return;
+    }
+    if (inputResponse.input === "__MANUAL__") {
+      const manualResponse = await (0, import_prompts.default)({
+        type: "text",
+        name: "input",
+        message: "Input OpenAPI file path (YAML or JSON):",
+        initial: "openapi.{yaml,yml,json}",
+        validate: (value) => {
+          if (value.length === 0) return "Input path is required";
+          if (!(0, import_node_fs2.existsSync)(value)) return "\u26A0\uFE0F  File does not exist. Continue anyway?";
+          return true;
+        }
+      });
+      if (!manualResponse.input) {
+        console.log("\nInitialization cancelled.");
+        return;
+      }
+      inputPath = manualResponse.input;
+    } else {
+      inputPath = inputResponse.input;
+    }
+  } else {
+    const manualResponse = await (0, import_prompts.default)({
       type: "text",
       name: "input",
-      message: "Input OpenAPI file path:",
-      initial: "openapi.yaml",
-      validate: (value) => value.length > 0 || "Input path is required"
-    },
+      message: "Input OpenAPI file path (YAML or JSON):",
+      initial: "openapi.{yaml,yml,json}",
+      validate: (value) => {
+        if (value.length === 0) return "Input path is required";
+        if (!(0, import_node_fs2.existsSync)(value)) return "\u26A0\uFE0F  File does not exist. Continue anyway?";
+        return true;
+      }
+    });
+    if (!manualResponse.input) {
+      console.log("\nInitialization cancelled.");
+      return;
+    }
+    inputPath = manualResponse.input;
+  }
+  const response = await (0, import_prompts.default)([
     {
       type: "text",
       name: "output",
@@ -7489,11 +7838,12 @@ async function initConfigFile() {
       initial: true
     }
   ]);
-  if (!response.input || !response.output || !response.format) {
+  if (!response.output || !response.format) {
     console.log("\nInitialization cancelled.");
     return;
   }
-  const { input, output, format, includeDefaults } = response;
+  const { output, format, includeDefaults } = response;
+  const input = inputPath;
   let configContent;
   let configFilename;
   if (format === "ts") {
@@ -7554,6 +7904,20 @@ export default defineConfig({
   console.log("\nNext steps:");
   console.log("  1. Review and customize your config file if needed");
   console.log("  2. Run 'openapi-to-zod' to generate schemas\n");
-  console.log("Things just got Cerios...\n");
+  const ceriosMessages = [
+    "Things just got Cerios!",
+    "Getting Cerios about schemas!",
+    "Cerios business ahead!",
+    "Don't take it too Cerios-ly!",
+    "Time to get Cerios!",
+    "We're dead Cerios about types!",
+    "This is Cerios-ly awesome!",
+    "Cerios-ly, you're all set!",
+    "You are Cerios right now!",
+    "Cerios vibes only!"
+  ];
+  const randomMessage = ceriosMessages[Math.floor(Math.random() * ceriosMessages.length)];
+  console.log(`${randomMessage}
+`);
 }
 //# sourceMappingURL=cli.js.map