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

package/dist/index.mjs

@@ -1,4 +1,20 @@
 #!/usr/bin/env node
+import {
+  ensureSchemaExport,
+  isDatabaseModule,
+  parseDatabaseDialect,
+  printDatabaseHints,
+  promptDatabaseConfig
+} from "./chunk-W36ZIR4Y.mjs";
+import {
+  injectDocsRoutes,
+  isDocsModuleInstalled,
+  printDocsHints
+} from "./chunk-YBAO5SKK.mjs";
+import {
+  appendImport,
+  escapeRegex
+} from "./chunk-VMOTWTER.mjs";
 
 // src/index.ts
 import { Command } from "commander";
@@ -9,6 +25,7 @@ import chalk2 from "chalk";
 import fs4 from "fs-extra";
 import path4 from "path";
 import prompts from "prompts";
+import { execSync } from "child_process";
 
 // src/utils/registry.ts
 import { createHash } from "crypto";
@@ -360,6 +377,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)" }
+    ]
   }
 };
 
@@ -473,6 +500,62 @@ bun.lockb
     await fs4.writeFile(prettierIgnorePath, ignoreContent);
   }
 }
+async function setupGitignore(targetDir) {
+  const gitignorePath = path4.join(targetDir, ".gitignore");
+  if (await fs4.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 fs4.writeFile(gitignorePath, gitignoreContent);
+}
+function tryGitInit(targetDir) {
+  try {
+    execSync("git rev-parse --is-inside-work-tree", {
+      cwd: targetDir,
+      stdio: "ignore"
+    });
+    return;
+  } catch {
+  }
+  try {
+    execSync("git init", { cwd: targetDir, stdio: "ignore" });
+    execSync("git add -A", { cwd: targetDir, stdio: "ignore" });
+    execSync('git commit -m "Initial commit from zuro-cli"', {
+      cwd: targetDir,
+      stdio: "ignore"
+    });
+  } catch {
+  }
+}
 async function init() {
   const cwd = process.cwd();
   const isExistingProject = await fs4.pathExists(path4.join(cwd, "package.json"));
@@ -624,8 +707,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(chalk2.green("Project initialized successfully!"));
     console.log(`
 ${chalk2.bold("Next steps:")}`);
@@ -649,10 +740,9 @@ ${chalk2.bold("Retry:")}`);
 }
 
 // src/commands/add.ts
-import prompts2 from "prompts";
 import ora2 from "ora";
-import path6 from "path";
-import fs6 from "fs-extra";
+import path10 from "path";
+import fs9 from "fs-extra";
 import { randomBytes } from "crypto";
 
 // src/utils/dependency.ts
@@ -667,7 +757,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) {
@@ -698,12 +790,8 @@ var resolveDependencies = async (moduleDependencies, cwd) => {
   }
 };
 
-// src/commands/add.ts
-import chalk4 from "chalk";
-var DEFAULT_DATABASE_URLS = {
-  "database-pg": "postgresql://postgres@localhost:5432/mydb",
-  "database-mysql": "mysql://root@localhost:3306/mydb"
-};
+// src/utils/paths.ts
+import path6 from "path";
 function resolveSafeTargetPath2(projectRoot, srcDir, file) {
   const targetPath = path6.resolve(projectRoot, srcDir, file.target);
   const normalizedRoot = path6.resolve(projectRoot);
@@ -712,202 +800,20 @@ function resolveSafeTargetPath2(projectRoot, srcDir, file) {
   }
   return targetPath;
 }
-function resolvePackageManager(projectRoot) {
-  if (fs6.existsSync(path6.join(projectRoot, "pnpm-lock.yaml"))) {
-    return "pnpm";
-  }
-  if (fs6.existsSync(path6.join(projectRoot, "bun.lockb")) || fs6.existsSync(path6.join(projectRoot, "bun.lock"))) {
-    return "bun";
-  }
-  if (fs6.existsSync(path6.join(projectRoot, "yarn.lock"))) {
-    return "yarn";
-  }
-  return "npm";
-}
-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 = path6.join(projectRoot, srcDir, "db", "index.ts");
-  if (!fs6.existsSync(dbIndexPath)) {
-    return null;
-  }
-  const content = await fs6.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 = path6.join(projectRoot, ".zuro", "backups", `database-${timestamp}`);
-  const candidates = [
-    path6.join(projectRoot, srcDir, "db", "index.ts"),
-    path6.join(projectRoot, "drizzle.config.ts")
-  ];
-  let copied = false;
-  for (const filePath of candidates) {
-    if (!fs6.existsSync(filePath)) {
-      continue;
-    }
-    const relativePath = path6.relative(projectRoot, filePath);
-    const backupPath = path6.join(backupRoot, relativePath);
-    await fs6.ensureDir(path6.dirname(backupPath));
-    await fs6.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>;"`;
-  }
-}
-function getModuleDocsPath(moduleName) {
-  if (isDatabaseModule(moduleName)) {
-    return "database";
-  }
-  return moduleName;
-}
-function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-async function hasEnvVariable(projectRoot, key) {
-  const envPath = path6.join(projectRoot, ".env");
-  if (!await fs6.pathExists(envPath)) {
-    return false;
-  }
-  const content = await fs6.readFile(envPath, "utf-8");
-  const pattern = new RegExp(`^${escapeRegex(key)}=`, "m");
-  return pattern.test(content);
-}
-async function isLikelyEmptyDirectory(cwd) {
-  const entries = await fs6.readdir(cwd);
-  const ignored = /* @__PURE__ */ new Set([".ds_store", "thumbs.db"]);
-  return entries.filter((entry) => !ignored.has(entry.toLowerCase())).length === 0;
-}
-async function ensureSchemaExport(projectRoot, srcDir, schemaFileName) {
-  const schemaIndexPath = path6.join(projectRoot, srcDir, "db", "schema", "index.ts");
-  if (!await fs6.pathExists(schemaIndexPath)) {
-    return;
-  }
-  const exportLine = `export * from "./${schemaFileName}";`;
-  const content = await fs6.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 fs6.writeFile(schemaIndexPath, next);
-}
-async function injectErrorHandler(projectRoot, srcDir) {
-  const appPath = path6.join(projectRoot, srcDir, "app.ts");
-  if (!fs6.existsSync(appPath)) {
-    return false;
-  }
-  let content = await fs6.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);
-  const hasErrorUse = /app\.use\(\s*errorHandler\s*\)/.test(content);
-  let modified = false;
-  let importInserted = hasErrorImport;
-  if (!hasErrorImport) {
-    const importRegex = /^import .+ from .+;?\s*$/gm;
-    let lastImportIndex = 0;
-    let match;
-    while ((match = importRegex.exec(content)) !== null) {
-      lastImportIndex = match.index + match[0].length;
-    }
-    if (lastImportIndex > 0) {
-      content = content.slice(0, lastImportIndex) + `
-${errorImport}` + content.slice(lastImportIndex);
-      modified = true;
-      importInserted = true;
-    }
-  }
-  let setupInserted = hasNotFoundUse && hasErrorUse;
-  if (!setupInserted) {
-    const setupLines = [];
-    if (!hasNotFoundUse) {
-      setupLines.push("app.use(notFoundHandler);");
-    }
-    if (!hasErrorUse) {
-      setupLines.push("app.use(errorHandler);");
-    }
-    const errorSetup = `
-// Error handling (must be last)
-${setupLines.join("\n")}
-`;
-    const exportMatch = content.match(/export default app;?\s*$/m);
-    if (exportMatch && exportMatch.index !== void 0) {
-      content = content.slice(0, exportMatch.index) + errorSetup + "\n" + content.slice(exportMatch.index);
-      modified = true;
-      setupInserted = true;
-    }
-  }
-  if (modified) {
-    await fs6.writeFile(appPath, content);
-  }
-  return importInserted && setupInserted;
+
+// src/commands/add.ts
+import chalk6 from "chalk";
+
+// src/handlers/auth.handler.ts
+import path7 from "path";
+import fs6 from "fs-extra";
+import prompts2 from "prompts";
+import chalk4 from "chalk";
+async function isAuthModuleInstalled(projectRoot, srcDir) {
+  return await fs6.pathExists(path7.join(projectRoot, srcDir, "lib", "auth.ts"));
 }
 async function injectAuthRoutes(projectRoot, srcDir) {
-  const appPath = path6.join(projectRoot, srcDir, "app.ts");
+  const appPath = path7.join(projectRoot, srcDir, "app.ts");
   if (!await fs6.pathExists(appPath)) {
     return false;
   }
@@ -917,25 +823,6 @@ async function injectAuthRoutes(projectRoot, srcDir) {
   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 };
-    }
-    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
-    };
-  };
   for (const importLine of [authHandlerImport, authImport]) {
     const next = appendImport(appContent, importLine);
     if (!next.inserted) {
@@ -965,7 +852,7 @@ ${line}` + source.slice(lastImportIndex),
     appContent = appContent.slice(0, insertionIndex) + authMountLine + appContent.slice(insertionIndex);
     appModified = true;
   }
-  const routeIndexPath = path6.join(projectRoot, srcDir, "routes", "index.ts");
+  const routeIndexPath = path7.join(projectRoot, srcDir, "routes", "index.ts");
   if (await fs6.pathExists(routeIndexPath)) {
     let routeContent = await fs6.readFile(routeIndexPath, "utf-8");
     let routeModified = false;
@@ -1021,7 +908,399 @@ app.use("/api/users", userRoutes);
   }
   return true;
 }
-var add = async (moduleName) => {
+async function injectAuthDocs(projectRoot, srcDir) {
+  const openApiPath = path7.join(projectRoot, srcDir, "lib", "openapi.ts");
+  if (!await fs6.pathExists(openApiPath)) {
+    return false;
+  }
+  const authMarker = "// ZURO_AUTH_DOCS";
+  let content = await fs6.readFile(openApiPath, "utf-8");
+  if (content.includes(authMarker)) {
+    return true;
+  }
+  const moduleDocsEndMarker = "// ZURO_DOCS_MODULES_END";
+  if (!content.includes(moduleDocsEndMarker)) {
+    return false;
+  }
+  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 fs6.writeFile(openApiPath, content);
+  return true;
+}
+async function promptAuthConfig(projectRoot, srcDir, options) {
+  const { isDocsModuleInstalled: isDocsModuleInstalled2 } = await import("./docs.handler-JL3ZIVJQ.mjs");
+  const docsInstalled = await isDocsModuleInstalled2(projectRoot, srcDir);
+  let shouldInstallDocsForAuth = false;
+  if (!docsInstalled) {
+    if (options.yes) {
+      shouldInstallDocsForAuth = true;
+    } else {
+      const docsResponse = await prompts2({
+        type: "confirm",
+        name: "installDocs",
+        message: "Install API docs module (Scalar + OpenAPI) too?",
+        initial: true
+      });
+      if (docsResponse.installDocs === void 0) {
+        console.log(chalk4.yellow("Operation cancelled."));
+        return null;
+      }
+      shouldInstallDocsForAuth = docsResponse.installDocs;
+    }
+  }
+  const { detectInstalledDatabaseDialect } = await import("./database.handler-D7EVXRJX.mjs");
+  const authDatabaseDialect = await detectInstalledDatabaseDialect(projectRoot, srcDir);
+  return { shouldInstallDocsForAuth, authDatabaseDialect };
+}
+function printAuthHints(generatedAuthSecret) {
+  if (generatedAuthSecret) {
+    console.log(chalk4.yellow("\u2139 BETTER_AUTH_SECRET was generated automatically."));
+  } else {
+    console.log(chalk4.yellow("\u2139 Review BETTER_AUTH_SECRET and BETTER_AUTH_URL in .env."));
+  }
+  console.log(chalk4.yellow("\u2139 Run migrations: npx drizzle-kit generate && npx drizzle-kit migrate"));
+}
+
+// src/handlers/mailer.handler.ts
+import prompts3 from "prompts";
+import chalk5 from "chalk";
+async function promptMailerConfig() {
+  const providerResponse = await prompts3({
+    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(chalk5.yellow("Operation cancelled."));
+    return null;
+  }
+  const mailerProvider = providerResponse.provider;
+  let customSmtpVars;
+  let usedDefaultSmtp = false;
+  console.log(chalk5.dim("  Tip: Leave fields blank to use placeholder values and configure later\n"));
+  if (mailerProvider === "smtp") {
+    const smtpResponse = await prompts3([
+      {
+        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(chalk5.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 prompts3([
+      {
+        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(chalk5.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"
+      };
+    }
+  }
+  return { mailerProvider, customSmtpVars, usedDefaultSmtp };
+}
+function printMailerHints(usedDefaultSmtp) {
+  if (usedDefaultSmtp) {
+    console.log(chalk5.yellow("\u2139 Placeholder SMTP values added to .env \u2014 update them before sending emails."));
+  } else {
+    console.log(chalk5.yellow("\u2139 Review SMTP configuration in .env to ensure values are correct."));
+  }
+}
+
+// src/handlers/error-handler.handler.ts
+import path8 from "path";
+import fs7 from "fs-extra";
+async function injectErrorHandler(projectRoot, srcDir) {
+  const appPath = path8.join(projectRoot, srcDir, "app.ts");
+  if (!fs7.existsSync(appPath)) {
+    return false;
+  }
+  let content = await fs7.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);
+  const hasErrorUse = /app\.use\(\s*errorHandler\s*\)/.test(content);
+  let modified = false;
+  let importInserted = hasErrorImport;
+  if (!hasErrorImport) {
+    const importRegex = /^import .+ from .+;?\s*$/gm;
+    let lastImportIndex = 0;
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      lastImportIndex = match.index + match[0].length;
+    }
+    if (lastImportIndex > 0) {
+      content = content.slice(0, lastImportIndex) + `
+${errorImport}` + content.slice(lastImportIndex);
+      modified = true;
+      importInserted = true;
+    }
+  }
+  let setupInserted = hasNotFoundUse && hasErrorUse;
+  if (!setupInserted) {
+    const setupLines = [];
+    if (!hasNotFoundUse) {
+      setupLines.push("app.use(notFoundHandler);");
+    }
+    if (!hasErrorUse) {
+      setupLines.push("app.use(errorHandler);");
+    }
+    const errorSetup = `
+// Error handling (must be last)
+${setupLines.join("\n")}
+`;
+    const exportMatch = content.match(/export default app;?\s*$/m);
+    if (exportMatch && exportMatch.index !== void 0) {
+      content = content.slice(0, exportMatch.index) + errorSetup + "\n" + content.slice(exportMatch.index);
+      modified = true;
+      setupInserted = true;
+    }
+  }
+  if (modified) {
+    await fs7.writeFile(appPath, content);
+  }
+  return importInserted && setupInserted;
+}
+
+// src/handlers/rate-limiter.handler.ts
+import path9 from "path";
+import fs8 from "fs-extra";
+async function injectRateLimiter(projectRoot, srcDir) {
+  const appPath = path9.join(projectRoot, srcDir, "app.ts");
+  if (!fs8.existsSync(appPath)) {
+    return false;
+  }
+  let content = await fs8.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(content)) !== null) {
+      lastImportIndex = match.index + match[0].length;
+    }
+    if (lastImportIndex > 0) {
+      content = content.slice(0, lastImportIndex) + `
+${rateLimiterImport}` + content.slice(lastImportIndex);
+      modified = true;
+    }
+  }
+  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;
+      }
+    }
+  }
+  if (modified) {
+    await fs8.writeFile(appPath, content);
+  }
+  return true;
+}
+
+// src/commands/add.ts
+function resolvePackageManager(projectRoot) {
+  if (fs9.existsSync(path10.join(projectRoot, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (fs9.existsSync(path10.join(projectRoot, "bun.lockb")) || fs9.existsSync(path10.join(projectRoot, "bun.lock"))) {
+    return "bun";
+  }
+  if (fs9.existsSync(path10.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 = path10.join(projectRoot, ".env");
+  if (!await fs9.pathExists(envPath)) {
+    return false;
+  }
+  const content = await fs9.readFile(envPath, "utf-8");
+  const pattern = new RegExp(`^${escapeRegex(key)}=`, "m");
+  return pattern.test(content);
+}
+async function isLikelyEmptyDirectory(cwd) {
+  const entries = await fs9.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) {
@@ -1046,162 +1325,27 @@ var add = async (moduleName) => {
   let customSmtpVars;
   let usedDefaultSmtp = false;
   let mailerProvider = "smtp";
-  if (resolvedModuleName === "database") {
-    const variantResponse = await prompts2({
-      type: "select",
-      name: "variant",
-      message: "Which database dialect?",
-      choices: [
-        { title: "PostgreSQL", value: "database-pg" },
-        { title: "MySQL", value: "database-mysql" }
-      ]
-    });
-    if (!variantResponse.variant) {
-      console.log(chalk4.yellow("Operation cancelled."));
-      return;
-    }
-    resolvedModuleName = variantResponse.variant;
-  }
-  if (isDatabaseModule(resolvedModuleName)) {
-    const installedDialect = await detectInstalledDatabaseDialect(projectRoot, srcDir);
-    if (installedDialect && installedDialect !== resolvedModuleName) {
-      console.log(
-        chalk4.yellow(
-          `
-\u26A0 Existing database setup detected: ${databaseLabel(installedDialect)}.`
-        )
-      );
-      console.log(
-        chalk4.yellow(
-          `  Switching to ${databaseLabel(resolvedModuleName)} will overwrite db files and drizzle config.
-`
-        )
-      );
-      const switchResponse = await prompts2({
-        type: "confirm",
-        name: "proceed",
-        message: "Continue and switch database dialect?",
-        initial: false
-      });
-      if (!switchResponse.proceed) {
-        console.log(chalk4.yellow("Operation cancelled."));
-        return;
-      }
-      databaseBackupPath = await backupDatabaseFiles(projectRoot, srcDir);
-    }
-    const defaultUrl = DEFAULT_DATABASE_URLS[resolvedModuleName];
-    console.log(chalk4.dim(`  Tip: Leave blank to use ${defaultUrl}
-`));
-    const response = await prompts2({
-      type: "text",
-      name: "dbUrl",
-      message: "Database URL",
-      initial: ""
-    });
-    if (response.dbUrl === void 0) {
-      console.log(chalk4.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 prompts2({
-      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(chalk4.yellow("Operation cancelled."));
-      return;
-    }
-    mailerProvider = providerResponse.provider;
-    console.log(chalk4.dim("  Tip: Leave fields blank to use placeholder values and configure later\n"));
-    if (mailerProvider === "smtp") {
-      const smtpResponse = await prompts2([
-        {
-          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(chalk4.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 prompts2([
-        {
-          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(chalk4.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 = ora2(`Checking registry for ${resolvedModuleName}...`).start();
@@ -1217,7 +1361,7 @@ var add = async (moduleName) => {
       spinner.fail(`Module '${resolvedModuleName}' not found.`);
       return;
     }
-    spinner.succeed(`Found module: ${chalk4.cyan(resolvedModuleName)}`);
+    spinner.succeed(`Found module: ${chalk6.cyan(resolvedModuleName)}`);
     const moduleDeps = module.moduleDependencies || [];
     currentStep = "module dependency resolution";
     await resolveDependencies(moduleDeps, projectRoot);
@@ -1239,9 +1383,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 module.files) {
       let fetchPath = file.path;
       let expectedSha256 = file.sha256;
@@ -1269,10 +1410,10 @@ var add = async (moduleName) => {
         );
       }
       const targetPath = resolveSafeTargetPath2(projectRoot, srcDir, file);
-      await fs6.ensureDir(path6.dirname(targetPath));
-      await fs6.writeFile(targetPath, content);
+      await fs9.ensureDir(path10.dirname(targetPath));
+      await fs9.writeFile(targetPath, content);
     }
-    const schemaExports = module.files.map((file) => file.target.replace(/\\/g, "/")).filter((target) => /^db\/schema\/[^/]+\.ts$/.test(target)).map((target) => path6.posix.basename(target, ".ts")).filter((name) => name !== "index");
+    const schemaExports = module.files.map((file) => file.target.replace(/\\/g, "/")).filter((target) => /^db\/schema\/[^/]+\.ts$/.test(target)).map((target) => path10.posix.basename(target, ".ts")).filter((name) => name !== "index");
     for (const schemaFileName of schemaExports) {
       await ensureSchemaExport(projectRoot, srcDir, schemaFileName);
     }
@@ -1285,6 +1426,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...");
@@ -1295,6 +1446,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";
@@ -1323,49 +1502,35 @@ var add = async (moduleName) => {
       await updateEnvSchema(projectRoot, srcDir, envConfig.schemaFields);
       spinner.succeed("Environment configured");
     }
-    console.log(chalk4.green(`
+    console.log(chalk6.green(`
 \u2714 ${resolvedModuleName} added successfully!
 `));
-    if (databaseBackupPath) {
-      console.log(chalk4.blue(`\u2139 Backup created at: ${databaseBackupPath}
-`));
-    }
     const docsPath = getModuleDocsPath(resolvedModuleName);
     const docsUrl = `https://zuro-cli.devbybriyan.com/docs/${docsPath}`;
-    console.log(chalk4.blue(`\u2139 Docs: ${docsUrl}`));
+    console.log(chalk6.blue(`\u2139 Docs: ${docsUrl}`));
     if (isDatabaseModule(resolvedModuleName)) {
-      if (usedDefaultDbUrl) {
-        console.log(chalk4.yellow("\u2139 Review DATABASE_URL in .env if your local DB config differs."));
-      }
-      const setupHint = getDatabaseSetupHint(
-        resolvedModuleName,
-        customDbUrl || DEFAULT_DATABASE_URLS[resolvedModuleName]
-      );
-      console.log(chalk4.yellow(`\u2139 Ensure DB exists: ${setupHint}`));
-      console.log(chalk4.yellow("\u2139 Run migrations: npx drizzle-kit generate && npx drizzle-kit migrate"));
+      printDatabaseHints(resolvedModuleName, customDbUrl, usedDefaultDbUrl, databaseBackupPath);
     }
     if (resolvedModuleName === "auth") {
-      if (generatedAuthSecret) {
-        console.log(chalk4.yellow("\u2139 BETTER_AUTH_SECRET was generated automatically."));
-      } else {
-        console.log(chalk4.yellow("\u2139 Review BETTER_AUTH_SECRET and BETTER_AUTH_URL in .env."));
-      }
-      console.log(chalk4.yellow("\u2139 Run migrations: npx drizzle-kit generate && npx drizzle-kit migrate"));
+      printAuthHints(generatedAuthSecret);
     }
     if (resolvedModuleName === "mailer") {
-      if (usedDefaultSmtp) {
-        console.log(chalk4.yellow("\u2139 Placeholder SMTP values added to .env \u2014 update them before sending emails."));
-      } else {
-        console.log(chalk4.yellow("\u2139 Review SMTP configuration in .env to ensure values are correct."));
-      }
+      printMailerHints(usedDefaultSmtp);
+    }
+    if (resolvedModuleName === "docs") {
+      printDocsHints();
+    }
+    if (resolvedModuleName === "auth" && shouldInstallDocsForAuth) {
+      console.log(chalk6.blue("\n\u2139 Installing API docs module..."));
+      await add("docs", { yes: true });
     }
   } catch (error) {
-    spinner.fail(chalk4.red(`Failed during ${currentStep}.`));
+    spinner.fail(chalk6.red(`Failed during ${currentStep}.`));
     const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error(chalk4.red(errorMessage));
+    console.error(chalk6.red(errorMessage));
     console.log(`
-${chalk4.bold("Retry:")}`);
-    console.log(chalk4.cyan(`  npx zuro-cli add ${resolvedModuleName}`));
+${chalk6.bold("Retry:")}`);
+    console.log(chalk6.cyan(`  npx zuro-cli add ${resolvedModuleName}`));
   }
 };
 
@@ -1373,6 +1538,6 @@ ${chalk4.bold("Retry:")}`);
 var program = new 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((module, options) => add(module, options));
 program.parse(process.argv);
 //# sourceMappingURL=index.mjs.map