zuro-cli 0.0.2-beta.12 → 0.0.2-beta.14

package/dist/index.js

@@ -6,6 +6,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -23,6 +30,343 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/utils/code-inject.ts
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function appendImport(source, line) {
+  if (source.includes(line)) {
+    return { source, inserted: true };
+  }
+  const importRegex = /^import .+ from .+;?\s*$/gm;
+  let lastImportIndex = 0;
+  let match;
+  while ((match = importRegex.exec(source)) !== null) {
+    lastImportIndex = match.index + match[0].length;
+  }
+  if (lastImportIndex <= 0) {
+    return { source, inserted: false };
+  }
+  return {
+    source: source.slice(0, lastImportIndex) + `
+${line}` + source.slice(lastImportIndex),
+    inserted: true
+  };
+}
+var init_code_inject = __esm({
+  "src/utils/code-inject.ts"() {
+    "use strict";
+  }
+});
+
+// src/handlers/database.handler.ts
+var database_handler_exports = {};
+__export(database_handler_exports, {
+  DEFAULT_DATABASE_URLS: () => DEFAULT_DATABASE_URLS,
+  backupDatabaseFiles: () => backupDatabaseFiles,
+  databaseLabel: () => databaseLabel,
+  detectInstalledDatabaseDialect: () => detectInstalledDatabaseDialect,
+  ensureSchemaExport: () => ensureSchemaExport,
+  getDatabaseSetupHint: () => getDatabaseSetupHint,
+  isDatabaseModule: () => isDatabaseModule,
+  parseDatabaseDialect: () => parseDatabaseDialect,
+  printDatabaseHints: () => printDatabaseHints,
+  promptDatabaseConfig: () => promptDatabaseConfig,
+  validateDatabaseUrl: () => validateDatabaseUrl
+});
+function parseDatabaseDialect(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) {
+    return null;
+  }
+  if (normalized === "pg" || normalized === "postgres" || normalized === "postgresql" || normalized === "database-pg") {
+    return "database-pg";
+  }
+  if (normalized === "mysql" || normalized === "database-mysql") {
+    return "database-mysql";
+  }
+  return null;
+}
+function isDatabaseModule(moduleName) {
+  return moduleName === "database-pg" || moduleName === "database-mysql";
+}
+function validateDatabaseUrl(rawUrl, moduleName) {
+  const dbUrl = rawUrl.trim();
+  if (!dbUrl) {
+    throw new Error("Database URL cannot be empty.");
+  }
+  let parsed;
+  try {
+    parsed = new URL(dbUrl);
+  } catch {
+    throw new Error(`Invalid database URL: '${dbUrl}'.`);
+  }
+  const protocol = parsed.protocol.toLowerCase();
+  if (moduleName === "database-pg" && protocol !== "postgresql:" && protocol !== "postgres:") {
+    throw new Error("PostgreSQL URL must start with postgres:// or postgresql://");
+  }
+  if (moduleName === "database-mysql" && protocol !== "mysql:") {
+    throw new Error("MySQL URL must start with mysql://");
+  }
+  return dbUrl;
+}
+async function detectInstalledDatabaseDialect(projectRoot, srcDir) {
+  const dbIndexPath = import_path7.default.join(projectRoot, srcDir, "db", "index.ts");
+  if (!import_fs_extra6.default.existsSync(dbIndexPath)) {
+    return null;
+  }
+  const content = await import_fs_extra6.default.readFile(dbIndexPath, "utf-8");
+  if (content.includes("drizzle-orm/node-postgres") || content.includes(`from "pg"`)) {
+    return "database-pg";
+  }
+  if (content.includes("drizzle-orm/mysql2") || content.includes(`from "mysql2`)) {
+    return "database-mysql";
+  }
+  return null;
+}
+async function backupDatabaseFiles(projectRoot, srcDir) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupRoot = import_path7.default.join(projectRoot, ".zuro", "backups", `database-${timestamp}`);
+  const candidates = [
+    import_path7.default.join(projectRoot, srcDir, "db", "index.ts"),
+    import_path7.default.join(projectRoot, "drizzle.config.ts")
+  ];
+  let copied = false;
+  for (const filePath of candidates) {
+    if (!import_fs_extra6.default.existsSync(filePath)) {
+      continue;
+    }
+    const relativePath = import_path7.default.relative(projectRoot, filePath);
+    const backupPath = import_path7.default.join(backupRoot, relativePath);
+    await import_fs_extra6.default.ensureDir(import_path7.default.dirname(backupPath));
+    await import_fs_extra6.default.copyFile(filePath, backupPath);
+    copied = true;
+  }
+  return copied ? backupRoot : null;
+}
+function databaseLabel(moduleName) {
+  return moduleName === "database-pg" ? "PostgreSQL" : "MySQL";
+}
+function getDatabaseSetupHint(moduleName, dbUrl) {
+  try {
+    const parsed = new URL(dbUrl);
+    const dbName = parsed.pathname.replace(/^\/+/, "") || "mydb";
+    if (moduleName === "database-pg") {
+      return `createdb ${dbName}`;
+    }
+    return `mysql -e "CREATE DATABASE IF NOT EXISTS ${dbName};"`;
+  } catch {
+    return moduleName === "database-pg" ? "createdb <database_name>" : `mysql -e "CREATE DATABASE IF NOT EXISTS <database_name>;"`;
+  }
+}
+async function ensureSchemaExport(projectRoot, srcDir, schemaFileName) {
+  const schemaIndexPath = import_path7.default.join(projectRoot, srcDir, "db", "schema", "index.ts");
+  if (!await import_fs_extra6.default.pathExists(schemaIndexPath)) {
+    return;
+  }
+  const exportLine = `export * from "./${schemaFileName}";`;
+  const content = await import_fs_extra6.default.readFile(schemaIndexPath, "utf-8");
+  const normalized = content.replace(/\r\n/g, "\n");
+  const exportPattern = new RegExp(
+    `^\\s*export\\s*\\*\\s*from\\s*["']\\./${escapeRegex(schemaFileName)}["'];?\\s*$`,
+    "m"
+  );
+  if (exportPattern.test(normalized)) {
+    return;
+  }
+  let next = normalized.replace(/^\s*export\s*\{\s*\};?\s*$/m, "").trimEnd();
+  if (next.length > 0) {
+    next += "\n\n";
+  }
+  next += `${exportLine}
+`;
+  await import_fs_extra6.default.writeFile(schemaIndexPath, next);
+}
+async function promptDatabaseConfig(initialModuleName, projectRoot, srcDir) {
+  let resolvedModuleName;
+  if (initialModuleName === "database") {
+    const variantResponse = await (0, import_prompts2.default)({
+      type: "select",
+      name: "variant",
+      message: "Which database dialect?",
+      choices: [
+        { title: "PostgreSQL", value: "database-pg" },
+        { title: "MySQL", value: "database-mysql" }
+      ]
+    });
+    if (!variantResponse.variant) {
+      console.log(import_chalk4.default.yellow("Operation cancelled."));
+      return null;
+    }
+    resolvedModuleName = variantResponse.variant;
+  } else {
+    resolvedModuleName = initialModuleName;
+  }
+  let databaseBackupPath = null;
+  const installedDialect = await detectInstalledDatabaseDialect(projectRoot, srcDir);
+  if (installedDialect && installedDialect !== resolvedModuleName) {
+    console.log(
+      import_chalk4.default.yellow(
+        `
+\u26A0 Existing database setup detected: ${databaseLabel(installedDialect)}.`
+      )
+    );
+    console.log(
+      import_chalk4.default.yellow(
+        `  Switching to ${databaseLabel(resolvedModuleName)} will overwrite db files and drizzle config.
+`
+      )
+    );
+    const switchResponse = await (0, import_prompts2.default)({
+      type: "confirm",
+      name: "proceed",
+      message: "Continue and switch database dialect?",
+      initial: false
+    });
+    if (!switchResponse.proceed) {
+      console.log(import_chalk4.default.yellow("Operation cancelled."));
+      return null;
+    }
+    databaseBackupPath = await backupDatabaseFiles(projectRoot, srcDir);
+  }
+  const defaultUrl = DEFAULT_DATABASE_URLS[resolvedModuleName];
+  console.log(import_chalk4.default.dim(`  Tip: Leave blank to use ${defaultUrl}
+`));
+  const response = await (0, import_prompts2.default)({
+    type: "text",
+    name: "dbUrl",
+    message: "Database URL",
+    initial: ""
+  });
+  if (response.dbUrl === void 0) {
+    console.log(import_chalk4.default.yellow("Operation cancelled."));
+    return null;
+  }
+  const enteredUrl = response.dbUrl?.trim() || "";
+  const usedDefaultDbUrl = enteredUrl.length === 0;
+  const customDbUrl = validateDatabaseUrl(enteredUrl || defaultUrl, resolvedModuleName);
+  return { resolvedModuleName, customDbUrl, usedDefaultDbUrl, databaseBackupPath };
+}
+function printDatabaseHints(moduleName, customDbUrl, usedDefaultDbUrl, databaseBackupPath) {
+  if (databaseBackupPath) {
+    console.log(import_chalk4.default.blue(`\u2139 Backup created at: ${databaseBackupPath}
+`));
+  }
+  if (usedDefaultDbUrl) {
+    console.log(import_chalk4.default.yellow("\u2139 Review DATABASE_URL in .env if your local DB config differs."));
+  }
+  const setupHint = getDatabaseSetupHint(
+    moduleName,
+    customDbUrl || DEFAULT_DATABASE_URLS[moduleName]
+  );
+  console.log(import_chalk4.default.yellow(`\u2139 Ensure DB exists: ${setupHint}`));
+  console.log(import_chalk4.default.yellow("\u2139 Run migrations: npx drizzle-kit generate && npx drizzle-kit migrate"));
+}
+var import_path7, import_fs_extra6, import_prompts2, import_chalk4, DEFAULT_DATABASE_URLS;
+var init_database_handler = __esm({
+  "src/handlers/database.handler.ts"() {
+    "use strict";
+    import_path7 = __toESM(require("path"));
+    import_fs_extra6 = __toESM(require("fs-extra"));
+    import_prompts2 = __toESM(require("prompts"));
+    import_chalk4 = __toESM(require("chalk"));
+    init_code_inject();
+    DEFAULT_DATABASE_URLS = {
+      "database-pg": "postgresql://postgres@localhost:5432/mydb",
+      "database-mysql": "mysql://root@localhost:3306/mydb"
+    };
+  }
+});
+
+// src/handlers/docs.handler.ts
+var docs_handler_exports = {};
+__export(docs_handler_exports, {
+  injectDocsRoutes: () => injectDocsRoutes,
+  isDocsModuleInstalled: () => isDocsModuleInstalled,
+  printDocsHints: () => printDocsHints
+});
+async function isDocsModuleInstalled(projectRoot, srcDir) {
+  return await import_fs_extra7.default.pathExists(import_path8.default.join(projectRoot, srcDir, "lib", "openapi.ts"));
+}
+async function injectDocsRoutes(projectRoot, srcDir) {
+  const routeIndexPath = import_path8.default.join(projectRoot, srcDir, "routes", "index.ts");
+  const routeImport = `import docsRoutes from "./docs.routes";`;
+  const routeMountPattern = /rootRouter\.use\(\s*["']\/docs["']\s*,\s*docsRoutes\s*\)/;
+  if (await import_fs_extra7.default.pathExists(routeIndexPath)) {
+    let routeContent = await import_fs_extra7.default.readFile(routeIndexPath, "utf-8");
+    let routeModified = false;
+    const importResult = appendImport(routeContent, routeImport);
+    if (!importResult.inserted) {
+      return false;
+    }
+    if (importResult.source !== routeContent) {
+      routeContent = importResult.source;
+      routeModified = true;
+    }
+    if (!routeMountPattern.test(routeContent)) {
+      const routeSetup = `
+// API docs
+rootRouter.use("/docs", docsRoutes);
+`;
+      const exportMatch = routeContent.match(/export default rootRouter;?\s*$/m);
+      if (!exportMatch || exportMatch.index === void 0) {
+        return false;
+      }
+      routeContent = routeContent.slice(0, exportMatch.index) + routeSetup + "\n" + routeContent.slice(exportMatch.index);
+      routeModified = true;
+    }
+    if (routeModified) {
+      await import_fs_extra7.default.writeFile(routeIndexPath, routeContent);
+    }
+    return true;
+  }
+  const appPath = import_path8.default.join(projectRoot, srcDir, "app.ts");
+  if (!await import_fs_extra7.default.pathExists(appPath)) {
+    return false;
+  }
+  let appContent = await import_fs_extra7.default.readFile(appPath, "utf-8");
+  let appModified = false;
+  const appImportResult = appendImport(appContent, `import docsRoutes from "./routes/docs.routes";`);
+  if (!appImportResult.inserted) {
+    return false;
+  }
+  if (appImportResult.source !== appContent) {
+    appContent = appImportResult.source;
+    appModified = true;
+  }
+  const hasMount = /app\.use\(\s*["']\/api\/docs["']\s*,\s*docsRoutes\s*\)/.test(appContent);
+  if (!hasMount) {
+    const setup = `
+// API docs
+app.use("/api/docs", docsRoutes);
+`;
+    const exportMatch = appContent.match(/export default app;?\s*$/m);
+    if (!exportMatch || exportMatch.index === void 0) {
+      return false;
+    }
+    appContent = appContent.slice(0, exportMatch.index) + setup + "\n" + appContent.slice(exportMatch.index);
+    appModified = true;
+  }
+  if (appModified) {
+    await import_fs_extra7.default.writeFile(appPath, appContent);
+  }
+  return true;
+}
+function printDocsHints() {
+  const chalk8 = require("chalk");
+  console.log(chalk8.yellow("\u2139 API docs available at: /api/docs"));
+  console.log(chalk8.yellow("\u2139 OpenAPI spec available at: /api/docs/openapi.json"));
+}
+var import_path8, import_fs_extra7;
+var init_docs_handler = __esm({
+  "src/handlers/docs.handler.ts"() {
+    "use strict";
+    import_path8 = __toESM(require("path"));
+    import_fs_extra7 = __toESM(require("fs-extra"));
+    init_code_inject();
+  }
+});
+
 // src/index.ts
 var import_commander = require("commander");
 
@@ -32,6 +376,7 @@ var import_chalk2 = __toESM(require("chalk"));
 var import_fs_extra4 = __toESM(require("fs-extra"));
 var import_path4 = __toESM(require("path"));
 var import_prompts = __toESM(require("prompts"));
+var import_child_process = require("child_process");
 
 // src/utils/registry.ts
 var import_node_crypto = require("crypto");
@@ -383,6 +728,16 @@ var ENV_CONFIGS = {
       { name: "RESEND_API_KEY", schema: "z.string().min(1)" },
       { name: "MAIL_FROM", schema: "z.string().min(1)" }
     ]
+  },
+  "rate-limiter": {
+    envVars: {
+      RATE_LIMIT_WINDOW_MS: "900000",
+      RATE_LIMIT_MAX: "100"
+    },
+    schemaFields: [
+      { name: "RATE_LIMIT_WINDOW_MS", schema: "z.coerce.number().default(900000)" },
+      { name: "RATE_LIMIT_MAX", schema: "z.coerce.number().default(100)" }
+    ]
   }
 };
 
@@ -496,6 +851,62 @@ bun.lockb
     await import_fs_extra4.default.writeFile(prettierIgnorePath, ignoreContent);
   }
 }
