@igniter-js/cli 0.2.4 → 0.2.6

package/dist/index.js

@@ -5160,7 +5160,7 @@ var require_Command = __commonJS({
         }
       }
       initPromise() {
-        const promise = new Promise((resolve4, reject) => {
+        const promise = new Promise((resolve5, reject) => {
           if (!this.transformed) {
             this.transformed = true;
             const transformer = _Command._transformer.argument[this.name];
@@ -5169,7 +5169,7 @@ var require_Command = __commonJS({
             }
             this.stringifyArguments();
           }
-          this.resolve = this._convertValue(resolve4);
+          this.resolve = this._convertValue(resolve5);
           if (this.errorStack) {
             this.reject = (err) => {
               reject((0, utils_1.optimizeErrorStack)(err, this.errorStack.stack, __dirname));
@@ -5199,7 +5199,7 @@ var require_Command = __commonJS({
       /**
        * Convert the value from buffer to the target encoding.
        */
-      _convertValue(resolve4) {
+      _convertValue(resolve5) {
         return (value) => {
           try {
             const existingTimer = this._commandTimeoutTimer;
@@ -5207,7 +5207,7 @@ var require_Command = __commonJS({
               clearTimeout(existingTimer);
               delete this._commandTimeoutTimer;
             }
-            resolve4(this.transformReply(value));
+            resolve5(this.transformReply(value));
             this.isResolved = true;
           } catch (err) {
             this.reject(err);
@@ -5462,13 +5462,13 @@ var require_autoPipelining = __commonJS({
       if (client.isCluster && !client.slots.length) {
         if (client.status === "wait")
           client.connect().catch(lodash_1.noop);
-        return (0, standard_as_callback_1.default)(new Promise(function(resolve4, reject) {
+        return (0, standard_as_callback_1.default)(new Promise(function(resolve5, reject) {
           client.delayUntilReady((err) => {
             if (err) {
               reject(err);
               return;
             }
-            executeWithAutoPipelining(client, functionName, commandName, args, null).then(resolve4, reject);
+            executeWithAutoPipelining(client, functionName, commandName, args, null).then(resolve5, reject);
           });
         }), callback);
       }
@@ -5485,13 +5485,13 @@ var require_autoPipelining = __commonJS({
         pipeline[exports2.kExec] = true;
         setImmediate(executeAutoPipeline, client, slotKey);
       }
-      const autoPipelinePromise = new Promise(function(resolve4, reject) {
+      const autoPipelinePromise = new Promise(function(resolve5, reject) {
         pipeline[exports2.kCallbacks].push(function(err, value) {
           if (err) {
             reject(err);
             return;
           }
-          resolve4(value);
+          resolve5(value);
         });
         if (functionName === "call") {
           args.unshift(commandName);
@@ -5729,8 +5729,8 @@ var require_Pipeline = __commonJS({
           this[name] = redis[name];
           this[name + "Buffer"] = redis[name + "Buffer"];
         });
-        this.promise = new Promise((resolve4, reject) => {
-          this.resolve = resolve4;
+        this.promise = new Promise((resolve5, reject) => {
+          this.resolve = resolve5;
           this.reject = reject;
         });
         const _this = this;
@@ -6025,13 +6025,13 @@ var require_transaction = __commonJS({
           if (this.isCluster && !this.redis.slots.length) {
             if (this.redis.status === "wait")
               this.redis.connect().catch(utils_1.noop);
-            return (0, standard_as_callback_1.default)(new Promise((resolve4, reject) => {
+            return (0, standard_as_callback_1.default)(new Promise((resolve5, reject) => {
               this.redis.delayUntilReady((err) => {
                 if (err) {
                   reject(err);
                   return;
                 }
-                this.exec(pipeline).then(resolve4, reject);
+                this.exec(pipeline).then(resolve5, reject);
               });
             }), callback);
           }
@@ -7207,7 +7207,7 @@ var require_cluster = __commonJS({
        * Connect to a cluster
        */
       connect() {
-        return new Promise((resolve4, reject) => {
+        return new Promise((resolve5, reject) => {
           if (this.status === "connecting" || this.status === "connect" || this.status === "ready") {
             reject(new Error("Redis is already connecting/connected"));
             return;
@@ -7231,7 +7231,7 @@ var require_cluster = __commonJS({
               this.retryAttempts = 0;
               this.executeOfflineCommands();
               this.resetNodesRefreshInterval();
-              resolve4();
+              resolve5();
             };
             let closeListener = void 0;
             const refreshListener = () => {
@@ -7824,7 +7824,7 @@ var require_cluster = __commonJS({
         });
       }
       resolveSrv(hostname) {
-        return new Promise((resolve4, reject) => {
+        return new Promise((resolve5, reject) => {
           this.options.resolveSrv(hostname, (err, records) => {
             if (err) {
               return reject(err);
@@ -7838,7 +7838,7 @@ var require_cluster = __commonJS({
               if (!group.records.length) {
                 sortedKeys.shift();
               }
-              self.dnsLookup(record.name).then((host) => resolve4({
+              self.dnsLookup(record.name).then((host) => resolve5({
                 host,
                 port: record.port
               }), tryFirstOne);
@@ -7848,14 +7848,14 @@ var require_cluster = __commonJS({
         });
       }
       dnsLookup(hostname) {
-        return new Promise((resolve4, reject) => {
+        return new Promise((resolve5, reject) => {
           this.options.dnsLookup(hostname, (err, address) => {
             if (err) {
               debug("failed to resolve hostname %s to IP: %s", hostname, err.message);
               reject(err);
             } else {
               debug("resolved hostname %s to IP %s", hostname, address);
-              resolve4(address);
+              resolve5(address);
             }
           });
         });
@@ -7973,7 +7973,7 @@ var require_StandaloneConnector = __commonJS({
         if (options.tls) {
           Object.assign(connectionOptions, options.tls);
         }
-        return new Promise((resolve4, reject) => {
+        return new Promise((resolve5, reject) => {
           process.nextTick(() => {
             if (!this.connecting) {
               reject(new Error(utils_1.CONNECTION_CLOSED_ERROR_MSG));
@@ -7992,7 +7992,7 @@ var require_StandaloneConnector = __commonJS({
             this.stream.once("error", (err) => {
               this.firstError = err;
             });
-            resolve4(this.stream);
+            resolve5(this.stream);
           });
         });
       }
@@ -8151,7 +8151,7 @@ var require_SentinelConnector = __commonJS({
             const error = new Error(errorMsg);
             if (typeof retryDelay === "number") {
               eventEmitter("error", error);
-              await new Promise((resolve4) => setTimeout(resolve4, retryDelay));
+              await new Promise((resolve5) => setTimeout(resolve5, retryDelay));
               return connectToNext();
             } else {
               throw error;
@@ -9457,7 +9457,7 @@ var require_Redis = __commonJS({
        * be resolved when the connection status is ready.
        */
       connect(callback) {
-        const promise = new Promise((resolve4, reject) => {
+        const promise = new Promise((resolve5, reject) => {
           if (this.status === "connecting" || this.status === "connect" || this.status === "ready") {
             reject(new Error("Redis is already connecting/connected"));
             return;
@@ -9536,7 +9536,7 @@ var require_Redis = __commonJS({
             }
             const connectionReadyHandler = function() {
               _this.removeListener("close", connectionCloseHandler);
-              resolve4();
+              resolve5();
             };
             var connectionCloseHandler = function() {
               _this.removeListener("ready", connectionReadyHandler);
@@ -9630,10 +9630,10 @@ var require_Redis = __commonJS({
           monitor: true,
           lazyConnect: false
         });
-        return (0, standard_as_callback_1.default)(new Promise(function(resolve4, reject) {
+        return (0, standard_as_callback_1.default)(new Promise(function(resolve5, reject) {
           monitorInstance.once("error", reject);
           monitorInstance.once("monitoring", function() {
-            resolve4(monitorInstance);
+            resolve5(monitorInstance);
           });
         }), callback);
       }
@@ -11415,8 +11415,8 @@ ${ANSI_COLORS.bold}TOP OPERATIONS${ANSI_COLORS.reset}`);
         }, 5e3);
         this.startApiMonitoring();
         await Promise.all(
-          this.processes.map((proc) => new Promise((resolve4) => {
-            proc.on("exit", resolve4);
+          this.processes.map((proc) => new Promise((resolve5) => {
+            proc.on("exit", resolve5);
           }))
         );
       }
@@ -11446,61 +11446,258 @@ ${ANSI_COLORS.bold}TOP OPERATIONS${ANSI_COLORS.reset}`);
   }
 });
 
-// src/adapters/build/generator.ts
-function getFileSize(filePath) {
-  try {
-    const stats = fs6.statSync(filePath);
-    const bytes = stats.size;
-    if (bytes < 1024) return `${bytes}b`;
-    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}kb`;
-    return `${(bytes / (1024 * 1024)).toFixed(1)}mb`;
-  } catch {
-    return "0b";
-  }
-}
-function extractRouterSchema(router) {
-  const controllersSchema = {};
+// src/adapters/build/introspector.ts
+var introspector_exports = {};
+__export(introspector_exports, {
+  introspectRouter: () => introspectRouter,
+  loadRouter: () => loadRouter
+});
+function introspectRouter(router) {
+  const logger6 = createChildLogger({ component: "router-introspector" });
+  logger6.debug("Starting router introspection");
+  const introspectedControllers = {};
   let totalActions = 0;
   for (const [controllerName, controller] of Object.entries(router.controllers)) {
-    const actionsSchema = {};
+    logger6.debug(`Introspecting controller: ${controllerName}`);
+    const introspectedActions = {};
     if (controller && controller.actions) {
       for (const [actionName, action] of Object.entries(controller.actions)) {
-        actionsSchema[actionName] = {
+        logger6.debug(`Introspecting action: ${controllerName}.${actionName}`, { path: action?.path, method: action?.method });
+        const bodySchemaOutput = action.bodySchema !== void 0 ? action.bodySchema : void 0;
+        const querySchemaOutput = action.querySchema !== void 0 ? action.querySchema : void 0;
+        introspectedActions[actionName] = {
           name: action?.name || actionName,
           description: action?.description || "",
           path: action?.path || "",
-          method: action?.method || "GET"
+          method: action?.method || "GET",
+          isStream: action?.stream || false,
+          ...bodySchemaOutput !== void 0 ? { bodySchema: bodySchemaOutput } : {},
+          ...querySchemaOutput !== void 0 ? { querySchema: querySchemaOutput } : {}
         };
         totalActions++;
       }
+    } else {
+      logger6.debug(`Controller ${controllerName} has no actions property or is invalid.`);
     }
-    controllersSchema[controllerName] = {
+    introspectedControllers[controllerName] = {
       name: controller?.name || controllerName,
       description: controller?.description || "",
       path: controller?.path || "",
-      actions: actionsSchema
+      actions: introspectedActions
     };
   }
-  const schema = {
-    config: {
-      baseURL: router.config?.baseURL || "",
-      basePATH: router.config?.basePATH || ""
-    },
-    controllers: controllersSchema,
-    processor: {},
-    handler: {},
-    $context: {},
-    $plugins: {},
-    $caller: {}
+  const schemaResult = {
+    controllers: introspectedControllers,
+    docs: router?.config?.docs
   };
   return {
-    schema,
+    schema: schemaResult,
     stats: {
-      controllers: Object.keys(controllersSchema).length,
+      controllers: Object.keys(introspectedControllers).length,
       actions: totalActions
     }
   };
 }
+async function loadRouter(routerPath) {
+  const logger6 = createChildLogger({ component: "router-loader" });
+  const fullPath = path7.resolve(process.cwd(), routerPath);
+  logger6.debug("Loading router", { path: routerPath });
+  try {
+    const module2 = await loadWithTypeScriptSupport(fullPath);
+    if (module2) {
+      if (module2?.config && module2?.controllers) {
+        return module2;
+      }
+      const router = module2?.AppRouter || module2?.default?.AppRouter || module2?.default || module2?.router;
+      if (router && typeof router === "object") {
+        return router;
+      } else {
+        logger6.debug("Module loaded but no router found", {
+          exports: Object.keys(module2 || {})
+        });
+      }
+    }
+    const fallbackSpinner = createDetachedSpinner("Trying fallback loading method...");
+    fallbackSpinner.start();
+    const fallbackModule = await loadRouterWithIndexResolution(fullPath);
+    if (fallbackModule) {
+      if (fallbackModule?.config && fallbackModule?.controllers) {
+        fallbackSpinner.success(`Router loaded successfully - ${Object.keys(fallbackModule.controllers).length} controllers`);
+        return fallbackModule;
+      }
+      const router = fallbackModule?.AppRouter || fallbackModule?.default?.AppRouter || fallbackModule?.default || fallbackModule?.router;
+      if (router && typeof router === "object") {
+        fallbackSpinner.success(`Router loaded successfully - ${Object.keys(router.controllers).length} controllers`);
+        return router;
+      }
+    }
+    fallbackSpinner.error("Could not load router");
+  } catch (error) {
+    logger6.error("Failed to load router", { path: routerPath }, error);
+  }
+  return null;
+}
+async function loadWithTypeScriptSupport(filePath) {
+  const logger6 = createChildLogger({ component: "tsx-loader" });
+  const jsPath = filePath.replace(/\.ts$/, ".js");
+  if (fs6.existsSync(jsPath)) {
+    try {
+      logger6.debug("Using compiled JS version");
+      delete require.cache[jsPath];
+      return require(jsPath);
+    } catch (error) {
+      logger6.debug("Compiled JS loading failed, trying TypeScript...");
+    }
+  }
+  if (filePath.endsWith(".ts")) {
+    try {
+      logger6.debug("Using TSX runtime loader");
+      const { spawn: spawn2 } = require("child_process");
+      const tsxCheckResult = await new Promise((resolve5) => {
+        const checkChild = spawn2("npx", ["tsx", "--version"], {
+          stdio: "pipe",
+          cwd: process.cwd()
+        });
+        checkChild.on("close", (code) => resolve5(code === 0));
+        checkChild.on("error", () => resolve5(false));
+        setTimeout(() => {
+          checkChild.kill();
+          resolve5(false);
+        }, 5e3);
+      });
+      if (!tsxCheckResult) {
+        throw new Error("TSX not available");
+      }
+      return await new Promise((resolve5, reject) => {
+        const tsxScript = `
+          import { zodToJsonSchema } from 'zod-to-json-schema'; // Precisamos importar isso no script filho
+
+          async function loadRouter() {
+            try {
+              const module = await import('${(0, import_url.pathToFileURL)(filePath).href}');
+              const router = module?.AppRouter || module?.default?.AppRouter || module?.default || module?.router;
+
+              if (router && typeof router === 'object') {
+                const safeRouter = {
+                  config: {
+                    baseURL: router.config?.baseURL || '',
+                    basePATH: router.config?.basePATH || '',
+                    docs: router.config?.docs || undefined,
+                  },
+                  controllers: {}
+                };
+
+                if (router.controllers && typeof router.controllers === 'object') {
+                  for (const [controllerName, controller] of Object.entries(router.controllers)) {
+                    if (controller && typeof controller === 'object' && (controller as any).actions) {
+                      const safeActions = {};
+                      for (const [actionName, action] of Object.entries((controller as any).actions)) {
+                        if (action && typeof action === 'object') {
+                          // MODIFICA\xC7\xC3O PRINCIPAL AQUI
+                          safeActions[actionName] = {
+                            name: (action as any).name,
+                            path: (action as any).path,
+                            method: (action as any).method,
+                            description: (action as any).description,
+                            // Convertemos o schema Zod para JSON Schema AQUI, antes do JSON.stringify
+                            bodySchema: (action as any).body ? zodToJsonSchema((action as any).body, { target: 'openApi3' }) : undefined,
+                            querySchema: (action as any).query ? zodToJsonSchema((action as any).query, { target: 'openApi3' }) : undefined,
+                            use: (action as any).use,
+                            stream: (action as any).stream,
+                          };
+                        }
+                      }
+                      safeRouter.controllers[controllerName] = {
+                        name: (controller as any).name || controllerName,
+                        path: (controller as any).path || '',
+                        description: (controller as any).description,
+                        actions: safeActions,
+                      };
+                    }
+                  }
+                }
+                console.log('__ROUTER_SUCCESS__' + JSON.stringify(safeRouter));
+                process.exit(0);
+              } else {
+                console.log('__ROUTER_ERROR__No router found in module');
+                process.exit(1);
+              }
+            } catch (error) {
+              console.log('__ROUTER_ERROR__' + error.message);
+              process.exit(1);
+            }
+          }
+          loadRouter();
+        `;
+        const child = spawn2("npx", ["tsx", "-e", tsxScript], {
+          stdio: "pipe",
+          cwd: process.cwd(),
+          env: { ...process.env, NODE_NO_WARNINGS: "1" }
+        });
+        let output = "";
+        let errorOutput = "";
+        child.stdout?.on("data", (data) => output += data.toString());
+        child.stderr?.on("data", (data) => errorOutput += data.toString());
+        child.on("close", (code) => {
+          if (output.includes("__ROUTER_SUCCESS__")) {
+            const resultLine = output.split("\n").find((line) => line.includes("__ROUTER_SUCCESS__"));
+            if (resultLine) {
+              try {
+                const routerData = JSON.parse(resultLine.replace("__ROUTER_SUCCESS__", ""));
+                resolve5(routerData);
+              } catch (e) {
+                reject(new Error("Failed to parse router data: " + e.message));
+              }
+            } else {
+              reject(new Error("Router success marker found but no data"));
+            }
+          } else if (output.includes("__ROUTER_ERROR__")) {
+            const errorLine = output.split("\n").find((line) => line.includes("__ROUTER_ERROR__"));
+            const errorMsg = errorLine ? errorLine.replace("__ROUTER_ERROR__", "") : "Unknown error";
+            reject(new Error("Router loading failed: " + errorMsg));
+          } else {
+            reject(new Error(`TSX execution failed with code ${code}: ${errorOutput || "No output"}`));
+          }
+        });
+        child.on("error", (error) => reject(new Error("Failed to spawn TSX process: " + error.message)));
+        setTimeout(() => {
+          child.kill();
+          reject(new Error("Timeout loading TypeScript file with TSX"));
+        }, 3e4);
+      });
+    } catch (error) {
+      logger6.debug("TSX runtime loader failed", {}, error);
+    }
+  }
+  return null;
+}
+async function loadRouterWithIndexResolution(routerPath) {
+  return null;
+}
+var fs6, path7, import_url;
+var init_introspector = __esm({
+  "src/adapters/build/introspector.ts"() {
+    "use strict";
+    fs6 = __toESM(require("fs"));
+    path7 = __toESM(require("path"));
+    import_url = require("url");
+    init_logger();
+    init_spinner();
+  }
+});
+
+// src/adapters/build/generator.ts
+function getFileSize(filePath) {
+  try {
+    const stats = fs7.statSync(filePath);
+    const bytes = stats.size;
+    if (bytes < 1024) return `${bytes}b`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}kb`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)}mb`;
+  } catch {
+    return "0b";
+  }
+}
 async function generateSchemaFromRouter(router, config) {
   const logger6 = createChildLogger({ component: "generator" });
   const startTime = performance.now();
@@ -11513,7 +11710,7 @@ async function generateSchemaFromRouter(router, config) {
       extractSpinner = createDetachedSpinner("Extracting router schema...");
       extractSpinner.start();
     }
-    const { schema, stats } = extractRouterSchema(router);
+    const { schema, stats } = introspectRouter(router);
     if (isInteractiveMode2) {
       logger6.success(`Schema extracted - ${stats.controllers} controllers, ${stats.actions} actions`);
     } else if (extractSpinner) {
@@ -11528,7 +11725,7 @@ async function generateSchemaFromRouter(router, config) {
     }
     const outputDir = config.outputDir || "generated";
     await ensureDirectoryExists(outputDir);
-    const outputPath = path7.resolve(outputDir);
+    const outputPath = path8.resolve(outputDir);
     if (isInteractiveMode2) {
       logger6.success(`Output directory ready ${outputPath}`);
     } else if (dirSpinner) {
@@ -11558,8 +11755,8 @@ async function generateSchemaFromRouter(router, config) {
       let totalSize = 0;
       files.forEach((file) => {
         const size = getFileSize(file.path);
-        totalSize += fs6.statSync(file.path).size;
-        logger6.info(`Generated ${file.name}`, { size, path: path7.relative(process.cwd(), file.path) });
+        totalSize += fs7.statSync(file.path).size;
+        logger6.info(`Generated ${file.name}`, { size, path: path8.relative(process.cwd(), file.path) });
       });
       const duration = ((performance.now() - startTime) / 1e3).toFixed(2);
       const totalSizeFormatted = totalSize < 1024 ? `${totalSize}b` : totalSize < 1024 * 1024 ? `${(totalSize / 1024).toFixed(1)}kb` : `${(totalSize / (1024 * 1024)).toFixed(1)}mb`;
@@ -11592,33 +11789,45 @@ export const AppRouterSchema = ${JSON.stringify(schema, null, 2)} as const
 
 export type AppRouterSchemaType = typeof AppRouterSchema
 `;
-  const filePath = path7.join(outputDir, "igniter.schema.ts");
+  const filePath = path8.join(outputDir, "igniter.schema.ts");
   await writeFileWithHeader(filePath, content, config);
   return filePath;
 }
 async function generateClientFile(schema, outputDir, config) {
-  const content = `import { createIgniterClient, useIgniterQueryClient } from '@igniter-js/core/client'
+  const filePath = path8.join(outputDir, "igniter.client.ts");
+  if (fs7.existsSync(filePath)) {
+    const logger6 = createChildLogger({ component: "generator" });
+    logger6.info("Skipping client file generation, already exists", { path: filePath });
+    return filePath;
+  }
+  const content = `* eslint-disable */
+/* prettier-ignore */
+
+import { createIgniterClient, useIgniterQueryClient } from '@igniter-js/core/client'
 import type { AppRouterType } from './igniter.router'
 
 /**
-  * Type-safe API client generated from your Igniter router
-  *
-  * Usage in Server Components:
-  * const users = await api.users.list.query()
-  *
-  * Usage in Client Components:
-  * const { data } = api.users.list.useQuery()
-  */
+* Type-safe API client generated from your Igniter router
+*
+* Usage in Server Components:
+* const users = await api.users.list.query()
+*
+* Usage in Client Components:
+* const { data } = api.users.list.useQuery()
+*
+* Note: Adjust environment variable prefixes (e.g., NEXT_PUBLIC_, BUN_PUBLIC_, DENO_PUBLIC_, REACT_APP_)
+*       according to your project's framework/runtime (Next.js, Bun, Deno, React/Vite, etc.).
+*/
 export const api = createIgniterClient<AppRouterType>({
-  baseURL: 'http://localhost:3000',
-  basePath: '/api/v1/',
-  router: () => {
-    if (typeof window === 'undefined') {
-      return require('./igniter.router').AppRouter
-    }
+baseURL: process.env.NEXT_PUBLIC_IGNITER_API_URL, // Adapt for your needs
+basePath: process.env.NEXT_PUBLIC_IGNITER_API_BASE_PATH,
+router: () => {
+  if (typeof window === 'undefined') {
+    return require('./igniter.router').AppRouter
+  }
 
-    return require('./igniter.schema').AppRouterSchema
-  },
+  return require('./igniter.schema').AppRouterSchema
+},
 })
 
 /**
@@ -11640,18 +11849,18 @@ export type ApiClient = typeof api
   */
 export const useQueryClient = useIgniterQueryClient<AppRouterType>;
 `;
-  const filePath = path7.join(outputDir, "igniter.client.ts");
   await writeFileWithHeader(filePath, content, config);
   return filePath;
 }
 async function writeFileWithHeader(filePath, content, config) {
   const header = generateFileHeader(config);
   const fullContent = header + "\n\n" + content;
-  await fs6.promises.writeFile(filePath, fullContent, "utf8");
+  await fs7.promises.writeFile(filePath, fullContent, "utf8");
 }
 function generateFileHeader(config) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  return `/* eslint-disable @typescript-eslint/no-var-requires */
+  return `/* eslint-disable */
+/* prettier-ignore */
 
 /**
  * Generated by @igniter-js/cli
@@ -11670,19 +11879,146 @@ function generateFileHeader(config) {
 }
 async function ensureDirectoryExists(dirPath) {
   try {
-    await fs6.promises.access(dirPath);
+    await fs7.promises.access(dirPath);
   } catch (error) {
-    await fs6.promises.mkdir(dirPath, { recursive: true });
+    await fs7.promises.mkdir(dirPath, { recursive: true });
   }
 }
-var fs6, path7;
+var fs7, path8;
 var init_generator = __esm({
   "src/adapters/build/generator.ts"() {
     "use strict";
-    fs6 = __toESM(require("fs"));
-    path7 = __toESM(require("path"));
+    fs7 = __toESM(require("fs"));
+    path8 = __toESM(require("path"));
     init_logger();
     init_spinner();
+    init_introspector();
+  }
+});
+
+// src/adapters/docs/openapi-generator.ts
+var openapi_generator_exports = {};
+__export(openapi_generator_exports, {
+  OpenAPIGenerator: () => OpenAPIGenerator
+});
+function toPascalCase2(str) {
+  if (!str) return "";
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+var OpenAPIGenerator;
+var init_openapi_generator = __esm({
+  "src/adapters/docs/openapi-generator.ts"() {
+    "use strict";
+    OpenAPIGenerator = class {
+      constructor(config) {
+        this.schemas = {};
+        this.docsConfig = config || {};
+      }
+      generate(router) {
+        const servers = this.docsConfig.servers && this.docsConfig.servers.length > 0 ? this.docsConfig.servers : [{ url: "http://localhost:3000/api/v1", description: "Default server" }];
+        const spec = {
+          openapi: "3.0.0",
+          info: this.docsConfig.info || { title: "Igniter API", version: "1.0.0" },
+          servers,
+          tags: this.buildTags(router),
+          paths: this.buildPaths(router),
+          components: {
+            schemas: this.schemas,
+            securitySchemes: this.docsConfig.securitySchemes || {}
+          }
+        };
+        return spec;
+      }
+      buildTags(router) {
+        const tags = [];
+        for (const [controllerKey, controller] of Object.entries(router.controllers)) {
+          const tag = {
+            name: controller.name || controllerKey,
+            description: controller.description
+          };
+          tags.push(tag);
+        }
+        return tags;
+      }
+      buildPaths(router) {
+        const paths = {};
+        for (const [controllerKey, controller] of Object.entries(router.controllers)) {
+          for (const [actionKey, action] of Object.entries(controller.actions)) {
+            const actionName = action.name || actionKey;
+            let path11 = `/${controller.path}/${action.path}`;
+            path11 = path11.replace(/\/{2,}/g, "/");
+            if (path11.length > 1 && path11.endsWith("/")) {
+              path11 = path11.slice(0, -1);
+            }
+            if (!paths[path11]) {
+              paths[path11] = {};
+            }
+            const operation = {
+              summary: action.description || actionName,
+              operationId: actionName,
+              tags: [controller.name || controllerKey],
+              parameters: [],
+              requestBody: void 0,
+              responses: {
+                "200": {
+                  description: "Success",
+                  content: {
+                    "application/json": {
+                      schema: {}
+                    }
+                  }
+                }
+              }
+            };
+            const pathParams = action.path.match(/:([a-zA-Z0-9_]+)/g);
+            if (pathParams) {
+              for (const param of pathParams) {
+                const paramName = param.substring(1);
+                operation.parameters.push({
+                  name: paramName,
+                  in: "path",
+                  required: true,
+                  schema: { type: "string" }
+                });
+              }
+            }
+            if (action.querySchema) {
+              const querySchemaName = `${toPascalCase2(controller.name || controllerKey)}${toPascalCase2(actionName)}Query`;
+              const queryJsonSchema = action.querySchema;
+              this.schemas[querySchemaName] = queryJsonSchema;
+              const properties = this.schemas[querySchemaName].properties || {};
+              const requiredProps = this.schemas[querySchemaName].required || [];
+              for (const propName of Object.keys(properties)) {
+                operation.parameters.push({
+                  name: propName,
+                  in: "query",
+                  required: requiredProps.includes(propName),
+                  schema: properties[propName]
+                });
+              }
+            }
+            if (action.bodySchema) {
+              const bodySchemaName = `${toPascalCase2(controller.name || controllerKey)}${toPascalCase2(actionName)}Body`;
+              const bodyJsonSchema = action.bodySchema;
+              this.schemas[bodySchemaName] = bodyJsonSchema;
+              operation.requestBody = {
+                required: true,
+                content: {
+                  "application/json": {
+                    schema: { $ref: `#/components/schemas/${bodySchemaName}` }
+                  }
+                }
+              };
+            }
+            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[path11][action.method.toLowerCase()] = operation;
+          }
+        }
+        return paths;
+      }
+    };
   }
 });
 
@@ -11691,17 +12027,18 @@ var watcher_exports = {};
 __export(watcher_exports, {
   IgniterWatcher: () => IgniterWatcher
 });
-var fs7, path8, import_url, import_chokidar, IgniterWatcher;
+var fs8, path9, import_chokidar, IgniterWatcher;
 var init_watcher = __esm({
   "src/adapters/build/watcher.ts"() {
     "use strict";
-    fs7 = __toESM(require("fs"));
-    path8 = __toESM(require("path"));
-    import_url = require("url");
+    fs8 = __toESM(require("fs"));
+    path9 = __toESM(require("path"));
+    init_introspector();
     init_generator();
     init_logger();
     init_spinner();
     import_chokidar = __toESM(require("chokidar"));
+    init_openapi_generator();
     IgniterWatcher = class {
       // Detect interactive mode
       constructor(config) {
@@ -11721,6 +12058,8 @@ var init_watcher = __esm({
           hotReload: true,
           controllerPatterns: ["**/*.controller.{ts,js}"],
           debug: false,
+          generateDocs: false,
+          docsOutputDir: "./src/docs",
           ...config
         };
         this.isInteractiveMode = !!(process.env.IGNITER_INTERACTIVE_MODE === "true" || process.argv.includes("--interactive"));
@@ -11782,380 +12121,6 @@ var init_watcher = __esm({
           process.stdout.write("\n");
         }
       }
-      /**
-       * Load router from file with simplified approach
-       */
-      async loadRouter(routerPath) {
-        const logger6 = createChildLogger({ component: "router-loader" });
-        const fullPath = path8.resolve(process.cwd(), routerPath);
-        logger6.debug("Loading router", { path: routerPath });
-        try {
-          const module2 = await this.loadWithTypeScriptSupport(fullPath);
-          if (module2) {
-            if (module2?.config && module2?.controllers) {
-              const controllerCount = Object.keys(module2.controllers || {}).length;
-              return module2;
-            }
-            const router = module2?.AppRouter || module2?.default?.AppRouter || module2?.default || module2?.router;
-            if (router && typeof router === "object") {
-              const controllerCount = Object.keys(router.controllers || {}).length;
-              return router;
-            } else {
-              logger6.debug("Available exports", {
-                exports: Object.keys(module2 || {})
-              });
-            }
-          } else {
-          }
-          const fallbackSpinner = createDetachedSpinner("Trying fallback loading method...");
-          fallbackSpinner.start();
-          const fallbackModule = await this.loadRouterWithIndexResolution(fullPath);
-          if (fallbackModule) {
-            if (fallbackModule?.config && fallbackModule?.controllers) {
-              const controllerCount = Object.keys(fallbackModule.controllers || {}).length;
-              fallbackSpinner.success(`Router loaded successfully - ${controllerCount} controllers`);
-              return fallbackModule;
-            }
-            const router = fallbackModule?.AppRouter || fallbackModule?.default?.AppRouter || fallbackModule?.default || fallbackModule?.router;
-            if (router && typeof router === "object") {
-              const controllerCount = Object.keys(router.controllers || {}).length;
-              fallbackSpinner.success(`Router loaded successfully - ${controllerCount} controllers`);
-              return router;
-            }
-          }
-          fallbackSpinner.error("Could not load router");
-        } catch (error) {
-          logger6.error("Failed to load router", { path: routerPath }, error);
-        }
-        return null;
-      }
-      /**
-       * Load TypeScript files using TSX runtime loader
-       * This is the NEW robust approach that replaces the problematic transpilation
-       */
-      async loadWithTypeScriptSupport(filePath) {
-        const logger6 = createChildLogger({ component: "tsx-loader" });
-        const jsPath = filePath.replace(/\.ts$/, ".js");
-        if (fs7.existsSync(jsPath)) {
-          try {
-            logger6.debug("Using compiled JS version");
-            delete require.cache[jsPath];
-            const module2 = require(jsPath);
-            return module2;
-          } catch (error) {
-            logger6.debug("Compiled JS loading failed, trying TypeScript...");
-          }
-        }
-        if (filePath.endsWith(".ts")) {
-          try {
-            logger6.debug("Using TSX runtime loader");
-            const { spawn: spawn2 } = require("child_process");
-            const tsxCheckResult = await new Promise((resolve4) => {
-              const checkChild = spawn2("npx", ["tsx", "--version"], {
-                stdio: "pipe",
-                cwd: process.cwd()
-              });
-              checkChild.on("close", (code) => {
-                resolve4(code === 0);
-              });
-              checkChild.on("error", () => {
-                resolve4(false);
-              });
-              setTimeout(() => {
-                checkChild.kill();
-                resolve4(false);
-              }, 5e3);
-            });
-            if (!tsxCheckResult) {
-              throw new Error("TSX not available");
-            }
-            const result = await new Promise((resolve4, reject) => {
-              const tsxScript = `
-            async function loadRouter() {
-              try {
-                const module = await import('${(0, import_url.pathToFileURL)(filePath).href}');
-                const router = module?.AppRouter || module?.default?.AppRouter || module?.default || module?.router;
-
-                if (router && typeof router === 'object') {
-                  // Extract safe metadata for CLI use
-                  const safeRouter = {
-                    config: {
-                      baseURL: router.config?.baseURL || '',
-                      basePATH: router.config?.basePATH || ''
-                    },
-                    controllers: {}
-                  };
-
-                  // Extract controller metadata (no handlers/functions)
-                  if (router.controllers && typeof router.controllers === 'object') {
-                    for (const [controllerName, controller] of Object.entries(router.controllers)) {
-                      if (controller && typeof controller === 'object' && (controller as any).actions) {
-                        const safeActions: Record<string, any> = {};
-
-                        for (const [actionName, action] of Object.entries((controller as any).actions)) {
-                          if (action && typeof action === 'object') {
-                            // Extract only metadata, no functions
-                            safeActions[actionName] = {
-                              path: (action as any).path || '',
-                              method: (action as any).method || 'GET',
-                              description: (action as any).description,
-                              // Keep type inference data if available
-                              $Infer: (action as any).$Infer
-                            };
-                          }
-                        }
-
-                        safeRouter.controllers[controllerName] = {
-                          name: (controller as any).name || controllerName,
-                          path: (controller as any).path || '',
-                          actions: safeActions
-                        };
-                      }
-                    }
-                  }
-
-                  console.log('__ROUTER_SUCCESS__' + JSON.stringify(safeRouter));
-                  process.exit(0); // Force exit after success
-                } else {
-                  console.log('__ROUTER_ERROR__No router found in module');
-                  process.exit(1); // Force exit after error
-                }
-              } catch (error) {
-                console.log('__ROUTER_ERROR__' + error.message);
-                process.exit(1); // Force exit after error
-              }
-            }
-
-            loadRouter();
-          `;
-              const child = spawn2("npx", ["tsx", "-e", tsxScript], {
-                stdio: "pipe",
-                cwd: process.cwd(),
-                env: { ...process.env, NODE_NO_WARNINGS: "1" }
-              });
-              let output = "";
-              let errorOutput = "";
-              child.stdout?.on("data", (data) => {
-                output += data.toString();
-              });
-              child.stderr?.on("data", (data) => {
-                errorOutput += data.toString();
-              });
-              child.on("close", (code) => {
-                if (output.includes("__ROUTER_SUCCESS__")) {
-                  const resultLine = output.split("\n").find((line) => line.includes("__ROUTER_SUCCESS__"));
-                  if (resultLine) {
-                    try {
-                      const routerData = JSON.parse(resultLine.replace("__ROUTER_SUCCESS__", ""));
-                      resolve4(routerData);
-                    } catch (e) {
-                      reject(new Error("Failed to parse router data: " + e.message));
-                    }
-                  } else {
-                    reject(new Error("Router success marker found but no data"));
-                  }
-                } else if (output.includes("__ROUTER_ERROR__")) {
-                  const errorLine = output.split("\n").find((line) => line.includes("__ROUTER_ERROR__"));
-                  const errorMsg = errorLine ? errorLine.replace("__ROUTER_ERROR__", "") : "Unknown error";
-                  reject(new Error("Router loading failed: " + errorMsg));
-                } else {
-                  reject(new Error(`TSX execution failed with code ${code}: ${errorOutput || "No output"}`));
-                }
-              });
-              child.on("error", (error) => {
-                reject(new Error("Failed to spawn TSX process: " + error.message));
-              });
-              setTimeout(() => {
-                child.kill();
-                reject(new Error("Timeout loading TypeScript file with TSX"));
-              }, 3e4);
-            });
-            return result;
-          } catch (error) {
-            logger6.debug("TSX runtime loader failed", {}, error);
-          }
-        }
-        return null;
-      }
-      /**
-       * Load router by resolving directory imports to index files
-       */
-      async loadRouterWithIndexResolution(routerPath) {
-        const logger6 = createChildLogger({ component: "index-resolver" });
-        try {
-          const routerContent = fs7.readFileSync(routerPath, "utf8");
-          const importRegex = /from\s+['\"]([^'\"]+)['\"]/g;
-          let resolvedContent = routerContent;
-          const matches = Array.from(routerContent.matchAll(importRegex));
-          for (const [fullMatch, importPath] of matches) {
-            if (!importPath.startsWith(".") && !importPath.startsWith("@")) {
-              continue;
-            }
-            const basePath = path8.dirname(routerPath);
-            let resolvedPath;
-            if (importPath.startsWith("@/")) {
-              resolvedPath = path8.resolve(process.cwd(), "src", importPath.substring(2));
-            } else if (importPath.startsWith("./")) {
-              resolvedPath = path8.resolve(basePath, importPath);
-            } else {
-              resolvedPath = path8.resolve(basePath, importPath);
-            }
-            let finalPath = importPath;
-            if (!importPath.match(/\\.(js|ts|tsx|jsx)$/)) {
-              const possibleFiles = [
-                resolvedPath + ".ts",
-                resolvedPath + ".tsx",
-                resolvedPath + ".js",
-                resolvedPath + ".jsx"
-              ];
-              let fileFound = false;
-              for (const filePath of possibleFiles) {
-                if (fs7.existsSync(filePath)) {
-                  const ext = path8.extname(filePath);
-                  finalPath = importPath + ext;
-                  fileFound = true;
-                  break;
-                }
-              }
-              if (!fileFound) {
-                const possibleIndexFiles = [
-                  path8.join(resolvedPath, "index.ts"),
-                  path8.join(resolvedPath, "index.tsx"),
-                  path8.join(resolvedPath, "index.js"),
-                  path8.join(resolvedPath, "index.jsx")
-                ];
-                for (const indexFile of possibleIndexFiles) {
-                  if (fs7.existsSync(indexFile)) {
-                    const ext = path8.extname(indexFile);
-                    finalPath = importPath + "/index" + ext;
-                    break;
-                  }
-                }
-              }
-            }
-            const absolutePath = path8.resolve(basePath, finalPath);
-            if (fs7.existsSync(absolutePath)) {
-              const fileUrl = (0, import_url.pathToFileURL)(absolutePath).href;
-              resolvedContent = resolvedContent.replace(fullMatch, `from '${fileUrl}'`);
-            } else {
-              resolvedContent = resolvedContent.replace(fullMatch, `from '${finalPath}'`);
-            }
-          }
-          const tempFileName = `igniter-temp-${Date.now()}.ts`;
-          const tempFilePath = path8.join(process.cwd(), tempFileName);
-          try {
-            fs7.writeFileSync(tempFilePath, resolvedContent);
-            logger6.debug("Loading resolved module via TSX");
-            const { spawn: spawn2 } = require("child_process");
-            const result = await new Promise((resolve4, reject) => {
-              const tsxScript = `
-            async function loadResolvedRouter() {
-              try {
-                const module = await import('${(0, import_url.pathToFileURL)(tempFilePath).href}');
-                const router = module?.AppRouter || module?.default?.AppRouter || module?.default || module?.router;
-
-                if (router && typeof router === 'object') {
-                  // Extract safe metadata
-                  const safeRouter = {
-                    config: {
-                      baseURL: router.config?.baseURL || '',
-                      basePATH: router.config?.basePATH || ''
-                    },
-                    controllers: {}
-                  };
-
-                  if (router.controllers && typeof router.controllers === 'object') {
-                    for (const [controllerName, controller] of Object.entries(router.controllers)) {
-                      if (controller && typeof controller === 'object' && (controller as any).actions) {
-                        const safeActions: Record<string, any> = {};
-
-                        for (const [actionName, action] of Object.entries((controller as any).actions)) {
-                          if (action && typeof action === 'object') {
-                            safeActions[actionName] = {
-                              path: (action as any).path || '',
-                              method: (action as any).method || 'GET',
-                              description: (action as any).description,
-                              $Infer: (action as any).$Infer
-                            };
-                          }
-                        }
-
-                        safeRouter.controllers[controllerName] = {
-                          name: (controller as any).name || controllerName,
-                          path: (controller as any).path || '',
-                          actions: safeActions
-                        };
-                      }
-                    }
-                  }
-
-                  console.log('__ROUTER_SUCCESS__' + JSON.stringify(safeRouter));
-                  process.exit(0); // Force exit after success
-                } else {
-                  console.log('__ROUTER_ERROR__No router found in resolved module');
-                  process.exit(1); // Force exit after error
-                }
-              } catch (error) {
-                console.log('__ROUTER_ERROR__' + error.message);
-                process.exit(1); // Force exit after error
-              }
-            }
-
-            loadResolvedRouter();
-          `;
-              const child = spawn2("npx", ["tsx", "-e", tsxScript], {
-                stdio: "pipe",
-                cwd: process.cwd(),
-                env: { ...process.env, NODE_NO_WARNINGS: "1" }
-              });
-              let output = "";
-              let errorOutput = "";
-              child.stdout?.on("data", (data) => {
-                output += data.toString();
-              });
-              child.stderr?.on("data", (data) => {
-                errorOutput += data.toString();
-              });
-              child.on("close", (code) => {
-                if (output.includes("__ROUTER_SUCCESS__")) {
-                  const resultLine = output.split("\n").find((line) => line.includes("__ROUTER_SUCCESS__"));
-                  if (resultLine) {
-                    try {
-                      const routerData = JSON.parse(resultLine.replace("__ROUTER_SUCCESS__", ""));
-                      resolve4(routerData);
-                    } catch (e) {
-                      reject(new Error("Failed to parse resolved router data: " + e.message));
-                    }
-                  } else {
-                    reject(new Error("Router success marker found but no data"));
-                  }
-                } else if (output.includes("__ROUTER_ERROR__")) {
-                  const errorLine = output.split("\n").find((line) => line.includes("__ROUTER_ERROR__"));
-                  const errorMsg = errorLine ? errorLine.replace("__ROUTER_ERROR__", "") : "Unknown error";
-                  reject(new Error("Router loading failed: " + errorMsg));
-                } else {
-                  reject(new Error(`TSX execution failed with code ${code}: ${errorOutput || "No output"}`));
-                }
-              });
-              child.on("error", (error) => {
-                reject(new Error("Failed to spawn TSX process for resolved module: " + error.message));
-              });
-              setTimeout(() => {
-                child.kill();
-                reject(new Error("Timeout loading resolved TypeScript file with TSX"));
-              }, 3e4);
-            });
-            return result;
-          } finally {
-            if (fs7.existsSync(tempFilePath)) {
-              fs7.unlinkSync(tempFilePath);
-            }
-          }
-        } catch (error) {
-          logger6.error("Index resolution failed", { path: routerPath }, error);
-          throw error;
-        }
-      }
       /**
        * Start watching controller files
        */
@@ -12170,7 +12135,7 @@ var init_watcher = __esm({
             persistent: true,
             ignoreInitial: false
           });
-          await new Promise((resolve4, reject) => {
+          await new Promise((resolve5, reject) => {
             this.watcher.on("add", this.handleFileChange.bind(this));
             this.watcher.on("change", this.handleFileChange.bind(this));
             this.watcher.on("unlink", this.handleFileChange.bind(this));
@@ -12178,7 +12143,7 @@ var init_watcher = __esm({
               this.logger.success("File watcher is ready", {
                 watching: this.config.controllerPatterns?.join(", ")
               });
-              resolve4();
+              resolve5();
             });
             this.watcher.on("error", (error) => {
               this.logger.error("File watcher error", {}, error);
@@ -12251,8 +12216,8 @@ var init_watcher = __esm({
           ];
           let router = null;
           for (const routerPath of possibleRouterPaths) {
-            if (fs7.existsSync(routerPath)) {
-              router = await this.loadRouter(routerPath);
+            if (fs8.existsSync(routerPath)) {
+              router = await loadRouter(routerPath);
               if (router) {
                 break;
               } else {
@@ -12267,20 +12232,43 @@ var init_watcher = __esm({
             return;
           }
           await generateSchemaFromRouter(router, this.config);
+          if (this.config.generateDocs) {
+            await this.generateOpenAPISpec(router);
+          }
         } catch (error) {
           this.logger.error("Schema generation failed", {}, error);
         } finally {
           this.isGenerating = false;
         }
       }
+      /**
+       * Generate OpenAPI specification from router
+       */
+      async generateOpenAPISpec(router) {
+        try {
+          this.logger.info("Generating OpenAPI specification...");
+          const introspected = introspectRouter(router);
+          const generator = new OpenAPIGenerator(introspected.schema.docs || {});
+          const openApiSpec = generator.generate(introspected.schema);
+          const outputDir = path9.resolve(this.config.docsOutputDir);
+          if (!fs8.existsSync(outputDir)) {
+            fs8.mkdirSync(outputDir, { recursive: true });
+          }
+          const outputPath = path9.join(outputDir, "openapi.json");
+          fs8.writeFileSync(outputPath, JSON.stringify(openApiSpec, null, 2), "utf8");
+          this.logger.success(`OpenAPI specification updated at ${outputPath}`);
+        } catch (error) {
+          this.logger.error("Error generating OpenAPI specification:", error);
+        }
+      }
     };
   }
 });
 
 // src/index.ts
 var import_commander = require("commander");
-var fs8 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
+var fs9 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
 
 // src/adapters/framework/framework-detector.ts
 var fs2 = __toESM(require("fs"));
@@ -12732,7 +12720,7 @@ var IGNITER_FEATURES = {
     name: "Redis Store",
     description: "Caching, sessions, and pub/sub messaging",
     dependencies: [
-      { name: "@igniter-js/adapter-redis", version: "alpha" },
+      { name: "@igniter-js/adapter-redis", version: "latest" },
       { name: "ioredis", version: "^5.6.1" }
     ],
     devDependencies: [
@@ -12760,8 +12748,8 @@ var IGNITER_FEATURES = {
     name: "BullMQ Jobs",
     description: "Background task processing and job queues",
     dependencies: [
-      { name: "@igniter-js/adapter-redis", version: "alpha" },
-      { name: "@igniter-js/adapter-bullmq", version: "alpha" },
+      { name: "@igniter-js/adapter-redis", version: "latest" },
+      { name: "@igniter-js/adapter-bullmq", version: "latest" },
       { name: "bullmq", version: "^4.0.0" },
       { name: "ioredis", version: "^5.6.1" }
     ],
@@ -12789,7 +12777,7 @@ var IGNITER_FEATURES = {
     name: "MCP Server",
     description: "Easy expose your API as a MCP server for AI assistants like Cursor, Claude, etc.",
     dependencies: [
-      { name: "@igniter-js/adapter-mcp", version: "alpha" },
+      { name: "@igniter-js/adapter-mcp", version: "latest" },
       { name: "@vercel/mcp-adapter", version: "^0.2.0" },
       { name: "@modelcontextprotocol/sdk", version: "^1.10.2" },
       { name: "ioredis", version: "^5.6.1" }
@@ -12821,7 +12809,7 @@ var IGNITER_FEATURES = {
     name: "Enhanced Logging",
     description: "Advanced console logging with structured output",
     dependencies: [
-      { name: "@igniter-js/core", version: "alpha" }
+      { name: "@igniter-js/core", version: "latest" }
     ],
     envVars: [
       { key: "IGNITER_LOG_LEVEL", value: "info", description: "Logging level (debug, info, warn, error)" }
@@ -12832,7 +12820,7 @@ var IGNITER_FEATURES = {
     name: "Telemetry",
     description: "Telemetry for tracking requests and errors",
     dependencies: [
-      { name: "@igniter-js/core", version: "alpha" }
+      { name: "@igniter-js/core", version: "latest" }
     ],
     envVars: [
       { key: "IGNITER_TELEMETRY_ENABLE_TRACING", value: "true", description: "Enable telemetry tracing" },
@@ -14464,13 +14452,13 @@ program.command("init").description("Create a new Igniter.js project with intera
         process.exit(1);
       }
     }
-    const targetDir = projectName === "." ? process.cwd() : path9.resolve(projectName);
-    const isExistingProject = await fs8.promises.stat(path9.join(targetDir, "package.json")).catch(() => null) !== null;
+    const targetDir = projectName === "." ? process.cwd() : path10.resolve(projectName);
+    const isExistingProject = await fs9.promises.stat(path10.join(targetDir, "package.json")).catch(() => null) !== null;
     if (!options.force) {
       try {
-        const stats = await fs8.promises.stat(targetDir);
+        const stats = await fs9.promises.stat(targetDir);
         if (stats.isDirectory()) {
-          const files = await fs8.promises.readdir(targetDir);
+          const files = await fs9.promises.readdir(targetDir);
           const nonEmptyFiles = files.filter((file) => !file.startsWith("."));
           if (nonEmptyFiles.length > 0 && !isExistingProject) {
             const shouldOverwrite = await confirmOverwrite(`Directory '${projectName}' is not empty. Continue?`);
@@ -14499,7 +14487,7 @@ program.command("init").description("Create a new Igniter.js project with intera
     process.exit(1);
   }
 });
-program.command("dev").description("Start development mode with framework and Igniter (interactive dashboard by default)").option("--framework <type>", `Framework type (${getFrameworkList()}, generic)`).option("--output <dir>", "Output directory for generated client files", "src/").option("--debug", "Enable debug mode").option("--port <number>", "Port for the dev server", "3000").option("--cmd <command>", "Custom command to start dev server").option("--no-framework", "Disable framework dev server (Igniter only)").option("--no-interactive", "Disable interactive mode (use regular concurrent mode)").action(async (options) => {
+program.command("dev").description("Start development mode with framework and Igniter (interactive dashboard by default)").option("--framework <type>", `Framework type (${getFrameworkList()}, generic)`).option("--output <dir>", "Output directory for generated client files", "src/").option("--debug", "Enable debug mode").option("--port <number>", "Port for the dev server", "3000").option("--cmd <command>", "Custom command to start dev server").option("--no-framework", "Disable framework dev server (Igniter only)").option("--no-interactive", "Disable interactive mode (use regular concurrent mode)").option("--docs", "Enable automatic OpenAPI documentation generation").option("--docs-output <dir>", "Output directory for OpenAPI docs", "./src/docs").action(async (options) => {
   const detectedFramework = detectFramework();
   const framework = options.framework ? isFrameworkSupported(options.framework) ? options.framework : "generic" : detectedFramework;
   const useInteractive = options.interactive !== false;
@@ -14528,9 +14516,10 @@ program.command("dev").description("Start development mode with framework and Ig
       });
     }
   }
+  const docsFlags = options.docs ? ` --docs --docs-output ${options.docsOutput}` : "";
   processes.push({
     name: "Igniter",
-    command: `igniter generate schema --watch --framework ${framework} --output ${options.output}${options.debug ? " --debug" : ""}`,
+    command: `igniter generate schema --watch --framework ${framework} --output ${options.output}${options.debug ? " --debug" : ""}${docsFlags}`,
     color: "blue",
     cwd: process.cwd()
   });
@@ -14541,7 +14530,7 @@ program.command("dev").description("Start development mode with framework and Ig
   }
 });
 var generate = program.command("generate").description("Scaffold new features or generate client schema");
-generate.command("schema").description("Generate client schema from your Igniter router (for CI/CD or manual builds)").option("--framework <type>", `Framework type (${getFrameworkList()}, generic)`).option("--output <dir>", "Output directory", "src/").option("--debug", "Enable debug mode").option("--watch", "Watch for changes and regenerate automatically").action(async (options) => {
+generate.command("schema").description("Generate client schema from your Igniter router (for CI/CD or manual builds)").option("--framework <type>", `Framework type (${getFrameworkList()}, generic)`).option("--output <dir>", "Output directory", "src/").option("--debug", "Enable debug mode").option("--watch", "Watch for changes and regenerate automatically").option("--docs", "Enable automatic OpenAPI documentation generation").option("--docs-output <dir>", "Output directory for OpenAPI docs", "./src/docs").action(async (options) => {
   const startTime = performance.now();
   const detectedFramework = detectFramework();
   const framework = options.framework ? isFrameworkSupported(options.framework) ? options.framework : "generic" : detectedFramework;
@@ -14554,7 +14543,9 @@ generate.command("schema").description("Generate client schema from your Igniter
     framework,
     outputDir: options.output,
     debug: options.debug,
-    controllerPatterns: ["**/*.controller.{ts,js}"]
+    controllerPatterns: ["**/*.controller.{ts,js}"],
+    generateDocs: options.docs,
+    docsOutputDir: options.docsOutput
   });
   watcherSpinner.success("Generator loaded");
   if (options.watch) {
@@ -14567,6 +14558,69 @@ generate.command("schema").description("Generate client schema from your Igniter
     process.exit(0);
   }
 });
+generate.command("docs").description("Generate OpenAPI specification and/or interactive playground").option("--output <dir>", "Output directory for the OpenAPI spec", "./src").option("--ui", "Generate a self-contained HTML file with Scalar UI").action(async (options) => {
+  const docsLogger = createChildLogger({ component: "generate-docs-command" });
+  try {
+    docsLogger.info("Starting OpenAPI documentation generation...");
+    const { loadRouter: loadRouter2, introspectRouter: introspectRouter2 } = await Promise.resolve().then(() => (init_introspector(), introspector_exports));
+    const { OpenAPIGenerator: OpenAPIGenerator2 } = await Promise.resolve().then(() => (init_openapi_generator(), openapi_generator_exports));
+    const possibleRouterPaths = [
+      "src/igniter.router.ts",
+      "src/igniter.router.js",
+      "src/router.ts",
+      "src/router.js",
+      "igniter.router.ts",
+      "igniter.router.js",
+      "router.ts",
+      "router.js"
+    ];
+    let router = null;
+    for (const routerPath of possibleRouterPaths) {
+      if (fs9.existsSync(routerPath)) {
+        router = await loadRouter2(routerPath);
+        if (router) {
+          docsLogger.info(`Found router at: ${routerPath}`);
+          break;
+        }
+      }
+    }
+    if (!router) {
+      docsLogger.error("No Igniter router found in your project. Please ensure you have a router file (e.g., src/igniter.router.ts).");
+      process.exit(1);
+    }
+    const introspected = introspectRouter2(router);
+    const generator = new OpenAPIGenerator2(introspected.schema.docs || {});
+    const openApiSpec = generator.generate(introspected.schema);
+    const outputDir = path10.resolve(options.output, "docs");
+    if (!fs9.existsSync(outputDir)) {
+      fs9.mkdirSync(outputDir, { recursive: true });
+    }
+    const outputPath = path10.join(outputDir, "openapi.json");
+    fs9.writeFileSync(outputPath, JSON.stringify(openApiSpec, null, 2), "utf8");
+    docsLogger.success(`OpenAPI specification generated at ${outputPath}`);
+    if (options.ui) {
+      const scalarHtml = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>API Reference</title>
+  </head>
+  <body>
+    <script id="api-reference" data-url="./openapi.json"></script>
+    <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
+  </body>
+</html>`;
+      const uiOutputPath = path10.join(outputDir, "index.html");
+      fs9.writeFileSync(uiOutputPath, scalarHtml, "utf8");
+      docsLogger.success(`Scalar UI generated at ${uiOutputPath}`);
+    }
+  } catch (error) {
+    docsLogger.error("Failed to generate OpenAPI documentation:");
+    console.error(error);
+    process.exit(1);
+  }
+});
 generate.command("feature").description("Scaffold a new feature module").argument("<name>", "The name of the feature (e.g., 'user', 'products')").option("--schema <value>", "Generate from a schema provider (e.g., 'prisma:User')").action(async (name, options) => {
   await handleGenerateFeature(name, options);
 });