@igniter-js/cli 0.4.91 → 0.4.93

package/dist/index.mjs

@@ -7,7 +7,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/index.ts
-import { Command as Command9 } from "commander";
+import { Command as Command10 } from "commander";
 
 // src/commands/init/index.ts
 import { Command } from "commander";
@@ -94,10 +94,10 @@ import { execa } from "execa";
 import { existsSync } from "fs";
 import { readFile, writeFile } from "fs/promises";
 import { join as join2 } from "path";
-import * as handlebars2 from "handlebars";
+import handlebars2 from "handlebars";
 
 // src/core/handlebars-helpers.ts
-import * as handlebars from "handlebars";
+import handlebars from "handlebars";
 function registerHandlebarsHelpers() {
   handlebars.registerHelper("includes", function(array, value) {
     if (!Array.isArray(array)) {
@@ -123,11 +123,11 @@ function registerHandlebarsHelpers() {
   handlebars.registerHelper("capitalizeSlug", function(slug) {
     return slug.replace(/-/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
   });
-  handlebars.registerHelper("get", function(obj, path24) {
-    if (!path24 || typeof path24 !== "string") {
+  handlebars.registerHelper("get", function(obj, path25) {
+    if (!path25 || typeof path25 !== "string") {
       return void 0;
     }
-    const pathArray = path24.split(".");
+    const pathArray = path25.split(".");
     let current = obj;
     for (let i = 0; i < pathArray.length; i++) {
       if (current === null || current === void 0) {
@@ -148,7 +148,7 @@ function registerHandlebarsHelpers() {
   });
   handlebars.registerHelper("filterPlugins", function(plugins = []) {
     if (!Array.isArray(plugins)) return [];
-    return plugins.filter((p13) => p13 !== "next-cookies");
+    return plugins.filter((p14) => p14 !== "next-cookies");
   });
   handlebars.registerHelper(
     "generatePluginImports",
@@ -162,7 +162,7 @@ function registerHandlebarsHelpers() {
         if (str === "open-api") return "openAPI";
         return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
       };
-      const regularPlugins = plugins.filter((p13) => p13 !== "next-cookies").map(camelCase);
+      const regularPlugins = plugins.filter((p14) => p14 !== "next-cookies").map(camelCase);
       const hasNextCookies = plugins.includes("next-cookies");
       const importStatements = [];
       if (regularPlugins.length > 0) {
@@ -334,9 +334,9 @@ var BaseStarter = class {
         }
         const outputPath = join2(projectDir, template.outputPath);
         const outputDir = join2(outputPath, "..");
-        await import("fs").then((fs8) => {
-          if (!fs8.existsSync(outputDir)) {
-            fs8.mkdirSync(outputDir, { recursive: true });
+        await import("fs").then((fs9) => {
+          if (!fs9.existsSync(outputDir)) {
+            fs9.mkdirSync(outputDir, { recursive: true });
           }
         });
         await writeFile(outputPath, renderedContent);
@@ -676,7 +676,7 @@ import path4 from "path";
 import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
 import { join as join3 } from "path";
-import * as handlebars3 from "handlebars";
+import handlebars3 from "handlebars";
 var BaseAddOn = class {
   async runSetup(projectDir, config) {
     await this.addToPackageJson(projectDir, config);
@@ -971,9 +971,9 @@ var BaseAddOn = class {
         }
         const outputPath = join3(projectDir, template.outputPath);
         const outputDir = join3(outputPath, "..");
-        await import("fs").then((fs8) => {
-          if (!fs8.existsSync(outputDir)) {
-            fs8.mkdirSync(outputDir, { recursive: true });
+        await import("fs").then((fs9) => {
+          if (!fs9.existsSync(outputDir)) {
+            fs9.mkdirSync(outputDir, { recursive: true });
           }
         });
         await writeFile2(outputPath, renderedContent);
@@ -1838,9 +1838,9 @@ var addOnRegistry = AddOnRegistry.create().register(new RedisStoreAddOn()).regis
 
 // src/core/file-system.ts
 import * as fs2 from "fs/promises";
-async function isPathEmpty(path24) {
+async function isPathEmpty(path25) {
   try {
-    const files = await fs2.readdir(path24);
+    const files = await fs2.readdir(path25);
     return files.length === 0;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -2173,14 +2173,14 @@ var ProjectGenerator = class {
       dockerSetup.message(
         `Checking and stopping currently running containers...`
       );
-      const fs8 = await import("fs/promises");
-      const path24 = await import("path");
-      const yaml = await import("js-yaml");
-      const composeFilePath = path24.join(this.targetDir, "docker-compose.yml");
+      const fs9 = await import("fs/promises");
+      const path25 = await import("path");
+      const yaml2 = await import("js-yaml");
+      const composeFilePath = path25.join(this.targetDir, "docker-compose.yml");
       let ports = [];
       try {
-        const composeContent = await fs8.readFile(composeFilePath, "utf8");
-        const doc = yaml.load(composeContent);
+        const composeContent = await fs9.readFile(composeFilePath, "utf8");
+        const doc = yaml2.load(composeContent);
         const services = doc?.services || {};
         for (const svcKey of Object.keys(services)) {
           const service = services[svcKey];
@@ -2287,7 +2287,7 @@ var initCommand = new Command().command("init").description("Create a new Ignite
 ).option("--no-git", "Skip git repository initialization").option("--no-install", "Skip automatic dependency installation").option("--no-docker", "Skip Docker Compose setup").action(handleInitAction);
 
 // src/commands/generate/index.ts
-import { Command as Command7 } from "commander";
+import { Command as Command8 } from "commander";
 
 // src/commands/generate/feature/index.ts
 import { Command as Command2 } from "commander";
@@ -2302,7 +2302,7 @@ import { writeFile as writeFile5 } from "fs/promises";
 import { mkdirSync, existsSync as existsSync3 } from "fs";
 import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 import * as path14 from "path";
-import * as handlebars4 from "handlebars";
+import handlebars4 from "handlebars";
 import { fileURLToPath } from "url";
 var __filename = fileURLToPath(import.meta?.url);
 var __dirname = path14.dirname(__filename);
@@ -2900,8 +2900,8 @@ async function handleGenerateFeatureAction(name, options) {
     p7.outro("Nothing to do.");
     process.exit(1);
   }
-  const spinner7 = p7.spinner();
-  spinner7.start(`Scaffolding feature '${featureSlug}'...`);
+  const spinner8 = p7.spinner();
+  spinner8.start(`Scaffolding feature '${featureSlug}'...`);
   try {
     if (provider && selection) {
       await FeatureWorkspace.ensureStructure(featureDir);
@@ -2914,13 +2914,13 @@ async function handleGenerateFeatureAction(name, options) {
       await FeatureWorkspace.ensureStructure(featureDir);
       await generateEmptyFeature(featureSlug, featureDir, templateEngine);
     }
-    spinner7.stop(`Feature '${featureSlug}' created successfully!`);
+    spinner8.stop(`Feature '${featureSlug}' created successfully!`);
     p7.log.success(
       `Scaffolded feature '${featureSlug}'. Remember to register the controller in your router.`
     );
     p7.outro("Feature generation complete!");
   } catch (error) {
-    spinner7.stop("Failed to scaffold the feature.");
+    spinner8.stop("Failed to scaffold the feature.");
     const message = error instanceof Error ? error.message : String(error);
     p7.log.error(`Feature generation failed: ${message}`);
     process.exit(1);
@@ -2929,7 +2929,7 @@ async function handleGenerateFeatureAction(name, options) {
 async function resolveSchemaProvider({
   registry,
   options,
-  cancel: cancel4
+  cancel: cancel5
 }) {
   if (options.schema) {
     const provider2 = registry.findBySchemaOption(options.schema);
@@ -2962,7 +2962,7 @@ async function resolveSchemaProvider({
     initialValue: "none"
   });
   if (p7.isCancel(choice)) {
-    cancel4("Feature generation cancelled.");
+    cancel5("Feature generation cancelled.");
   }
   if (choice === "none") {
     return { provider: null, selection: null };
@@ -3063,13 +3063,13 @@ var OpenAPIGenerator = class _OpenAPIGenerator {
     for (const [controllerKey, controller] of Object.entries(router.controllers)) {
       for (const [actionKey, action] of Object.entries(controller.actions)) {
         const actionName = action.name || actionKey;
-        let path24 = `/${controller.path}/${action.path}`;
-        path24 = path24.replace(/\/{2,}/g, "/");
-        if (path24.length > 1 && path24.endsWith("/")) {
-          path24 = path24.slice(0, -1);
+        let path25 = `/${controller.path}/${action.path}`;
+        path25 = path25.replace(/\/{2,}/g, "/");
+        if (path25.length > 1 && path25.endsWith("/")) {
+          path25 = path25.slice(0, -1);
         }
-        if (!paths[path24]) {
-          paths[path24] = {};
+        if (!paths[path25]) {
+          paths[path25] = {};
         }
         const operation = {
           summary: action.description || actionName,
@@ -3131,7 +3131,7 @@ var OpenAPIGenerator = class _OpenAPIGenerator {
         if (action.isStream) {
           operation.description = (operation.description ? operation.description + "\n\n" : "") + "This endpoint supports Server-Sent Events (SSE) for real-time updates. It functions as a standard GET request initially, then maintains an open connection for streaming data.";
         }
-        paths[path24][action.method.toLowerCase()] = operation;
+        paths[path25][action.method.toLowerCase()] = operation;
       }
     }
     return paths;
@@ -3307,10 +3307,10 @@ async function generateDocsWatchMode(routerPath, outputDir) {
 async function handleGenerateDocsAction(options) {
   try {
     p9.intro("Generate OpenAPI documentation");
-    const spinner7 = p9.spinner();
-    spinner7.start("Generating OpenAPI documentation...");
+    const spinner8 = p9.spinner();
+    spinner8.start("Generating OpenAPI documentation...");
     const result = await generateDocsWatchMode(options.router, options.output);
-    spinner7.stop("OpenAPI documentation generated successfully.");
+    spinner8.stop("OpenAPI documentation generated successfully.");
     p9.log.success(
       `Docs generated in ${(result.durationMs / 1e3).toFixed(2)}s (${result.sizeKb.toFixed(1)} KB)`
     );
@@ -3354,10 +3354,10 @@ async function generateSchemaWatchMode(routerPath, outputPath) {
 async function handleGenerateSchemaAction({ router: routerPath, output: outputPath }) {
   try {
     p10.intro("Generate Igniter.js Client Schema");
-    const spinner7 = p10.spinner();
-    spinner7.start("Generating schema...");
+    const spinner8 = p10.spinner();
+    spinner8.start("Generating schema...");
     const result = await generateSchemaWatchMode(routerPath, outputPath);
-    spinner7.stop("Schema generated successfully.");
+    spinner8.stop("Schema generated successfully.");
     p10.log.success(
       `Schema generated in ${(result.durationMs / 1e3).toFixed(2)}s (${result.controllers} controllers, ${result.actions} actions).`
     );
@@ -3432,8 +3432,8 @@ async function handleGenerateControllerAction(name, options) {
     "feature",
     "empty.controller.hbs"
   );
-  const spinner7 = p11.spinner();
-  spinner7.start(
+  const spinner8 = p11.spinner();
+  spinner8.start(
     `Creating controller '${controllerSlug}' inside feature '${featureSlug}'...`
   );
   try {
@@ -3446,13 +3446,13 @@ async function handleGenerateControllerAction(name, options) {
       },
       controllerPath
     );
-    spinner7.stop("Controller created successfully!");
+    spinner8.stop("Controller created successfully!");
     p11.log.success(
       `Created controller '${controllerSlug}' in feature '${featureSlug}'.`
     );
     p11.outro("Controller generation complete!");
   } catch (error) {
-    spinner7.stop("Failed to create the controller.");
+    spinner8.stop("Failed to create the controller.");
     const message = error instanceof Error ? error.message : String(error);
     p11.log.error(`Controller generation failed: ${message}`);
     process.exit(1);
@@ -3510,8 +3510,8 @@ async function handleGenerateProcedureAction(name, options) {
     "feature",
     "procedure.hbs"
   );
-  const spinner7 = p12.spinner();
-  spinner7.start(
+  const spinner8 = p12.spinner();
+  spinner8.start(
     `Creating procedure '${procedureSlug}' inside feature '${featureSlug}'...`
   );
   if (await FeatureWorkspace.fileExists(path22.join(featureDir, "procedures", ".gitkeep"))) {
@@ -3527,13 +3527,13 @@ async function handleGenerateProcedureAction(name, options) {
       },
       procedurePath
     );
-    spinner7.stop("Procedure created successfully!");
+    spinner8.stop("Procedure created successfully!");
     p12.log.success(
       `Created procedure '${procedureSlug}' in feature '${featureSlug}'.`
     );
     p12.outro("Procedure generation complete!");
   } catch (error) {
-    spinner7.stop("Failed to create the procedure.");
+    spinner8.stop("Failed to create the procedure.");
     const message = error instanceof Error ? error.message : String(error);
     p12.log.error(`Procedure generation failed: ${message}`);
     process.exit(1);
@@ -3543,15 +3543,434 @@ async function handleGenerateProcedureAction(name, options) {
 // src/commands/generate/procedure/index.ts
 var procedureCommand = new Command6().command("procedure").description("Scaffold a new procedure within a feature").argument("[name]", "Name of the procedure (e.g., 'profile')").option("-f, --feature <feature>", "Target feature name").action(handleGenerateProcedureAction);
 
+// src/commands/generate/caller/index.ts
+import { Command as Command7 } from "commander";
+
+// src/commands/generate/caller/action.ts
+import { promises as fs7 } from "fs";
+import path23 from "path";
+import * as p13 from "@clack/prompts";
+import yaml from "js-yaml";
+import SwaggerParser from "@apidevtools/swagger-parser";
+var SUPPORTED_METHODS = ["get", "post", "put", "patch", "delete"];
+async function handleGenerateCallerAction(options) {
+  p13.intro("Generate Igniter Caller");
+  try {
+    const callerName = await resolveCallerName(options.name);
+    const source = await resolveSource(options);
+    const spinner8 = p13.spinner();
+    spinner8.start("Loading OpenAPI spec...");
+    const parsedDoc = await loadOpenApiDocument(source);
+    const host = deriveHostname(source, parsedDoc) || "api";
+    const outputDir = path23.resolve(
+      process.cwd(),
+      options.output ?? path23.join("src", "callers", host)
+    );
+    const prefix = Casing.toPascalCase(callerName);
+    const converter = new SchemaConverter(prefix, parsedDoc.components);
+    const pathsCode = buildSchemasObject(parsedDoc, converter);
+    const componentsCode = converter.renderComponentSchemas();
+    const schemaConstName = `${prefix}Schema`;
+    const schemaTypeName = `${prefix}SchemaType`;
+    const schemaFileContents = [
+      "/* eslint-disable */",
+      "/* prettier-ignore */",
+      "",
+      "/**",
+      " * @generated by @igniter-js/cli",
+      " * This file was automatically created from your OpenAPI spec.",
+      " * Do not edit manually; regenerate via `igniter generate caller`.",
+      " */",
+      "",
+      'import { z } from "zod";',
+      componentsCode,
+      `const schemas = ${pathsCode};`,
+      "",
+      `export const ${schemaConstName} = schemas;`,
+      `export type ${schemaTypeName} = typeof ${schemaConstName};`,
+      ""
+    ].filter(Boolean).join("\n");
+    const baseUrl = inferBaseUrl(source, parsedDoc);
+    const callerVar = `${Casing.toCamelCase(callerName)}Caller`;
+    const callerFileContents = [
+      "/**",
+      ` * Preconfigured IgniterCaller for ${prefix}.`,
+      " * Regenerate via `igniter generate caller` when the OpenAPI spec changes.",
+      " */",
+      'import { IgniterCaller } from "@igniter-js/caller";',
+      `import { ${schemaConstName} } from "./schema";`,
+      "",
+      "export const " + callerVar + " = IgniterCaller.create()",
+      baseUrl ? `  .withBaseUrl("${baseUrl}")` : "",
+      "  .withSchemas(" + schemaConstName + ', { mode: "strict" })',
+      "  .build();",
+      ""
+    ].filter(Boolean).join("\n");
+    await fs7.mkdir(outputDir, { recursive: true });
+    await fs7.writeFile(path23.join(outputDir, "schema.ts"), schemaFileContents, "utf8");
+    await fs7.writeFile(path23.join(outputDir, "index.ts"), callerFileContents, "utf8");
+    spinner8.stop("Caller generated successfully.");
+    p13.log.success(
+      `Schemas and caller created at ${path23.relative(process.cwd(), outputDir)}`
+    );
+    p13.log.info(
+      `Exported caller: ${callerVar} (schemas: ${schemaConstName})`
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    p13.log.error(message);
+    process.exit(1);
+  }
+}
+async function resolveCallerName(name) {
+  if (name) {
+    return name.trim();
+  }
+  const answer = await p13.text({
+    message: "Caller name (e.g., facebook, billing)",
+    validate: (value) => value && value.trim().length > 0 ? void 0 : "Name is required"
+  });
+  if (p13.isCancel(answer)) {
+    p13.cancel("Caller generation cancelled.");
+    process.exit(0);
+  }
+  return String(answer);
+}
+async function resolveSource(options) {
+  if (options.url && options.path) {
+    throw new Error("Use either --url or --path, not both.");
+  }
+  if (options.url) {
+    return { type: "url", url: options.url };
+  }
+  if (options.path) {
+    return { type: "path", path: options.path };
+  }
+  const sourceChoice = await p13.select({
+    message: "Where is your OpenAPI spec?",
+    options: [
+      { label: "Remote URL", value: "url" },
+      { label: "Local file path", value: "path" }
+    ],
+    initialValue: "url"
+  });
+  if (p13.isCancel(sourceChoice)) {
+    p13.cancel("Caller generation cancelled.");
+    process.exit(0);
+  }
+  if (sourceChoice === "url") {
+    const url = await p13.text({
+      message: "OpenAPI URL",
+      placeholder: "https://api.example.com/openapi.json",
+      validate: (value) => !value ? "URL is required" : void 0
+    });
+    if (p13.isCancel(url)) {
+      p13.cancel("Caller generation cancelled.");
+      process.exit(0);
+    }
+    return { type: "url", url: String(url) };
+  }
+  const filePath = await p13.text({
+    message: "Path to OpenAPI file",
+    placeholder: "./openapi.json",
+    validate: (value) => !value ? "Path is required" : void 0
+  });
+  if (p13.isCancel(filePath)) {
+    p13.cancel("Caller generation cancelled.");
+    process.exit(0);
+  }
+  return { type: "path", path: String(filePath) };
+}
+async function loadOpenApiDocument(source) {
+  const raw = await loadRawContent(source);
+  const parsed = parseOpenApi(raw);
+  if (!parsed.openapi || !parsed.openapi.startsWith("3.")) {
+    throw new Error("Only OpenAPI 3.x documents are supported.");
+  }
+  const dereferenced = await SwaggerParser.dereference(
+    parsed
+  );
+  return dereferenced;
+}
+async function loadRawContent(source) {
+  if (source.type === "url") {
+    const response = await fetch(source.url);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch OpenAPI document: ${response.status} ${response.statusText}`
+      );
+    }
+    return await response.text();
+  }
+  const filePath = path23.resolve(process.cwd(), source.path);
+  return await fs7.readFile(filePath, "utf8");
+}
+function parseOpenApi(content) {
+  try {
+    return JSON.parse(content);
+  } catch {
+    const parsed = yaml.load(content);
+    if (!parsed || typeof parsed !== "object") {
+      throw new Error("Could not parse OpenAPI document (JSON/YAML).");
+    }
+    return parsed;
+  }
+}
+function deriveHostname(source, doc) {
+  if (source.type === "url") {
+    try {
+      const url = new URL(source.url);
+      return url.hostname.replace(/[^a-zA-Z0-9.-]/g, "") || null;
+    } catch {
+      return null;
+    }
+  }
+  const serverUrl = doc.servers?.[0]?.url;
+  if (serverUrl) {
+    try {
+      const url = new URL(serverUrl);
+      return url.hostname.replace(/[^a-zA-Z0-9.-]/g, "") || null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function inferBaseUrl(source, doc) {
+  if (source.type === "url") {
+    const serverUrl2 = doc.servers?.[0]?.url;
+    if (serverUrl2) {
+      return serverUrl2;
+    }
+    return new URL(source.url).origin;
+  }
+  const serverUrl = doc.servers?.[0]?.url;
+  return serverUrl ?? null;
+}
+var SchemaConverter = class {
+  constructor(prefix, components) {
+    this.generated = /* @__PURE__ */ new Map();
+    this.inProgress = /* @__PURE__ */ new Set();
+    this.prefix = prefix;
+    this.components = components;
+  }
+  renderComponentSchemas() {
+    const entries = [];
+    const names = Object.keys(this.components?.schemas ?? {}).sort();
+    for (const name of names) {
+      const identifier = this.componentIdentifier(name);
+      const expression = this.convertWithCache(name);
+      entries.push(`const ${identifier} = ${expression};`);
+    }
+    return entries.length ? `${entries.join("\n")}
+` : "";
+  }
+  convert(schema) {
+    if ("$ref" in schema) {
+      const refName = this.refName(schema.$ref);
+      const identifier = this.componentIdentifier(refName);
+      this.convertWithCache(refName);
+      return this.wrapLazyIfNeeded(refName, identifier);
+    }
+    if (schema.oneOf?.length) {
+      const parts = schema.oneOf.map((item) => this.convert(item));
+      return `z.union([${parts.join(", ")}])${schema.nullable ? ".nullable()" : ""}`;
+    }
+    if (schema.anyOf?.length) {
+      const parts = schema.anyOf.map((item) => this.convert(item));
+      return `z.union([${parts.join(", ")}])${schema.nullable ? ".nullable()" : ""}`;
+    }
+    if (schema.allOf?.length) {
+      const [first, ...rest] = schema.allOf;
+      let expr = this.convert(first);
+      for (const part of rest) {
+        expr = `z.intersection(${expr}, ${this.convert(part)})`;
+      }
+      return schema.nullable ? `${expr}.nullable()` : expr;
+    }
+    switch (schema.type) {
+      case "string":
+        if (schema.enum) {
+          const values = schema.enum.map((v) => JSON.stringify(String(v)));
+          return `z.enum([${values.join(", ")}])${schema.nullable ? ".nullable()" : ""}`;
+        }
+        return `z.string()${schema.nullable ? ".nullable()" : ""}`;
+      case "number":
+      case "integer": {
+        let expr = "z.number()";
+        if (schema.type === "integer") {
+          expr = `${expr}.int()`;
+        }
+        if (schema.nullable) {
+          expr = `${expr}.nullable()`;
+        }
+        return expr;
+      }
+      case "boolean":
+        return `z.boolean()${schema.nullable ? ".nullable()" : ""}`;
+      case "array": {
+        const items = schema.items ? this.convert(schema.items) : "z.unknown()";
+        return `z.array(${items})${schema.nullable ? ".nullable()" : ""}`;
+      }
+      case "object": {
+        const properties = schema.properties ?? {};
+        const required = new Set(schema.required ?? []);
+        const entries = Object.entries(properties).map(([key, value]) => {
+          const valueExpr = this.convert(value);
+          return `${JSON.stringify(key)}: ${required.has(key) ? valueExpr : `${valueExpr}.optional()`}`;
+        });
+        let base = `z.object({${entries.length ? ` ${entries.join(", ")} ` : ""}})`;
+        if (schema.additionalProperties) {
+          const apValue = schema.additionalProperties === true ? "z.unknown()" : this.convert(schema.additionalProperties);
+          base = `${base}.catchall(${apValue})`;
+        }
+        if (schema.nullable) {
+          base = `${base}.nullable()`;
+        }
+        return base;
+      }
+      default:
+        return "z.unknown()";
+    }
+  }
+  convertWithCache(name) {
+    const identifier = this.componentIdentifier(name);
+    if (this.generated.has(name)) {
+      return this.generated.get(name);
+    }
+    if (this.inProgress.has(name)) {
+      return `z.lazy(() => ${identifier})`;
+    }
+    const schema = this.components?.schemas?.[name];
+    if (!schema) {
+      return "z.unknown()";
+    }
+    this.inProgress.add(name);
+    const expression = this.convert(schema);
+    this.inProgress.delete(name);
+    const finalized = expression.startsWith("z.lazy(") ? expression : expression;
+    this.generated.set(name, finalized);
+    return finalized;
+  }
+  componentIdentifier(name) {
+    return `${this.prefix}${Casing.toPascalCase(name)}Schema`;
+  }
+  refName(ref) {
+    const [, component] = ref.split("#/components/schemas/");
+    if (!component) {
+      return "UnknownSchema";
+    }
+    return component;
+  }
+  wrapLazyIfNeeded(name, identifier) {
+    if (this.inProgress.has(name)) {
+      return `z.lazy(() => ${identifier})`;
+    }
+    return identifier;
+  }
+};
+function buildSchemasObject(doc, converter) {
+  const pathEntries = [];
+  const sortedPaths = Object.keys(doc.paths || {}).sort();
+  for (const rawPath of sortedPaths) {
+    const pathItem = doc.paths?.[rawPath];
+    if (!pathItem) continue;
+    const methodEntries = [];
+    for (const method of SUPPORTED_METHODS) {
+      const operation = pathItem[method];
+      if (!operation) continue;
+      const responses = buildResponses(operation.responses, converter);
+      const requestBody = buildRequestBody(operation.requestBody, converter);
+      const segments = [];
+      if (requestBody) {
+        segments.push(`request: ${requestBody}`);
+      }
+      segments.push(`responses: ${responses}`);
+      const methodBlock = [
+        `${method.toUpperCase()}: {`,
+        indentLines(segments.join(",\n"), 2),
+        "}"
+      ].join("\n");
+      methodEntries.push(indentLines(methodBlock, 2));
+    }
+    if (!methodEntries.length) continue;
+    const normalizedPath = normalizePath(rawPath);
+    const pathBlock = [
+      `${JSON.stringify(normalizedPath)}: {`,
+      methodEntries.join(",\n"),
+      "}"
+    ].join("\n");
+    pathEntries.push(indentLines(pathBlock, 1));
+  }
+  return `{
+${pathEntries.join(",\n")}
+}`;
+}
+function buildResponses(responses, converter) {
+  if (!responses || !Object.keys(responses).length) {
+    return "{ }";
+  }
+  const entries = [];
+  const sorted = Object.keys(responses).sort();
+  for (const status of sorted) {
+    const responseOrRef = responses[status];
+    if (!responseOrRef) continue;
+    const response = "$ref" in responseOrRef ? void 0 : responseOrRef;
+    const schema = resolveSchemaFromResponse(response);
+    const expression = schema ? converter.convert(schema) : "z.unknown()";
+    entries.push(`${status}: ${expression}`);
+  }
+  if (!entries.length) {
+    return "{ }";
+  }
+  return `{
+${indentLines(entries.join(",\n"), 2)}
+  }`;
+}
+function buildRequestBody(requestBody, converter) {
+  if (!requestBody) return null;
+  const resolved = "$ref" in requestBody ? null : requestBody;
+  if (!resolved?.content) return null;
+  const schema = selectJsonSchema(resolved.content);
+  if (!schema) return null;
+  return converter.convert(schema);
+}
+function selectJsonSchema(content) {
+  if (content["application/json"]?.schema) {
+    return content["application/json"].schema;
+  }
+  const first = Object.values(content)[0];
+  return first?.schema;
+}
+function resolveSchemaFromResponse(response) {
+  if (!response?.content) {
+    return void 0;
+  }
+  return selectJsonSchema(response.content);
+}
+function normalizePath(pathname) {
+  return pathname.replace(/{(.*?)}/g, ":$1");
+}
+function indentLines(value, depth) {
+  const pad = "  ".repeat(depth);
+  return value.split("\n").map((line) => line ? pad + line : line).join("\n");
+}
+
+// src/commands/generate/caller/index.ts
+var callerCommand = new Command7().command("caller").description("Generate Igniter Caller schemas from an OpenAPI spec").option("--name <name>", "Name used to prefix generated schemas and caller export").option("--url <url>", "URL to the OpenAPI document").option("--path <path>", "Local path to the OpenAPI document").option(
+  "--output <path>",
+  "Output directory (defaults to src/callers/<hostname>)"
+).action(handleGenerateCallerAction);
+
 // src/commands/generate/index.ts
-var generateCommand = new Command7().command("generate").description("Scaffold new features or generate client schema").addCommand(featureCommand).addCommand(controllerCommand).addCommand(procedureCommand).addCommand(docsCommand).addCommand(schemaCommand);
+var generateCommand = new Command8().command("generate").description("Scaffold new features or generate client schema").addCommand(featureCommand).addCommand(controllerCommand).addCommand(procedureCommand).addCommand(docsCommand).addCommand(schemaCommand).addCommand(callerCommand);
 
 // src/commands/dev/index.ts
-import { Command as Command8 } from "commander";
+import { Command as Command9 } from "commander";
 
 // src/commands/dev/action.ts
-import * as path23 from "path";
-import * as fs7 from "fs";
+import * as path24 from "path";
+import * as fs8 from "fs";
 import { spawn as spawn2 } from "child_process";
 import chokidar from "chokidar";
 import { render } from "ink";
@@ -3586,14 +4005,14 @@ function DevUI({ igniterLogs, appLogs, onExit }) {
   };
   const renderLogs = (logs, maxLines = 50) => {
     const visibleLogs = logs.slice(-maxLines);
-    return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, visibleLogs.length === 0 ? /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "No logs yet...") : visibleLogs.map((log11, index) => {
+    return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, visibleLogs.length === 0 ? /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "No logs yet...") : visibleLogs.map((log12, index) => {
       const color2 = {
         info: "cyan",
         success: "green",
         error: "red",
         warn: "yellow"
-      }[log11.type];
-      return /* @__PURE__ */ React.createElement(Text, { key: `${log11.timestamp.getTime()}-${index}`, color: color2 }, formatLogEntry(log11));
+      }[log12.type];
+      return /* @__PURE__ */ React.createElement(Text, { key: `${log12.timestamp.getTime()}-${index}`, color: color2 }, formatLogEntry(log12));
     }));
   };
   return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Box, { marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { bold: true }, "Igniter.js Development Mode")), /* @__PURE__ */ React.createElement(Box, { flexDirection: "row" }, /* @__PURE__ */ React.createElement(
@@ -3655,19 +4074,19 @@ async function regenerateSchemaAndDocs(routerPath, outputPath, docsOutputDir, ad
 }
 async function handleDevAction(options) {
   const packageManager = detectPackageManager();
-  const routerPath = path23.resolve(process.cwd(), options.router || "src/igniter.router.ts");
+  const routerPath = path24.resolve(process.cwd(), options.router || "src/igniter.router.ts");
   const outputPath = options.output || "src/igniter.schema.ts";
   const docsOutputDir = options.docsOutput || "./src/docs";
   const devCommand2 = options.cmd || getDefaultDevCommand(packageManager);
-  if (!fs7.existsSync(routerPath)) {
+  if (!fs8.existsSync(routerPath)) {
     console.error(`Router file not found: ${routerPath}`);
     process.exit(1);
   }
   const igniterLogs = [];
   const appLogs = [];
   let rerenderFn = null;
-  const addIgniterLog = (log11) => {
-    igniterLogs.push(log11);
+  const addIgniterLog = (log12) => {
+    igniterLogs.push(log12);
     if (igniterLogs.length > 1e3) {
       igniterLogs.shift();
     }
@@ -3675,8 +4094,8 @@ async function handleDevAction(options) {
       rerenderFn();
     }
   };
-  const addAppLog = (log11) => {
-    appLogs.push(log11);
+  const addAppLog = (log12) => {
+    appLogs.push(log12);
     if (appLogs.length > 1e3) {
       appLogs.shift();
     }
@@ -3706,13 +4125,13 @@ async function handleDevAction(options) {
     });
     process.exit(1);
   }
-  const featuresDir = path23.join(process.cwd(), "src", "features");
+  const featuresDir = path24.join(process.cwd(), "src", "features");
   const watchPaths = [
     routerPath,
     // Watch router file directly
     featuresDir
     // Watch features directory recursively
-  ].filter((p13) => fs7.existsSync(p13));
+  ].filter((p14) => fs8.existsSync(p14));
   if (watchPaths.length === 0) {
     addIgniterLog({
       type: "warn",
@@ -3723,7 +4142,7 @@ async function handleDevAction(options) {
   }
   addIgniterLog({
     type: "info",
-    message: `Watching for changes in: ${watchPaths.map((p13) => path23.relative(process.cwd(), p13)).join(", ")}`,
+    message: `Watching for changes in: ${watchPaths.map((p14) => path24.relative(process.cwd(), p14)).join(", ")}`,
     timestamp: /* @__PURE__ */ new Date()
   });
   let regenerateTimeout = null;
@@ -3743,7 +4162,7 @@ async function handleDevAction(options) {
     ignoreInitial: true
   });
   watcher.on("change", (filePath) => {
-    const relativePath = path23.relative(process.cwd(), filePath);
+    const relativePath = path24.relative(process.cwd(), filePath);
     if (regenerateTimeout) {
       clearTimeout(regenerateTimeout);
     }
@@ -3867,10 +4286,10 @@ async function handleDevAction(options) {
 }
 
 // src/commands/dev/index.ts
-var devCommand = new Command8().command("dev").description("Start development mode with automatic schema and docs regeneration").option("--router <path>", "Path to the router file", "src/igniter.router.ts").option("--output <path>", "Output path for the schema file", "src/igniter.schema.ts").option("--docs-output <dir>", "Output directory for the OpenAPI spec", "./src/docs").option("--cmd <command>", "Custom command to start the development server").action(handleDevAction);
+var devCommand = new Command9().command("dev").description("Start development mode with automatic schema and docs regeneration").option("--router <path>", "Path to the router file", "src/igniter.router.ts").option("--output <path>", "Output path for the schema file", "src/igniter.schema.ts").option("--docs-output <dir>", "Output directory for the OpenAPI spec", "./src/docs").option("--cmd <command>", "Custom command to start the development server").action(handleDevAction);
 
 // src/index.ts
-var program = new Command9();
+var program = new Command10();
 program.name("igniter").description("The next-generation command-line interface for Igniter.js").version("0.0.1");
 program.addCommand(initCommand);
 program.addCommand(generateCommand);