+async function setupGitignore(targetDir) {
+  const gitignorePath = import_path4.default.join(targetDir, ".gitignore");
+  if (await import_fs_extra4.default.pathExists(gitignorePath)) {
+    return;
+  }
+  const gitignoreContent = `# dependencies
+node_modules
+
+# build output
+dist
+build
+
+# environment variables
+.env
+.env.*
+!.env.example
+
+# logs
+*.log
+npm-debug.log*
+pnpm-debug.log*
+
+# coverage
+coverage
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# IDE
+.vscode
+.idea
+*.swp
+*.swo
+`;
+  await import_fs_extra4.default.writeFile(gitignorePath, gitignoreContent);
+}
+function tryGitInit(targetDir) {
+  try {
+    (0, import_child_process.execSync)("git rev-parse --is-inside-work-tree", {
+      cwd: targetDir,
+      stdio: "ignore"
+    });
+    return;
+  } catch {
+  }
+  try {
+    (0, import_child_process.execSync)("git init", { cwd: targetDir, stdio: "ignore" });
+    (0, import_child_process.execSync)("git add -A", { cwd: targetDir, stdio: "ignore" });
+    (0, import_child_process.execSync)('git commit -m "Initial commit from zuro-cli"', {
+      cwd: targetDir,
+      stdio: "ignore"
+    });
+  } catch {
+  }
+}
 async function init() {
   const cwd = process.cwd();
   const isExistingProject = await import_fs_extra4.default.pathExists(import_path4.default.join(cwd, "package.json"));
@@ -647,8 +1058,16 @@ async function init() {
       currentStep = "prettier setup";
       await setupPrettier(targetDir);
     }
+    currentStep = "gitignore setup";
+    spinner.text = "Setting up .gitignore...";
+    await setupGitignore(targetDir);
     currentStep = "config write";
     await writeZuroConfig(targetDir, zuroConfig);
+    if (!isExistingProject) {
+      currentStep = "git init";
+      spinner.text = "Initializing git repository...";
+      tryGitInit(targetDir);
+    }
     spinner.succeed(import_chalk2.default.green("Project initialized successfully!"));
     console.log(`
 ${import_chalk2.default.bold("Next steps:")}`);
@@ -672,10 +1091,9 @@ ${import_chalk2.default.bold("Retry:")}`);
 }
 
 // src/commands/add.ts
-var import_prompts2 = __toESM(require("prompts"));
 var import_ora2 = __toESM(require("ora"));
-var import_path6 = __toESM(require("path"));
-var import_fs_extra6 = __toESM(require("fs-extra"));
+var import_path12 = __toESM(require("path"));
+var import_fs_extra11 = __toESM(require("fs-extra"));
 var import_node_crypto2 = require("crypto");
 
 // src/utils/dependency.ts
@@ -690,7 +1108,9 @@ var BLOCK_SIGNATURES = {
   "error-handler": "lib/errors.ts",
   logger: "lib/logger.ts",
   auth: "lib/auth.ts",
-  mailer: "lib/mailer.ts"
+  mailer: "lib/mailer.ts",
+  docs: "lib/openapi.ts",
+  "rate-limiter": "middleware/rate-limiter.ts"
 };
 var resolveDependencies = async (moduleDependencies, cwd) => {
   if (!moduleDependencies || moduleDependencies.length === 0) {
@@ -721,12 +1141,8 @@ var resolveDependencies = async (moduleDependencies, cwd) => {
   }
 };
 
-// src/commands/add.ts
-var import_chalk4 = __toESM(require("chalk"));
-var DEFAULT_DATABASE_URLS = {
-  "database-pg": "postgresql://postgres@localhost:5432/mydb",
-  "database-mysql": "mysql://root@localhost:3306/mydb"
-};
+// src/utils/paths.ts
+var import_path6 = __toESM(require("path"));
 function resolveSafeTargetPath2(projectRoot, srcDir, file) {
   const targetPath = import_path6.default.resolve(projectRoot, srcDir, file.target);
   const normalizedRoot = import_path6.default.resolve(projectRoot);
@@ -735,155 +1151,380 @@ function resolveSafeTargetPath2(projectRoot, srcDir, file) {
   }
   return targetPath;
 }
-function resolvePackageManager(projectRoot) {
-  if (import_fs_extra6.default.existsSync(import_path6.default.join(projectRoot, "pnpm-lock.yaml"))) {
-    return "pnpm";
-  }
-  if (import_fs_extra6.default.existsSync(import_path6.default.join(projectRoot, "bun.lockb")) || import_fs_extra6.default.existsSync(import_path6.default.join(projectRoot, "bun.lock"))) {
-    return "bun";
-  }
-  if (import_fs_extra6.default.existsSync(import_path6.default.join(projectRoot, "yarn.lock"))) {
-    return "yarn";
-  }
-  return "npm";
+
+// src/commands/add.ts
+init_code_inject();
+var import_chalk7 = __toESM(require("chalk"));
+init_database_handler();
+
+// src/handlers/auth.handler.ts
+var import_path9 = __toESM(require("path"));
+var import_fs_extra8 = __toESM(require("fs-extra"));
+var import_prompts3 = __toESM(require("prompts"));
+var import_chalk5 = __toESM(require("chalk"));
+init_code_inject();
+async function isAuthModuleInstalled(projectRoot, srcDir) {
+  return await import_fs_extra8.default.pathExists(import_path9.default.join(projectRoot, srcDir, "lib", "auth.ts"));
 }
-function parseDatabaseDialect(value) {
-  const normalized = value?.trim().toLowerCase();
-  if (!normalized) {
-    return null;
+async function injectAuthRoutes(projectRoot, srcDir) {
+  const appPath = import_path9.default.join(projectRoot, srcDir, "app.ts");
+  if (!await import_fs_extra8.default.pathExists(appPath)) {
+    return false;
   }
-  if (normalized === "pg" || normalized === "postgres" || normalized === "postgresql" || normalized === "database-pg") {
-    return "database-pg";
+  let appContent = await import_fs_extra8.default.readFile(appPath, "utf-8");
+  const authHandlerImport = `import { toNodeHandler } from "better-auth/node";`;
+  const authImport = `import { auth } from "./lib/auth";`;
+  const routeIndexUserImport = `import userRoutes from "./user.routes";`;
+  const appUserImport = `import userRoutes from "./routes/user.routes";`;
+  let appModified = false;
+  for (const importLine of [authHandlerImport, authImport]) {
+    const next = appendImport(appContent, importLine);
+    if (!next.inserted) {
+      return false;
+    }
+    if (next.source !== appContent) {
+      appContent = next.source;
+      appModified = true;
+    }
   }
-  if (normalized === "mysql" || normalized === "database-mysql") {
-    return "database-mysql";
-  }
-  return null;
-}
-function isDatabaseModule(moduleName) {
-  return moduleName === "database-pg" || moduleName === "database-mysql";
-}
-function validateDatabaseUrl(rawUrl, moduleName) {
-  const dbUrl = rawUrl.trim();
-  if (!dbUrl) {
-    throw new Error("Database URL cannot be empty.");
-  }
-  let parsed;
-  try {
-    parsed = new URL(dbUrl);
-  } catch {
-    throw new Error(`Invalid database URL: '${dbUrl}'.`);
+  const hasAuthMount = /toNodeHandler\(\s*auth\s*\)/.test(appContent) && /\/api\/auth/.test(appContent);
+  if (!hasAuthMount) {
+    const authMountLine = "app.all(/^\\/api\\/auth(?:\\/.*)?$/, toNodeHandler(auth));\n";
+    const jsonIndex = appContent.search(/^\s*app\.use\(\s*express\.json\(\)\s*\);\s*$/m);
+    let insertionIndex = jsonIndex;
+    if (insertionIndex < 0) {
+      const healthIndex = appContent.search(/^\s*app\.get\(\s*["']\/health["']\s*,/m);
+      insertionIndex = healthIndex;
+    }
+    if (insertionIndex < 0) {
+      const exportMatch = appContent.match(/export default app;?\s*$/m);
+      insertionIndex = exportMatch?.index ?? -1;
+    }
+    if (insertionIndex < 0) {
+      return false;
+    }
+    appContent = appContent.slice(0, insertionIndex) + authMountLine + appContent.slice(insertionIndex);
+    appModified = true;
   }
-  const protocol = parsed.protocol.toLowerCase();
-  if (moduleName === "database-pg" && protocol !== "postgresql:" && protocol !== "postgres:") {
-    throw new Error("PostgreSQL URL must start with postgres:// or postgresql://");
+  const routeIndexPath = import_path9.default.join(projectRoot, srcDir, "routes", "index.ts");
+  if (await import_fs_extra8.default.pathExists(routeIndexPath)) {
+    let routeContent = await import_fs_extra8.default.readFile(routeIndexPath, "utf-8");
+    let routeModified = false;
+    const userImportResult = appendImport(routeContent, routeIndexUserImport);
+    if (!userImportResult.inserted) {
+      return false;
+    }
+    if (userImportResult.source !== routeContent) {
+      routeContent = userImportResult.source;
+      routeModified = true;
+    }
+    const hasUserRoute = /rootRouter\.use\(\s*["']\/users["']\s*,\s*userRoutes\s*\)/.test(routeContent);
+    if (!hasUserRoute) {
+      const routeSetup = `
+// User routes
+rootRouter.use("/users", userRoutes);
+`;
+      const exportMatch = routeContent.match(/export default rootRouter;?\s*$/m);
+      if (!exportMatch || exportMatch.index === void 0) {
+        return false;
+      }
+      routeContent = routeContent.slice(0, exportMatch.index) + routeSetup + "\n" + routeContent.slice(exportMatch.index);
+      routeModified = true;
+    }
+    if (routeModified) {
+      await import_fs_extra8.default.writeFile(routeIndexPath, routeContent);
+    }
+  } else {
+    const hasUserRoute = /app\.use\(\s*["']\/api\/users["']\s*,\s*userRoutes\s*\)/.test(appContent);
+    if (!hasUserRoute) {
+      const exportMatch = appContent.match(/export default app;?\s*$/m);
+      if (!exportMatch || exportMatch.index === void 0) {
+        return false;
+      }
+      const routeSetup = `
+// User routes
+app.use("/api/users", userRoutes);
+`;
+      appContent = appContent.slice(0, exportMatch.index) + routeSetup + "\n" + appContent.slice(exportMatch.index);
+      appModified = true;
+    }
+    const userImportResult = appendImport(appContent, appUserImport);
+    if (!userImportResult.inserted) {
+      return false;
+    }
+    if (userImportResult.source !== appContent) {
+      appContent = userImportResult.source;
+      appModified = true;
+    }
   }
-  if (moduleName === "database-mysql" && protocol !== "mysql:") {
-    throw new Error("MySQL URL must start with mysql://");
+  if (appModified) {
+    await import_fs_extra8.default.writeFile(appPath, appContent);
   }
-  return dbUrl;
+  return true;
 }
-async function detectInstalledDatabaseDialect(projectRoot, srcDir) {
-  const dbIndexPath = import_path6.default.join(projectRoot, srcDir, "db", "index.ts");
-  if (!import_fs_extra6.default.existsSync(dbIndexPath)) {
-    return null;
+async function injectAuthDocs(projectRoot, srcDir) {
+  const openApiPath = import_path9.default.join(projectRoot, srcDir, "lib", "openapi.ts");
+  if (!await import_fs_extra8.default.pathExists(openApiPath)) {
+    return false;
   }
-  const content = await import_fs_extra6.default.readFile(dbIndexPath, "utf-8");
-  if (content.includes("drizzle-orm/node-postgres") || content.includes(`from "pg"`)) {
-    return "database-pg";
+  const authMarker = "// ZURO_AUTH_DOCS";
+  let content = await import_fs_extra8.default.readFile(openApiPath, "utf-8");
+  if (content.includes(authMarker)) {
+    return true;
   }
-  if (content.includes("drizzle-orm/mysql2") || content.includes(`from "mysql2`)) {
-    return "database-mysql";
+  const moduleDocsEndMarker = "// ZURO_DOCS_MODULES_END";
+  if (!content.includes(moduleDocsEndMarker)) {
+    return false;
   }
-  return null;
+  const authBlock = `
+const authSignUpSchema = z.object({
+    email: z.string().email().openapi({ example: "dev@company.com" }),
+    password: z.string().min(8).openapi({ example: "strong-password" }),
+    name: z.string().min(1).optional().openapi({ example: "Dev User" }),
+});
+
+const authSignInSchema = z.object({
+    email: z.string().email().openapi({ example: "dev@company.com" }),
+    password: z.string().min(8).openapi({ example: "strong-password" }),
+});
+
+const authUserSchema = z.object({
+    id: z.string().openapi({ example: "user_123" }),
+    email: z.string().email().openapi({ example: "dev@company.com" }),
+    name: z.string().nullable().openapi({ example: "Dev User" }),
+});
+
+${authMarker}
+registry.registerPath({
+    method: "post",
+    path: "/api/auth/sign-up/email",
+    tags: ["Auth"],
+    summary: "Register using email and password",
+    request: {
+        body: {
+            content: {
+                "application/json": {
+                    schema: authSignUpSchema,
+                },
+            },
+        },
+    },
+    responses: {
+        200: { description: "Registration successful" },
+    },
+});
+
+registry.registerPath({
+    method: "post",
+    path: "/api/auth/sign-in/email",
+    tags: ["Auth"],
+    summary: "Sign in using email and password",
+    request: {
+        body: {
+            content: {
+                "application/json": {
+                    schema: authSignInSchema,
+                },
+            },
+        },
+    },
+    responses: {
+        200: { description: "Sign in successful" },
+        401: { description: "Invalid credentials" },
+    },
+});
+
+registry.registerPath({
+    method: "post",
+    path: "/api/auth/sign-out",
+    tags: ["Auth"],
+    summary: "Sign out current user",
+    responses: {
+        200: { description: "Sign out successful" },
+    },
+});
+
+registry.registerPath({
+    method: "get",
+    path: "/api/users/me",
+    tags: ["Auth"],
+    summary: "Get current authenticated user",
+    security: [{ bearerAuth: [] }],
+    responses: {
+        200: {
+            description: "Current user",
+            content: {
+                "application/json": {
+                    schema: z.object({ user: authUserSchema }),
+                },
+            },
+        },
+        401: { description: "Not authenticated" },
+    },
+});
+`;
+  content = content.replace(moduleDocsEndMarker, `${authBlock}
+${moduleDocsEndMarker}`);
+  await import_fs_extra8.default.writeFile(openApiPath, content);
+  return true;
 }
-async function backupDatabaseFiles(projectRoot, srcDir) {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupRoot = import_path6.default.join(projectRoot, ".zuro", "backups", `database-${timestamp}`);
-  const candidates = [
-    import_path6.default.join(projectRoot, srcDir, "db", "index.ts"),
-    import_path6.default.join(projectRoot, "drizzle.config.ts")
-  ];
-  let copied = false;
-  for (const filePath of candidates) {
-    if (!import_fs_extra6.default.existsSync(filePath)) {
-      continue;
+async function promptAuthConfig(projectRoot, srcDir, options) {
+  const { isDocsModuleInstalled: isDocsModuleInstalled2 } = await Promise.resolve().then(() => (init_docs_handler(), docs_handler_exports));
+  const docsInstalled = await isDocsModuleInstalled2(projectRoot, srcDir);
+  let shouldInstallDocsForAuth = false;
+  if (!docsInstalled) {
+    if (options.yes) {
+      shouldInstallDocsForAuth = true;
+    } else {
+      const docsResponse = await (0, import_prompts3.default)({
+        type: "confirm",
+        name: "installDocs",
+        message: "Install API docs module (Scalar + OpenAPI) too?",
+        initial: true
+      });
+      if (docsResponse.installDocs === void 0) {
+        console.log(import_chalk5.default.yellow("Operation cancelled."));
+        return null;
+      }
+      shouldInstallDocsForAuth = docsResponse.installDocs;
     }
-    const relativePath = import_path6.default.relative(projectRoot, filePath);
-    const backupPath = import_path6.default.join(backupRoot, relativePath);
-    await import_fs_extra6.default.ensureDir(import_path6.default.dirname(backupPath));
-    await import_fs_extra6.default.copyFile(filePath, backupPath);
-    copied = true;
   }
-  return copied ? backupRoot : null;
-}
-function databaseLabel(moduleName) {
-  return moduleName === "database-pg" ? "PostgreSQL" : "MySQL";
+  const { detectInstalledDatabaseDialect: detectInstalledDatabaseDialect2 } = await Promise.resolve().then(() => (init_database_handler(), database_handler_exports));
+  const authDatabaseDialect = await detectInstalledDatabaseDialect2(projectRoot, srcDir);
+  return { shouldInstallDocsForAuth, authDatabaseDialect };
 }
-function getDatabaseSetupHint(moduleName, dbUrl) {
-  try {
-    const parsed = new URL(dbUrl);
-    const dbName = parsed.pathname.replace(/^\/+/, "") || "mydb";
-    if (moduleName === "database-pg") {
-      return `createdb ${dbName}`;
-    }
-    return `mysql -e "CREATE DATABASE IF NOT EXISTS ${dbName};"`;
-  } catch {
-    return moduleName === "database-pg" ? "createdb <database_name>" : `mysql -e "CREATE DATABASE IF NOT EXISTS <database_name>;"`;
+function printAuthHints(generatedAuthSecret) {
+  if (generatedAuthSecret) {
+    console.log(import_chalk5.default.yellow("\u2139 BETTER_AUTH_SECRET was generated automatically."));
+  } else {
+    console.log(import_chalk5.default.yellow("\u2139 Review BETTER_AUTH_SECRET and BETTER_AUTH_URL in .env."));
   }
+  console.log(import_chalk5.default.yellow("\u2139 Run migrations: npx drizzle-kit generate && npx drizzle-kit migrate"));
 }
-function getModuleDocsPath(moduleName) {
-  if (isDatabaseModule(moduleName)) {
-    return "database";
+
+// src/handlers/mailer.handler.ts
+var import_prompts4 = __toESM(require("prompts"));
+var import_chalk6 = __toESM(require("chalk"));
+async function promptMailerConfig() {
+  const providerResponse = await (0, import_prompts4.default)({
+    type: "select",
+    name: "provider",
+    message: "Which email provider?",
+    choices: [
+      { title: "SMTP (Nodemailer)", description: "Gmail, Mailtrap, any SMTP server", value: "smtp" },
+      { title: "Resend", description: "API-based, easiest setup", value: "resend" }
+    ]
+  });
+  if (providerResponse.provider === void 0) {
+    console.log(import_chalk6.default.yellow("Operation cancelled."));
+    return null;
   }
-  return moduleName;
-}
-function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-async function hasEnvVariable(projectRoot, key) {
-  const envPath = import_path6.default.join(projectRoot, ".env");
-  if (!await import_fs_extra6.default.pathExists(envPath)) {
-    return false;
+  const mailerProvider = providerResponse.provider;
+  let customSmtpVars;
+  let usedDefaultSmtp = false;
+  console.log(import_chalk6.default.dim("  Tip: Leave fields blank to use placeholder values and configure later\n"));
+  if (mailerProvider === "smtp") {
+    const smtpResponse = await (0, import_prompts4.default)([
+      {
+        type: "text",
+        name: "host",
+        message: "SMTP Host",
+        initial: ""
+      },
+      {
+        type: "text",
+        name: "port",
+        message: "SMTP Port",
+        initial: "587"
+      },
+      {
+        type: "text",
+        name: "user",
+        message: "SMTP User",
+        initial: ""
+      },
+      {
+        type: "password",
+        name: "pass",
+        message: "SMTP Password"
+      },
+      {
+        type: "text",
+        name: "from",
+        message: "Mail From address",
+        initial: ""
+      }
+    ]);
+    if (smtpResponse.host === void 0) {
+      console.log(import_chalk6.default.yellow("Operation cancelled."));
+      return null;
+    }
+    const host = smtpResponse.host?.trim() || "";
+    const user = smtpResponse.user?.trim() || "";
+    const pass = smtpResponse.pass?.trim() || "";
+    const from = smtpResponse.from?.trim() || "";
+    const port = smtpResponse.port?.trim() || "587";
+    usedDefaultSmtp = !host && !user;
+    if (!usedDefaultSmtp) {
+      customSmtpVars = {
+        SMTP_HOST: host || "smtp.example.com",
+        SMTP_PORT: port,
+        SMTP_USER: user || "your-email@example.com",
+        SMTP_PASS: pass || "your-password",
+        MAIL_FROM: from || "noreply@example.com"
+      };
+    }
+  } else {
+    const resendResponse = await (0, import_prompts4.default)([
+      {
+        type: "text",
+        name: "apiKey",
+        message: "Resend API Key",
+        initial: ""
+      },
+      {
+        type: "text",
+        name: "from",
+        message: "Mail From address",
+        initial: ""
+      }
+    ]);
+    if (resendResponse.apiKey === void 0) {
+      console.log(import_chalk6.default.yellow("Operation cancelled."));
+      return null;
+    }
+    const apiKey = resendResponse.apiKey?.trim() || "";
+    const from = resendResponse.from?.trim() || "";
+    usedDefaultSmtp = !apiKey;
+    if (!usedDefaultSmtp) {
+      customSmtpVars = {
+        RESEND_API_KEY: apiKey || "re_your_api_key",
+        MAIL_FROM: from || "onboarding@resend.dev"
+      };
+    }
   }
-  const content = await import_fs_extra6.default.readFile(envPath, "utf-8");
-  const pattern = new RegExp(`^${escapeRegex(key)}=`, "m");
-  return pattern.test(content);
-}
-async function isLikelyEmptyDirectory(cwd) {
-  const entries = await import_fs_extra6.default.readdir(cwd);
-  const ignored = /* @__PURE__ */ new Set([".ds_store", "thumbs.db"]);
-  return entries.filter((entry) => !ignored.has(entry.toLowerCase())).length === 0;
+  return { mailerProvider, customSmtpVars, usedDefaultSmtp };
 }
-async function ensureSchemaExport(projectRoot, srcDir, schemaFileName) {
-  const schemaIndexPath = import_path6.default.join(projectRoot, srcDir, "db", "schema", "index.ts");
-  if (!await import_fs_extra6.default.pathExists(schemaIndexPath)) {
-    return;
-  }
-  const exportLine = `export * from "./${schemaFileName}";`;
-  const content = await import_fs_extra6.default.readFile(schemaIndexPath, "utf-8");
-  const normalized = content.replace(/\r\n/g, "\n");
-  const exportPattern = new RegExp(
-    `^\\s*export\\s*\\*\\s*from\\s*["']\\./${escapeRegex(schemaFileName)}["'];?\\s*$`,
-    "m"
-  );
-  if (exportPattern.test(normalized)) {
-    return;
-  }
-  let next = normalized.replace(/^\s*export\s*\{\s*\};?\s*$/m, "").trimEnd();
-  if (next.length > 0) {
-    next += "\n\n";
+function printMailerHints(usedDefaultSmtp) {
+  if (usedDefaultSmtp) {
+    console.log(import_chalk6.default.yellow("\u2139 Placeholder SMTP values added to .env \u2014 update them before sending emails."));
+  } else {
+    console.log(import_chalk6.default.yellow("\u2139 Review SMTP configuration in .env to ensure values are correct."));
   }
-  next += `${exportLine}
-`;
-  await import_fs_extra6.default.writeFile(schemaIndexPath, next);
 }
+
+// src/commands/add.ts
+init_docs_handler();
+
+// src/handlers/error-handler.handler.ts
+var import_path10 = __toESM(require("path"));
+var import_fs_extra9 = __toESM(require("fs-extra"));
 async function injectErrorHandler(projectRoot, srcDir) {
-  const appPath = import_path6.default.join(projectRoot, srcDir, "app.ts");
-  if (!import_fs_extra6.default.existsSync(appPath)) {
+  const appPath = import_path10.default.join(projectRoot, srcDir, "app.ts");
+  if (!import_fs_extra9.default.existsSync(appPath)) {
     return false;
   }
-  let content = await import_fs_extra6.default.readFile(appPath, "utf-8");
+  let content = await import_fs_extra9.default.readFile(appPath, "utf-8");
   const errorImport = `import { errorHandler, notFoundHandler } from "./middleware/error-handler";`;
   const hasErrorImport = content.includes(errorImport);
   const hasNotFoundUse = /app\.use\(\s*notFoundHandler\s*\)/.test(content);
@@ -925,126 +1566,98 @@ ${setupLines.join("\n")}
     }
   }
   if (modified) {
-    await import_fs_extra6.default.writeFile(appPath, content);
+    await import_fs_extra9.default.writeFile(appPath, content);
   }
   return importInserted && setupInserted;
 }
-async function injectAuthRoutes(projectRoot, srcDir) {
-  const appPath = import_path6.default.join(projectRoot, srcDir, "app.ts");
-  if (!await import_fs_extra6.default.pathExists(appPath)) {
+
+// src/handlers/rate-limiter.handler.ts
+var import_path11 = __toESM(require("path"));
+var import_fs_extra10 = __toESM(require("fs-extra"));
+async function injectRateLimiter(projectRoot, srcDir) {
+  const appPath = import_path11.default.join(projectRoot, srcDir, "app.ts");
+  if (!import_fs_extra10.default.existsSync(appPath)) {
     return false;
   }
-  let appContent = await import_fs_extra6.default.readFile(appPath, "utf-8");
-  const authHandlerImport = `import { toNodeHandler } from "better-auth/node";`;
-  const authImport = `import { auth } from "./lib/auth";`;
-  const routeIndexUserImport = `import userRoutes from "./user.routes";`;
-  const appUserImport = `import userRoutes from "./routes/user.routes";`;
-  let appModified = false;
-  const appendImport = (source, line) => {
-    if (source.includes(line)) {
-      return { source, inserted: true };
-    }
+  let content = await import_fs_extra10.default.readFile(appPath, "utf-8");
+  const rateLimiterImport = `import { rateLimiter } from "./middleware/rate-limiter";`;
+  const hasImport = content.includes(rateLimiterImport);
+  const hasUse = /app\.use\(\s*rateLimiter\s*\)/.test(content);
+  if (hasImport && hasUse) {
+    return true;
+  }
+  let modified = false;
+  if (!hasImport) {
     const importRegex = /^import .+ from .+;?\s*$/gm;
     let lastImportIndex = 0;
     let match;
-    while ((match = importRegex.exec(source)) !== null) {
+    while ((match = importRegex.exec(content)) !== null) {
       lastImportIndex = match.index + match[0].length;
     }
-    if (lastImportIndex <= 0) {
-      return { source, inserted: false };
-    }
-    return {
-      source: source.slice(0, lastImportIndex) + `
-${line}` + source.slice(lastImportIndex),
-      inserted: true
-    };
-  };
-  for (const importLine of [authHandlerImport, authImport]) {
-    const next = appendImport(appContent, importLine);
-    if (!next.inserted) {
-      return false;
-    }
-    if (next.source !== appContent) {
-      appContent = next.source;
-      appModified = true;
-    }
-  }
-  const hasAuthMount = /toNodeHandler\(\s*auth\s*\)/.test(appContent) && /\/api\/auth/.test(appContent);
-  if (!hasAuthMount) {
-    const authMountLine = "app.all(/^\\/api\\/auth(?:\\/.*)?$/, toNodeHandler(auth));\n";
-    const jsonIndex = appContent.search(/^\s*app\.use\(\s*express\.json\(\)\s*\);\s*$/m);
-    let insertionIndex = jsonIndex;
-    if (insertionIndex < 0) {
-      const healthIndex = appContent.search(/^\s*app\.get\(\s*["']\/health["']\s*,/m);
-      insertionIndex = healthIndex;
-    }
-    if (insertionIndex < 0) {
-      const exportMatch = appContent.match(/export default app;?\s*$/m);
-      insertionIndex = exportMatch?.index ?? -1;
-    }
-    if (insertionIndex < 0) {
-      return false;
+    if (lastImportIndex > 0) {
+      content = content.slice(0, lastImportIndex) + `
+${rateLimiterImport}` + content.slice(lastImportIndex);
+      modified = true;
     }
-    appContent = appContent.slice(0, insertionIndex) + authMountLine + appContent.slice(insertionIndex);
-    appModified = true;
   }
-  const routeIndexPath = import_path6.default.join(projectRoot, srcDir, "routes", "index.ts");
-  if (await import_fs_extra6.default.pathExists(routeIndexPath)) {
-    let routeContent = await import_fs_extra6.default.readFile(routeIndexPath, "utf-8");
-    let routeModified = false;
-    const userImportResult = appendImport(routeContent, routeIndexUserImport);
-    if (!userImportResult.inserted) {
-      return false;
-    }
-    if (userImportResult.source !== routeContent) {
-      routeContent = userImportResult.source;
-      routeModified = true;
-    }
-    const hasUserRoute = /rootRouter\.use\(\s*["']\/users["']\s*,\s*userRoutes\s*\)/.test(routeContent);
-    if (!hasUserRoute) {
-      const routeSetup = `
-// User routes
-rootRouter.use("/users", userRoutes);
-`;
-      const exportMatch = routeContent.match(/export default rootRouter;?\s*$/m);
-      if (!exportMatch || exportMatch.index === void 0) {
-        return false;
-      }
-      routeContent = routeContent.slice(0, exportMatch.index) + routeSetup + "\n" + routeContent.slice(exportMatch.index);
-      routeModified = true;
-    }
-    if (routeModified) {
-      await import_fs_extra6.default.writeFile(routeIndexPath, routeContent);
-    }
-  } else {
-    const hasUserRoute = /app\.use\(\s*["']\/api\/users["']\s*,\s*userRoutes\s*\)/.test(appContent);
-    if (!hasUserRoute) {
-      const exportMatch = appContent.match(/export default app;?\s*$/m);
-      if (!exportMatch || exportMatch.index === void 0) {
-        return false;
+  if (!hasUse) {
+    const jsonMiddleware = /^(\s*app\.use\(\s*express\.json\(\)\s*\);?\s*)$/m;
+    const jsonMatch = content.match(jsonMiddleware);
+    if (jsonMatch && jsonMatch.index !== void 0) {
+      const insertAt = jsonMatch.index + jsonMatch[0].length;
+      content = content.slice(0, insertAt) + `
+app.use(rateLimiter);` + content.slice(insertAt);
+      modified = true;
+    } else {
+      const routeMount = /^\s*app\.use\(\s*["']\/api["']/m;
+      const routeMatch = content.match(routeMount);
+      if (routeMatch && routeMatch.index !== void 0) {
+        content = content.slice(0, routeMatch.index) + `app.use(rateLimiter);
+` + content.slice(routeMatch.index);
+        modified = true;
       }
-      const routeSetup = `
-// User routes
-app.use("/api/users", userRoutes);
-`;
-      appContent = appContent.slice(0, exportMatch.index) + routeSetup + "\n" + appContent.slice(exportMatch.index);
-      appModified = true;
-    }
-    const userImportResult = appendImport(appContent, appUserImport);
-    if (!userImportResult.inserted) {
-      return false;
-    }
-    if (userImportResult.source !== appContent) {
-      appContent = userImportResult.source;
-      appModified = true;
     }
   }
-  if (appModified) {
-    await import_fs_extra6.default.writeFile(appPath, appContent);
+  if (modified) {
+    await import_fs_extra10.default.writeFile(appPath, content);
   }
   return true;
 }
-var add = async (moduleName) => {
+
+// src/commands/add.ts
+function resolvePackageManager(projectRoot) {
+  if (import_fs_extra11.default.existsSync(import_path12.default.join(projectRoot, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (import_fs_extra11.default.existsSync(import_path12.default.join(projectRoot, "bun.lockb")) || import_fs_extra11.default.existsSync(import_path12.default.join(projectRoot, "bun.lock"))) {
+    return "bun";
+  }
+  if (import_fs_extra11.default.existsSync(import_path12.default.join(projectRoot, "yarn.lock"))) {
+    return "yarn";
+  }
+  return "npm";
+}
+function getModuleDocsPath(moduleName) {
+  if (isDatabaseModule(moduleName)) {
+    return "database";
+  }
+  return moduleName;
+}
+async function hasEnvVariable(projectRoot, key) {
+  const envPath = import_path12.default.join(projectRoot, ".env");
+  if (!await import_fs_extra11.default.pathExists(envPath)) {
+    return false;
+  }
+  const content = await import_fs_extra11.default.readFile(envPath, "utf-8");
+  const pattern = new RegExp(`^${escapeRegex(key)}=`, "m");
+  return pattern.test(content);
+}
+async function isLikelyEmptyDirectory(cwd) {
+  const entries = await import_fs_extra11.default.readdir(cwd);
+  const ignored = /* @__PURE__ */ new Set([".ds_store", "thumbs.db"]);
+  return entries.filter((entry) => !ignored.has(entry.toLowerCase())).length === 0;
+}
+var add = async (moduleName, options = {}) => {
   const projectRoot = process.cwd();
   const projectConfig = await readZuroConfig(projectRoot);
   if (!projectConfig) {
@@ -1069,162 +1682,27 @@ var add = async (moduleName) => {
   let customSmtpVars;
   let usedDefaultSmtp = false;
   let mailerProvider = "smtp";
-  if (resolvedModuleName === "database") {
-    const variantResponse = await (0, import_prompts2.default)({
-      type: "select",
-      name: "variant",
-      message: "Which database dialect?",
-      choices: [
-        { title: "PostgreSQL", value: "database-pg" },
-        { title: "MySQL", value: "database-mysql" }
-      ]
-    });
-    if (!variantResponse.variant) {
-      console.log(import_chalk4.default.yellow("Operation cancelled."));
-      return;
-    }
-    resolvedModuleName = variantResponse.variant;
-  }
-  if (isDatabaseModule(resolvedModuleName)) {
-    const installedDialect = await detectInstalledDatabaseDialect(projectRoot, srcDir);
-    if (installedDialect && installedDialect !== resolvedModuleName) {
-      console.log(
-        import_chalk4.default.yellow(
-          `
-\u26A0 Existing database setup detected: ${databaseLabel(installedDialect)}.`
-        )
-      );
-      console.log(
-        import_chalk4.default.yellow(
-          `  Switching to ${databaseLabel(resolvedModuleName)} will overwrite db files and drizzle config.
-`
-        )
-      );
-      const switchResponse = await (0, import_prompts2.default)({
-        type: "confirm",
-        name: "proceed",
-        message: "Continue and switch database dialect?",
-        initial: false
-      });
-      if (!switchResponse.proceed) {
-        console.log(import_chalk4.default.yellow("Operation cancelled."));
-        return;
-      }
-      databaseBackupPath = await backupDatabaseFiles(projectRoot, srcDir);
-    }
-    const defaultUrl = DEFAULT_DATABASE_URLS[resolvedModuleName];
-    console.log(import_chalk4.default.dim(`  Tip: Leave blank to use ${defaultUrl}
-`));
-    const response = await (0, import_prompts2.default)({
-      type: "text",
-      name: "dbUrl",
-      message: "Database URL",
-      initial: ""
-    });
-    if (response.dbUrl === void 0) {
-      console.log(import_chalk4.default.yellow("Operation cancelled."));
-      return;
-    }
-    const enteredUrl = response.dbUrl?.trim() || "";
-    usedDefaultDbUrl = enteredUrl.length === 0;
-    customDbUrl = validateDatabaseUrl(enteredUrl || defaultUrl, resolvedModuleName);
+  let shouldInstallDocsForAuth = false;
+  if (resolvedModuleName === "database" || isDatabaseModule(resolvedModuleName)) {
+    const result = await promptDatabaseConfig(resolvedModuleName, projectRoot, srcDir);
+    if (!result) return;
+    resolvedModuleName = result.resolvedModuleName;
+    customDbUrl = result.customDbUrl;
+    usedDefaultDbUrl = result.usedDefaultDbUrl;
+    databaseBackupPath = result.databaseBackupPath;
   }
   if (resolvedModuleName === "mailer") {
-    const providerResponse = await (0, import_prompts2.default)({
-      type: "select",
-      name: "provider",
-      message: "Which email provider?",
-      choices: [
-        { title: "SMTP (Nodemailer)", description: "Gmail, Mailtrap, any SMTP server", value: "smtp" },
-        { title: "Resend", description: "API-based, easiest setup", value: "resend" }
-      ]
-    });
-    if (providerResponse.provider === void 0) {
-      console.log(import_chalk4.default.yellow("Operation cancelled."));
-      return;
-    }
-    mailerProvider = providerResponse.provider;
-    console.log(import_chalk4.default.dim("  Tip: Leave fields blank to use placeholder values and configure later\n"));
-    if (mailerProvider === "smtp") {
-      const smtpResponse = await (0, import_prompts2.default)([
-        {
-          type: "text",
-          name: "host",
-          message: "SMTP Host",
-          initial: ""
-        },
-        {
-          type: "text",
-          name: "port",
-          message: "SMTP Port",
-          initial: "587"
-        },
-        {
-          type: "text",
-          name: "user",
-          message: "SMTP User",
-          initial: ""
-        },
-        {
-          type: "password",
-          name: "pass",
-          message: "SMTP Password"
-        },
-        {
-          type: "text",
-          name: "from",
-          message: "Mail From address",
-          initial: ""
-        }
-      ]);
-      if (smtpResponse.host === void 0) {
-        console.log(import_chalk4.default.yellow("Operation cancelled."));
-        return;
-      }
-      const host = smtpResponse.host?.trim() || "";
-      const user = smtpResponse.user?.trim() || "";
-      const pass = smtpResponse.pass?.trim() || "";
-      const from = smtpResponse.from?.trim() || "";
-      const port = smtpResponse.port?.trim() || "587";
-      usedDefaultSmtp = !host && !user;
-      if (!usedDefaultSmtp) {
-        customSmtpVars = {
-          SMTP_HOST: host || "smtp.example.com",
-          SMTP_PORT: port,
-          SMTP_USER: user || "your-email@example.com",
-          SMTP_PASS: pass || "your-password",
-          MAIL_FROM: from || "noreply@example.com"
-        };
-      }
-    } else {
-      const resendResponse = await (0, import_prompts2.default)([
-        {
-          type: "text",
-          name: "apiKey",
-          message: "Resend API Key",
-          initial: ""
-        },
-        {
-          type: "text",
-          name: "from",
-          message: "Mail From address",
-          initial: ""
-        }
-      ]);
-      if (resendResponse.apiKey === void 0) {
-        console.log(import_chalk4.default.yellow("Operation cancelled."));
-        return;
-      }
-      const apiKey = resendResponse.apiKey?.trim() || "";
-      const from = resendResponse.from?.trim() || "";
-      usedDefaultSmtp = !apiKey;
-      if (!usedDefaultSmtp) {
-        customSmtpVars = {
-          RESEND_API_KEY: apiKey || "re_your_api_key",
-          MAIL_FROM: from || "onboarding@resend.dev"
-        };
-      }
-    }
+    const result = await promptMailerConfig();
+    if (!result) return;
+    mailerProvider = result.mailerProvider;
+    customSmtpVars = result.customSmtpVars;
+    usedDefaultSmtp = result.usedDefaultSmtp;
+  }
+  if (resolvedModuleName === "auth") {
+    const result = await promptAuthConfig(projectRoot, srcDir, options);
+    if (!result) return;
+    shouldInstallDocsForAuth = result.shouldInstallDocsForAuth;
+    authDatabaseDialect = result.authDatabaseDialect;
   }
   const pm = resolvePackageManager(projectRoot);
   const spinner = (0, import_ora2.default)(`Checking registry for ${resolvedModuleName}...`).start();
@@ -1240,7 +1718,7 @@ var add = async (moduleName) => {
       spinner.fail(`Module '${resolvedModuleName}' not found.`);
       return;
     }
-    spinner.succeed(`Found module: ${import_chalk4.default.cyan(resolvedModuleName)}`);
+    spinner.succeed(`Found module: ${import_chalk7.default.cyan(resolvedModuleName)}`);
     const moduleDeps = module2.moduleDependencies || [];
     currentStep = "module dependency resolution";
     await resolveDependencies(moduleDeps, projectRoot);
@@ -1262,9 +1740,6 @@ var add = async (moduleName) => {
     spinner.succeed("Dependencies installed");
     currentStep = "module scaffolding";
     spinner.start("Scaffolding files...");
-    if (resolvedModuleName === "auth") {
-      authDatabaseDialect = await detectInstalledDatabaseDialect(projectRoot, srcDir);
-    }
     for (const file of module2.files) {
       let fetchPath = file.path;
       let expectedSha256 = file.sha256;
@@ -1292,10 +1767,10 @@ var add = async (moduleName) => {
         );
       }
       const targetPath = resolveSafeTargetPath2(projectRoot, srcDir, file);
-      await import_fs_extra6.default.ensureDir(import_path6.default.dirname(targetPath));
-      await import_fs_extra6.default.writeFile(targetPath, content);
+      await import_fs_extra11.default.ensureDir(import_path12.default.dirname(targetPath));
+      await import_fs_extra11.default.writeFile(targetPath, content);
     }
-    const schemaExports = module2.files.map((file) => file.target.replace(/\\/g, "/")).filter((target) => /^db\/schema\/[^/]+\.ts$/.test(target)).map((target) => import_path6.default.posix.basename(target, ".ts")).filter((name) => name !== "index");
+    const schemaExports = module2.files.map((file) => file.target.replace(/\\/g, "/")).filter((target) => /^db\/schema\/[^/]+\.ts$/.test(target)).map((target) => import_path12.default.posix.basename(target, ".ts")).filter((name) => name !== "index");
     for (const schemaFileName of schemaExports) {
       await ensureSchemaExport(projectRoot, srcDir, schemaFileName);
     }
@@ -1308,6 +1783,16 @@ var add = async (moduleName) => {
       } else {
         spinner.warn("Could not configure routes automatically");
       }
+      const docsInstalled = await isDocsModuleInstalled(projectRoot, srcDir);
+      if (docsInstalled) {
+        spinner.start("Adding auth endpoints to API docs...");
+        const authDocsInjected = await injectAuthDocs(projectRoot, srcDir);
+        if (authDocsInjected) {
+          spinner.succeed("Auth endpoints added to API docs");
+        } else {
+          spinner.warn("Could not update API docs automatically");
+        }
+      }
     }
     if (resolvedModuleName === "error-handler") {
       spinner.start("Configuring error handler in app.ts...");
@@ -1318,6 +1803,34 @@ var add = async (moduleName) => {
         spinner.warn("Could not find app.ts - error handler needs manual setup");
       }
     }
+    if (resolvedModuleName === "rate-limiter") {
+      spinner.start("Configuring rate limiter in app.ts...");
+      const injected = await injectRateLimiter(projectRoot, srcDir);
+      if (injected) {
+        spinner.succeed("Rate limiter configured in app.ts");
+      } else {
+        spinner.warn("Could not find app.ts - rate limiter needs manual setup");
+      }
+    }
+    if (resolvedModuleName === "docs") {
+      spinner.start("Configuring docs routes...");
+      const injected = await injectDocsRoutes(projectRoot, srcDir);
+      if (injected) {
+        spinner.succeed("Docs routes configured");
+      } else {
+        spinner.warn("Could not configure docs routes automatically");
+      }
+      const authInstalled = await isAuthModuleInstalled(projectRoot, srcDir);
+      if (authInstalled) {
+        spinner.start("Adding auth endpoints to API docs...");
+        const authDocsInjected = await injectAuthDocs(projectRoot, srcDir);
+        if (authDocsInjected) {
+          spinner.succeed("Auth endpoints added to API docs");
+        } else {
+          spinner.warn("Could not update API docs automatically");
+        }
+      }
+    }
     let envConfigKey = resolvedModuleName;
     if (resolvedModuleName === "mailer" && mailerProvider === "resend") {
       envConfigKey = "mailer-resend";
@@ -1346,49 +1859,35 @@ var add = async (moduleName) => {
       await updateEnvSchema(projectRoot, srcDir, envConfig.schemaFields);
       spinner.succeed("Environment configured");
     }
-    console.log(import_chalk4.default.green(`
+    console.log(import_chalk7.default.green(`
 \u2714 ${resolvedModuleName} added successfully!
 `));
-    if (databaseBackupPath) {
-      console.log(import_chalk4.default.blue(`\u2139 Backup created at: ${databaseBackupPath}
-`));
-    }
     const docsPath = getModuleDocsPath(resolvedModuleName);
     const docsUrl = `https://zuro-cli.devbybriyan.com/docs/${docsPath}`;
-    console.log(import_chalk4.default.blue(`\u2139 Docs: ${docsUrl}`));
+    console.log(import_chalk7.default.blue(`\u2139 Docs: ${docsUrl}`));
     if (isDatabaseModule(resolvedModuleName)) {
-      if (usedDefaultDbUrl) {
-        console.log(import_chalk4.default.yellow("\u2139 Review DATABASE_URL in .env if your local DB config differs."));
-      }
-      const setupHint = getDatabaseSetupHint(
-        resolvedModuleName,
-        customDbUrl || DEFAULT_DATABASE_URLS[resolvedModuleName]
-      );
-      console.log(import_chalk4.default.yellow(`\u2139 Ensure DB exists: ${setupHint}`));
-      console.log(import_chalk4.default.yellow("\u2139 Run migrations: npx drizzle-kit generate && npx drizzle-kit migrate"));
+      printDatabaseHints(resolvedModuleName, customDbUrl, usedDefaultDbUrl, databaseBackupPath);
     }
     if (resolvedModuleName === "auth") {
-      if (generatedAuthSecret) {
-        console.log(import_chalk4.default.yellow("\u2139 BETTER_AUTH_SECRET was generated automatically."));
-      } else {
-        console.log(import_chalk4.default.yellow("\u2139 Review BETTER_AUTH_SECRET and BETTER_AUTH_URL in .env."));
-      }
-      console.log(import_chalk4.default.yellow("\u2139 Run migrations: npx drizzle-kit generate && npx drizzle-kit migrate"));
+      printAuthHints(generatedAuthSecret);
     }
     if (resolvedModuleName === "mailer") {
-      if (usedDefaultSmtp) {
-        console.log(import_chalk4.default.yellow("\u2139 Placeholder SMTP values added to .env \u2014 update them before sending emails."));
-      } else {
-        console.log(import_chalk4.default.yellow("\u2139 Review SMTP configuration in .env to ensure values are correct."));
-      }
+      printMailerHints(usedDefaultSmtp);
+    }
+    if (resolvedModuleName === "docs") {
+      printDocsHints();
+    }
+    if (resolvedModuleName === "auth" && shouldInstallDocsForAuth) {
+      console.log(import_chalk7.default.blue("\n\u2139 Installing API docs module..."));
+      await add("docs", { yes: true });
     }
   } catch (error) {
-    spinner.fail(import_chalk4.default.red(`Failed during ${currentStep}.`));
+    spinner.fail(import_chalk7.default.red(`Failed during ${currentStep}.`));
     const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error(import_chalk4.default.red(errorMessage));
+    console.error(import_chalk7.default.red(errorMessage));
     console.log(`
-${import_chalk4.default.bold("Retry:")}`);
-    console.log(import_chalk4.default.cyan(`  npx zuro-cli add ${resolvedModuleName}`));
+${import_chalk7.default.bold("Retry:")}`);
+    console.log(import_chalk7.default.cyan(`  npx zuro-cli add ${resolvedModuleName}`));
   }
 };
 
@@ -1396,6 +1895,6 @@ ${import_chalk4.default.bold("Retry:")}`);
 var program = new import_commander.Command();
 program.name("zuro-cli").description("Zuro CLI tool").version("0.0.1");
 program.command("init").description("Initialize a new Zuro project").action(init);
-program.command("add <module>").description("Add a module to your project").action(add);
+program.command("add <module>").description("Add a module to your project").action((module2, options) => add(module2, options));
 program.parse(process.argv);
 //# sourceMappingURL=index.js.map