authverse 1.1.4 → 1.1.5

package/dist/index.js

@@ -32,7 +32,7 @@ var getPackageManager = () => {
   if (ua.includes("bun")) return "bun";
   if (ua.includes("pnpm")) return "pnpm";
   if (ua.includes("yarn")) return "yarn";
-  return "npm";
+  return "pnpm";
 };
 var pm = getPackageManager();
 var packageManager = (pkg, dev = false) => {
@@ -62,14 +62,47 @@ var runCommand = (cmd) => {
 };
 
 // script/authUi.ts
-var authUiRun = async ({ folder }) => {
+var shadcnComponents = [
+  "button.tsx",
+  "card.tsx",
+  "field.tsx",
+  "input.tsx",
+  "label.tsx",
+  "separator.tsx",
+  "sonner.tsx"
+];
+var authUiRun = async ({
+  folder,
+  packageJson: packageJson2,
+  cmd
+}) => {
   try {
-    console.log(chalk.yellow("\n Installing shadcn ui Components\n"));
-    runCommand("shadcn@latest add button sonner card field input");
-    packageManager("react-hook-form @hookform/resolvers");
+    const projectDir = process.cwd();
+    const shadcnPath = path.join(projectDir, folder, "components", "ui");
+    const shadcnConfigPath = path.join(projectDir, "components.json");
+    if (!fs.existsSync(shadcnPath) || !fs.existsSync(shadcnConfigPath)) {
+      console.log(chalk.yellow("\n Installing shadcn ui Components\n"));
+      if (cmd == true) {
+        runCommand("shadcn@latest init --base-color zinc --yes");
+        runCommand("shadcn@latest add button sonner card field input");
+      } else {
+        runCommand("shadcn@latest add button sonner card field input");
+      }
+    }
+    const shadcnFiles = fs.readdirSync(shadcnPath);
+    const missingComponents = shadcnComponents.filter(
+      (component) => !shadcnFiles.includes(component)
+    );
+    if (missingComponents.length > 0) {
+      console.log(chalk.yellow("\n Installing shadcn ui Components\n"));
+      const install = missingComponents.map((components) => components.split(".")[0]).join(" ");
+      runCommand(`shadcn@latest add ${install}`);
+    }
+    if (!packageJson2.dependencies?.["react-hook-form"] || !packageJson2.dependencies?.["@hookform/resolvers"] || !packageJson2.dependencies?.["zod"]) {
+      packageManager("react-hook-form @hookform/resolvers zod");
+    }
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = path.dirname(__filename);
-    const projectDir = process.cwd();
     const componentPath = path.resolve(__dirname, "./template/components");
     const destinationPath = path.join(
       projectDir,
@@ -150,14 +183,14 @@ ${layoutContent}`;
 
 // script/prisma.ts
 import inquirer from "inquirer";
-var prismaRun = async ({ authUi, database }) => {
+var prismaRun = async ({ authUi, database, cmd }) => {
   try {
     const projectDir = process.cwd();
     const __filename = fileURLToPath2(import.meta.url);
     const __dirname = path2.dirname(__filename);
     const packageJsonPath = path2.join(projectDir, "package.json");
     const packageJson2 = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
-    if (!packageJson2.devDependencies?.prisma && !packageJson2.dependencies?.["@prisma/client"]) {
+    if (!packageJson2.devDependencies?.prisma || !packageJson2.dependencies?.["@prisma/client"]) {
       console.log(chalk2.cyan("\n\u2699\uFE0F  Initializing Prisma...\n"));
       if (database !== "Mongodb") {
         packageManager("prisma", true);
@@ -197,7 +230,7 @@ var prismaRun = async ({ authUi, database }) => {
     } else {
       const schemaPath = path2.join(prismaDir, "schema.prisma");
       const schemaContent = fs2.readFileSync(schemaPath, "utf-8");
-      if (!schemaContent.includes("User") && !schemaContent.includes("Session") && !schemaContent.includes("Account") && !schemaContent.includes("Verification")) {
+      if (!schemaContent.includes("User") || !schemaContent.includes("Session") || !schemaContent.includes("Account") || !schemaContent.includes("Verification")) {
         const templatePath = path2.resolve(
           __dirname,
           `./template/prisma/${database}/schema.prisma_copy`
@@ -230,16 +263,48 @@ BETTER_AUTH_URL=http://localhost:3000
     }
     const authPath = path2.join(libPath, "auth.ts");
     const authClientPath = path2.join(libPath, "auth-client.ts");
-    if (fs2.existsSync(authPath) || fs2.existsSync(authClientPath)) {
-      const answers = await inquirer.prompt([
-        {
-          type: "confirm",
-          name: "overwrite",
-          message: "Do you want to overwrite existing auth lib/auth.ts or lib/auth-client.ts",
-          default: false
+    if (cmd !== true) {
+      if (fs2.existsSync(authPath) || fs2.existsSync(authClientPath)) {
+        const answers = await inquirer.prompt([
+          {
+            type: "confirm",
+            name: "overwrite",
+            message: "Do you want to overwrite existing auth lib/auth.ts or lib/auth-client.ts",
+            default: false
+          }
+        ]);
+        if (answers.overwrite) {
+          const authTemplatePath = path2.resolve(
+            __dirname,
+            `./template/lib/${database}/auth.ts`
+          );
+          const authDestinationPath = path2.join(libPath, "auth.ts");
+          fs2.copyFileSync(authTemplatePath, authDestinationPath);
+          const authClientTemplatePath = path2.resolve(
+            __dirname,
+            "./template/lib/auth-client.ts"
+          );
+          const authClientDestinationPath = path2.join(
+            libPath,
+            "auth-client.ts"
+          );
+          fs2.copyFileSync(authClientTemplatePath, authClientDestinationPath);
+          if (srcFolder === "src") {
+            const authContextPath = path2.join(libPath, "auth.ts");
+            const authContextContent = fs2.readFileSync(
+              authContextPath,
+              "utf-8"
+            );
+            fs2.writeFileSync(
+              authContextPath,
+              authContextContent.replace(
+                'import { PrismaClient } from "@/generated/prisma/client";',
+                'import { PrismaClient } from "../../generated/prisma/client";'
+              )
+            );
+          }
         }
-      ]);
-      if (answers.overwrite) {
+      } else {
         const authTemplatePath = path2.resolve(
           __dirname,
           `./template/lib/${database}/auth.ts`
@@ -264,30 +329,6 @@ BETTER_AUTH_URL=http://localhost:3000
           );
         }
       }
-    } else {
-      const authTemplatePath = path2.resolve(
-        __dirname,
-        `./template/lib/${database}/auth.ts`
-      );
-      const authDestinationPath = path2.join(libPath, "auth.ts");
-      fs2.copyFileSync(authTemplatePath, authDestinationPath);
-      const authClientTemplatePath = path2.resolve(
-        __dirname,
-        "./template/lib/auth-client.ts"
-      );
-      const authClientDestinationPath = path2.join(libPath, "auth-client.ts");
-      fs2.copyFileSync(authClientTemplatePath, authClientDestinationPath);
-      if (srcFolder === "src") {
-        const authContextPath = path2.join(libPath, "auth.ts");
-        const authContextContent = fs2.readFileSync(authContextPath, "utf-8");
-        fs2.writeFileSync(
-          authContextPath,
-          authContextContent.replace(
-            'import { PrismaClient } from "@/generated/prisma/client";',
-            'import { PrismaClient } from "../../generated/prisma/client";'
-          )
-        );
-      }
     }
     const routeTemplatePath = path2.resolve(
       __dirname,
@@ -327,7 +368,11 @@ BETTER_AUTH_URL=http://localhost:3000
       );
     }
     if (authUi) {
-      await authUiRun({ folder: srcFolder });
+      await authUiRun({
+        folder: srcFolder,
+        packageJson: packageJson2,
+        cmd
+      });
     } else {
       console.log(
         chalk2.green(
@@ -346,7 +391,7 @@ import path3 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import fs3 from "fs";
 import inquirer2 from "inquirer";
-var drizzleRun = async (authUi) => {
+var drizzleRun = async ({ authUi, cmd }) => {
   try {
     const projectDir = process.cwd();
     const packageJsonPath = path3.join(projectDir, "package.json");
@@ -494,7 +539,11 @@ BETTER_AUTH_URL=http://localhost:3000
     const proxyDestinationPath = path3.join(proxyDestinationDir, "proxy.ts");
     fs3.copyFileSync(proxyTemplatePath, proxyDestinationPath);
     if (authUi) {
-      await authUiRun({ folder: srcFolder });
+      await authUiRun({
+        folder: srcFolder,
+        packageJson: packageJson2,
+        cmd
+      });
     } else {
       console.log(
         chalk3.green(
@@ -507,10 +556,6 @@ BETTER_AUTH_URL=http://localhost:3000
   }
 };
 
-// cli/init.ts
-import path7 from "path";
-import fs7 from "fs";
-
 // script/prismaRunTanstackState.ts
 import chalk5 from "chalk";
 import path5 from "path";
@@ -522,14 +567,46 @@ import chalk4 from "chalk";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import path4 from "path";
 import fs4 from "fs";
-var authUiTanstackState = async () => {
+var shadcnComponents2 = [
+  "button.tsx",
+  "card.tsx",
+  "field.tsx",
+  "input.tsx",
+  "label.tsx",
+  "separator.tsx",
+  "sonner.tsx"
+];
+var authUiTanstackState = async ({
+  packageJson: packageJson2,
+  cmd
+}) => {
   try {
-    console.log(chalk4.yellow("\n Installing shadcn ui Components\n"));
-    runCommand("shadcn@latest add button sonner card field input");
-    packageManager("@tanstack/react-form");
+    const projectDir = process.cwd();
+    const shadcnPath = path4.join(projectDir, "src", "components", "ui");
+    const shadcnConfigPath = path4.join(projectDir, "components.json");
+    if (!fs4.existsSync(shadcnPath) || !fs4.existsSync(shadcnConfigPath)) {
+      console.log(chalk4.yellow("\n Installing shadcn ui Components\n"));
+      if (cmd == true) {
+        runCommand("shadcn@latest init --base-color zinc --yes");
+        runCommand("shadcn@latest add button sonner card field input");
+      } else {
+        runCommand("shadcn@latest add button sonner card field input");
+      }
+    }
+    const shadcnFiles = fs4.readdirSync(shadcnPath);
+    const missingComponents = shadcnComponents2.filter(
+      (component) => !shadcnFiles.includes(component)
+    );
+    if (missingComponents.length > 0) {
+      console.log(chalk4.yellow("\n Installing shadcn ui Components\n"));
+      const install = missingComponents.map((components) => components.split(".")[0]).join(" ");
+      runCommand(`shadcn@latest add ${install}`);
+    }
+    if (!packageJson2.dependencies?.["@tanstack/react-form"] || !packageJson2.dependencies?.["zod"]) {
+      packageManager("@tanstack/react-form zod");
+    }
     const __filename = fileURLToPath4(import.meta.url);
     const __dirname = path4.dirname(__filename);
-    const projectDir = process.cwd();
     const srcPath = path4.join(projectDir, "src");
     const componentPath = path4.resolve(
       __dirname,
@@ -591,7 +668,8 @@ ${rootContent}`;
 // script/prismaRunTanstackState.ts
 var prismaRunTanstackState = async ({
   authUi,
-  database
+  database,
+  cmd
 }) => {
   try {
     const projectDir = process.cwd();
@@ -599,7 +677,7 @@ var prismaRunTanstackState = async ({
     const __dirname = path5.dirname(__filename);
     const packageJsonPath = path5.join(projectDir, "package.json");
     const packageJson2 = JSON.parse(fs5.readFileSync(packageJsonPath, "utf-8"));
-    if (!packageJson2.devDependencies?.prisma && !packageJson2.dependencies?.["@prisma/client"]) {
+    if (!packageJson2.devDependencies?.prisma || !packageJson2.dependencies?.["@prisma/client"]) {
       console.log(chalk5.cyan("\n\u2699\uFE0F  Initializing Prisma...\n"));
       if (database !== "Mongodb") {
         packageManager("prisma", true);
@@ -639,7 +717,7 @@ var prismaRunTanstackState = async ({
     } else {
       const schemaPath = path5.join(prismaDir, "schema.prisma");
       const schemaContent = fs5.readFileSync(schemaPath, "utf-8");
-      if (!schemaContent.includes("User") && !schemaContent.includes("Session") && !schemaContent.includes("Account") && !schemaContent.includes("Verification")) {
+      if (!schemaContent.includes("User") || !schemaContent.includes("Session") || !schemaContent.includes("Account") || !schemaContent.includes("Verification")) {
         const templatePath = path5.resolve(
           __dirname,
           `./template/prisma/${database}/schema.prisma_copy`
@@ -708,7 +786,10 @@ BETTER_AUTH_URL=http://localhost:3000
     const apiDestinationPath = path5.join(fileRouteDestinationPath, "$.ts");
     fs5.copyFileSync(fileRouteTemplatePath, apiDestinationPath);
     if (authUi) {
-      await authUiTanstackState();
+      await authUiTanstackState({
+        packageJson: packageJson2,
+        cmd
+      });
     } else {
       console.log(
         chalk5.green(
@@ -726,7 +807,10 @@ import chalk6 from "chalk";
 import path6 from "path";
 import fs6 from "fs";
 import { fileURLToPath as fileURLToPath6 } from "url";
-var drizzleRunTanstackState = async (authUi) => {
+var drizzleRunTanstackState = async ({
+  authUi,
+  cmd
+}) => {
   try {
     const projectDir = process.cwd();
     const packageJsonPath = path6.join(projectDir, "package.json");
@@ -819,7 +903,10 @@ BETTER_AUTH_URL=http://localhost:3000
     const apiDestinationPath = path6.join(fileRouteDestinationPath, "$.ts");
     fs6.copyFileSync(fileRouteTemplatePath, apiDestinationPath);
     if (authUi) {
-      await authUiTanstackState();
+      await authUiTanstackState({
+        packageJson: packageJson2,
+        cmd
+      });
     } else {
       console.log(
         chalk6.green(
@@ -832,15 +919,47 @@ BETTER_AUTH_URL=http://localhost:3000
   }
 };
 
+// utils/framework.ts
+import path7 from "path";
+import fs7 from "fs";
+var getFramework = async () => {
+  const projectDir = process.cwd();
+  if (!fs7.existsSync(path7.join(projectDir, "package.json"))) {
+    return {
+      framework: null,
+      error: "No framework detected"
+    };
+  }
+  const packageJson2 = JSON.parse(
+    fs7.readFileSync(path7.join(projectDir, "package.json"), "utf-8")
+  );
+  const hasNext = packageJson2?.dependencies?.["next"] || packageJson2?.devDependencies?.["next"];
+  if (hasNext) {
+    return {
+      framework: "Next js",
+      error: null
+    };
+  }
+  const hasTanstackState = packageJson2?.devDependencies?.["@tanstack/devtools-vite"] || packageJson2?.devDependencies?.["@tanstack/eslint-config"] || packageJson2?.devDependencies?.["@tanstack/react-start"];
+  if (hasTanstackState) {
+    return {
+      framework: "tanstack state",
+      error: null
+    };
+  }
+  return {
+    framework: null,
+    error: "No framework supported authverse"
+  };
+};
+
 // cli/init.ts
+import chalk7 from "chalk";
 var initAnswer = async () => {
-  const projectDir = process.cwd();
-  const packageJsonPath = path7.join(projectDir, "package.json");
-  let framework = "tanstack state";
-  if (fs7.existsSync(packageJsonPath)) {
-    const packageJson2 = JSON.parse(fs7.readFileSync(packageJsonPath, "utf-8"));
-    const hasNext = packageJson2?.dependencies?.["next"] || packageJson2?.devDependencies?.["next"];
-    framework = hasNext ? "Next js" : "tanstack state";
+  const { framework, error } = await getFramework();
+  if (error) {
+    console.log(chalk7.red(error));
+    return;
   }
   console.log(`\u2714 Detected framework: ${framework}`);
   const answers = await inquirer3.prompt([
@@ -867,20 +986,28 @@ var initAnswer = async () => {
   if (framework === "Next js" && answers.orm === "Prisma") {
     await prismaRun({
       authUi: answers.authUi,
-      database: answers.database
+      database: answers.database,
+      cmd: false
     });
   }
   if (framework === "Next js" && answers.orm === "Drizzle") {
-    await drizzleRun(answers.authUi);
+    await drizzleRun({
+      authUi: answers.authUi,
+      cmd: false
+    });
   }
   if (framework === "tanstack state" && answers.orm === "Prisma") {
     await prismaRunTanstackState({
       authUi: answers.authUi,
-      database: answers.database
+      database: answers.database,
+      cmd: false
     });
   }
   if (framework === "tanstack state" && answers.orm === "Drizzle") {
-    await drizzleRunTanstackState(answers.authUi);
+    await drizzleRunTanstackState({
+      authUi: answers.authUi,
+      cmd: false
+    });
   }
 };
 
@@ -888,10 +1015,10 @@ var initAnswer = async () => {
 import { readFileSync } from "fs";
 
 // cli/provider.ts
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 
 // script/googleRun.ts
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 import fs8 from "fs";
 import path8 from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
@@ -904,16 +1031,16 @@ var googleRun = async () => {
     const folder = fs8.existsSync(srcPath) ? "src" : "";
     const authFilePath = path8.join(projectDir, folder, "lib", "auth.ts");
     if (!fs8.existsSync(authFilePath)) {
-      console.log(chalk7.red("\u274C auth.ts file not found"));
+      console.log(chalk8.red("\u274C auth.ts file not found"));
       return;
     }
     let content = fs8.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(chalk7.red("betterAuth({}) block not found"));
+      console.log(chalk8.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("google:")) {
-      console.log(chalk7.yellow("Google provider already exists"));
+      console.log(chalk8.yellow("Google provider already exists"));
       return;
     }
     const googleProviderEntry = `
@@ -936,7 +1063,7 @@ var googleRun = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(chalk7.red("Failed to parse socialProviders block"));
+        console.log(chalk8.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + googleProviderEntry + "\n  " + content.slice(insertPos);
@@ -944,7 +1071,7 @@ var googleRun = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          chalk7.red(
+          chalk8.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -993,14 +1120,14 @@ GOOGLE_CLIENT_SECRET=
     if (fs8.existsSync(componentTemplate)) {
       fs8.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(chalk7.green("Google provider added & merged successfully"));
+    console.log(chalk8.green("Google provider added & merged successfully"));
   } catch (error) {
-    console.log(chalk7.red("googleRun error:"), error);
+    console.log(chalk8.red("googleRun error:"), error);
   }
 };
 
 // script/githubRun.ts
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 import fs9 from "fs";
 import path9 from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
@@ -1013,16 +1140,16 @@ var githubRun = async () => {
     const folder = fs9.existsSync(srcPath) ? "src" : "";
     const authFilePath = path9.join(projectDir, folder, "lib", "auth.ts");
     if (!fs9.existsSync(authFilePath)) {
-      console.log(chalk8.red("auth.ts file not found"));
+      console.log(chalk9.red("auth.ts file not found"));
       return;
     }
     let content = fs9.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(chalk8.red("betterAuth({}) block not found"));
+      console.log(chalk9.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("github:")) {
-      console.log(chalk8.yellow("GitHub provider already exists"));
+      console.log(chalk9.yellow("GitHub provider already exists"));
       return;
     }
     const githubProviderEntry = `
@@ -1045,7 +1172,7 @@ var githubRun = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(chalk8.red("Failed to parse socialProviders block"));
+        console.log(chalk9.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + githubProviderEntry + "\n  " + content.slice(insertPos);
@@ -1053,7 +1180,7 @@ var githubRun = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          chalk8.red(
+          chalk9.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -1102,18 +1229,14 @@ GITHUB_CLIENT_SECRET=
     if (fs9.existsSync(componentTemplate)) {
       fs9.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(chalk8.green("GitHub provider added & merged successfully"));
+    console.log(chalk9.green("GitHub provider added & merged successfully"));
   } catch (error) {
-    console.log(chalk8.red("githubRun error:"), error);
+    console.log(chalk9.red("githubRun error:"), error);
   }
 };
 
-// cli/provider.ts
-import path12 from "path";
-import fs12 from "fs";
-
 // script/googleRunTanstackState.ts
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 import fs10 from "fs";
 import path10 from "path";
 import { fileURLToPath as fileURLToPath9 } from "url";
@@ -1125,16 +1248,16 @@ var googleRunTanstackState = async () => {
     const srcPath = path10.join(projectDir, "src");
     const authFilePath = path10.join(srcPath, "lib", "auth.ts");
     if (!fs10.existsSync(authFilePath)) {
-      console.log(chalk9.red("auth.ts file not found"));
+      console.log(chalk10.red("auth.ts file not found"));
       return;
     }
     let content = fs10.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(chalk9.red("betterAuth({}) block not found"));
+      console.log(chalk10.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("google:")) {
-      console.log(chalk9.yellow("Google provider already exists"));
+      console.log(chalk10.yellow("Google provider already exists"));
       return;
     }
     const googleProviderEntry = `
@@ -1157,7 +1280,7 @@ var googleRunTanstackState = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(chalk9.red("Failed to parse socialProviders block"));
+        console.log(chalk10.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + googleProviderEntry + "\n  " + content.slice(insertPos);
@@ -1165,7 +1288,7 @@ var googleRunTanstackState = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          chalk9.red(
+          chalk10.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -1209,14 +1332,14 @@ GOOGLE_CLIENT_SECRET=
     if (fs10.existsSync(componentTemplate)) {
       fs10.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(chalk9.green("Google provider added & merged successfully"));
+    console.log(chalk10.green("Google provider added & merged successfully"));
   } catch (error) {
-    console.log(chalk9.red("googleRunTanstackState error:"), error);
+    console.log(chalk10.red("googleRunTanstackState error:"), error);
   }
 };
 
 // script/githubRunTanstackState.ts
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 import fs11 from "fs";
 import path11 from "path";
 import { fileURLToPath as fileURLToPath10 } from "url";
@@ -1228,16 +1351,16 @@ var githubRunTanstackState = async () => {
     const srcPath = path11.join(projectDir, "src");
     const authFilePath = path11.join(srcPath, "lib", "auth.ts");
     if (!fs11.existsSync(authFilePath)) {
-      console.log(chalk10.red("auth.ts file not found"));
+      console.log(chalk11.red("auth.ts file not found"));
       return;
     }
     let content = fs11.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(chalk10.red("betterAuth({}) block not found"));
+      console.log(chalk11.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("github:")) {
-      console.log(chalk10.yellow("Github provider already exists"));
+      console.log(chalk11.yellow("Github provider already exists"));
       return;
     }
     const githubProviderEntry = `
@@ -1260,7 +1383,7 @@ var githubRunTanstackState = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(chalk10.red("Failed to parse socialProviders block"));
+        console.log(chalk11.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + githubProviderEntry + "\n  " + content.slice(insertPos);
@@ -1268,7 +1391,7 @@ var githubRunTanstackState = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          chalk10.red(
+          chalk11.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -1312,22 +1435,19 @@ GITHUB_CLIENT_SECRET=
     if (fs11.existsSync(componentTemplate)) {
       fs11.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(chalk10.green("Github provider added & merged successfully"));
+    console.log(chalk11.green("Github provider added & merged successfully"));
   } catch (error) {
-    console.log(chalk10.red("githubRunTanstackState error:"), error);
+    console.log(chalk11.red("githubRunTanstackState error:"), error);
   }
 };
 
 // cli/provider.ts
 var providers = async ({ provider }) => {
   try {
-    const projectDir = process.cwd();
-    const packageJsonPath = path12.join(projectDir, "package.json");
-    let framework = "tanstack state";
-    if (fs12.existsSync(packageJsonPath)) {
-      const packageJson2 = JSON.parse(fs12.readFileSync(packageJsonPath, "utf-8"));
-      const hasNext = packageJson2?.dependencies?.["next"] || packageJson2?.devDependencies?.["next"];
-      framework = hasNext ? "Next js" : "tanstack state";
+    const { framework, error } = await getFramework();
+    if (error) {
+      console.log(chalk12.red(error));
+      return;
     }
     if (framework === "Next js" && provider == "google") {
       await googleRun();
@@ -1340,45 +1460,96 @@ var providers = async ({ provider }) => {
       await githubRunTanstackState();
     }
   } catch (error) {
-    console.log(chalk11.red("Error adding provider:"), error);
+    console.log(chalk12.red("Error adding provider:"), error);
   }
 };
 
-// cli/forget.ts
-import path22 from "path";
-import fs22 from "fs";
-
 // script/forgetNext.ts
-import chalk18 from "chalk";
-import path20 from "path";
+import chalk20 from "chalk";
+import path19 from "path";
 import { fileURLToPath as fileURLToPath17 } from "url";
-import fs20 from "fs";
+import fs19 from "fs";
 
 // cli/email.ts
-import path19 from "path";
-import fs19 from "fs";
+import path18 from "path";
+import fs18 from "fs";
 import inquirer4 from "inquirer";
 
 // email/gmailRun.ts
-import chalk12 from "chalk";
-import path13 from "path";
-import fs13 from "fs";
+import chalk13 from "chalk";
+import path12 from "path";
+import fs12 from "fs";
 import { fileURLToPath as fileURLToPath11 } from "url";
 var gmailRun = async () => {
+  try {
+    const projectDir = process.cwd();
+    const packageJsonPath = path12.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(fs12.readFileSync(packageJsonPath, "utf-8"));
+    const srcFolder = fs12.existsSync(path12.join(projectDir, "src")) ? "src" : "";
+    const __filename = fileURLToPath11(import.meta.url);
+    const __dirname = path12.dirname(__filename);
+    if (!packageJson2.dependencies?.nodemailer || !packageJson2.devDependencies?.["@types/nodemailer"]) {
+      console.log(chalk13.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
+      packageManager("nodemailer");
+      packageManager("@types/nodemailer", true);
+    }
+    if (!packageJson2.dependencies?.["@react-email/components"]) {
+      console.log(chalk13.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
+      packageManager("@react-email/components");
+    }
+    const envPath = path12.join(projectDir, ".env");
+    const envContent = fs12.readFileSync(envPath, "utf8");
+    if (!envContent.includes("GMAIL_HOST") && !envContent.includes("GMAIL_PORT") && !envContent.includes("GMAIL_SERVICE") && !envContent.includes("GMAIL_MAIL") && !envContent.includes("GMAIL_NAME") && !envContent.includes("GMAIL_PASSWORD")) {
+      fs12.appendFileSync(envPath, `
+
+# Gmail API Key for sending emails`);
+      fs12.appendFileSync(envPath, `
+GMAIL_HOST=`);
+      fs12.appendFileSync(envPath, `
+GMAIL_PORT=`);
+      fs12.appendFileSync(envPath, `
+GMAIL_SERVICE=`);
+      fs12.appendFileSync(envPath, `
+GMAIL_MAIL=`);
+      fs12.appendFileSync(envPath, `
+GMAIL_NAME=`);
+      fs12.appendFileSync(envPath, `
+GMAIL_PASSWORD=`);
+    }
+    const templatePath = path12.resolve(
+      __dirname,
+      "./template/email/emailGmail.ts"
+    );
+    const libPath = path12.join(projectDir, srcFolder, "lib");
+    if (!fs12.existsSync(libPath)) {
+      fs12.mkdirSync(libPath, { recursive: true });
+    }
+    const libDestinationPath = path12.join(libPath, "email.ts");
+    fs12.copyFileSync(templatePath, libDestinationPath);
+  } catch (error) {
+    console.log(chalk13.red(error));
+  }
+};
+
+// email/gmailRunTanstackState.ts
+import chalk14 from "chalk";
+import path13 from "path";
+import fs13 from "fs";
+import { fileURLToPath as fileURLToPath12 } from "url";
+var gmailRunTanstackState = async () => {
   try {
     const projectDir = process.cwd();
     const packageJsonPath = path13.join(projectDir, "package.json");
     const packageJson2 = JSON.parse(fs13.readFileSync(packageJsonPath, "utf-8"));
-    const srcFolder = fs13.existsSync(path13.join(projectDir, "src")) ? "src" : "";
-    const __filename = fileURLToPath11(import.meta.url);
+    const __filename = fileURLToPath12(import.meta.url);
     const __dirname = path13.dirname(__filename);
     if (!packageJson2.dependencies?.nodemailer || !packageJson2.devDependencies?.["@types/nodemailer"]) {
-      console.log(chalk12.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
+      console.log(chalk14.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
       packageManager("nodemailer");
       packageManager("@types/nodemailer", true);
     }
     if (!packageJson2.dependencies?.["@react-email/components"]) {
-      console.log(chalk12.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
+      console.log(chalk14.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
       packageManager("@react-email/components");
     }
     const envPath = path13.join(projectDir, ".env");
@@ -1404,92 +1575,92 @@ GMAIL_PASSWORD=`);
       __dirname,
       "./template/email/emailGmail.ts"
     );
-    const libPath = path13.join(projectDir, srcFolder, "lib");
+    const libPath = path13.join(projectDir, "src", "lib");
     if (!fs13.existsSync(libPath)) {
       fs13.mkdirSync(libPath, { recursive: true });
     }
     const libDestinationPath = path13.join(libPath, "email.ts");
     fs13.copyFileSync(templatePath, libDestinationPath);
   } catch (error) {
-    console.log(chalk12.red(error));
+    console.log(chalk14.red(error));
   }
 };
 
-// email/gmailRunTanstackState.ts
-import chalk13 from "chalk";
+// email/awsSesRun.ts
+import chalk15 from "chalk";
 import path14 from "path";
 import fs14 from "fs";
-import { fileURLToPath as fileURLToPath12 } from "url";
-var gmailRunTanstackState = async () => {
+import { fileURLToPath as fileURLToPath13 } from "url";
+var awsSesRun = async () => {
   try {
     const projectDir = process.cwd();
     const packageJsonPath = path14.join(projectDir, "package.json");
     const packageJson2 = JSON.parse(fs14.readFileSync(packageJsonPath, "utf-8"));
-    const __filename = fileURLToPath12(import.meta.url);
+    const srcFolder = fs14.existsSync(path14.join(projectDir, "src")) ? "src" : "";
+    const __filename = fileURLToPath13(import.meta.url);
     const __dirname = path14.dirname(__filename);
     if (!packageJson2.dependencies?.nodemailer || !packageJson2.devDependencies?.["@types/nodemailer"]) {
-      console.log(chalk13.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
+      console.log(chalk15.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
       packageManager("nodemailer");
       packageManager("@types/nodemailer", true);
     }
     if (!packageJson2.dependencies?.["@react-email/components"]) {
-      console.log(chalk13.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
+      console.log(chalk15.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
       packageManager("@react-email/components");
     }
     const envPath = path14.join(projectDir, ".env");
     const envContent = fs14.readFileSync(envPath, "utf8");
-    if (!envContent.includes("GMAIL_HOST") && !envContent.includes("GMAIL_PORT") && !envContent.includes("GMAIL_SERVICE") && !envContent.includes("GMAIL_MAIL") && !envContent.includes("GMAIL_NAME") && !envContent.includes("GMAIL_PASSWORD")) {
+    if (!envContent.includes("AWS_SES_HOST") && !envContent.includes("AWS_SES_PORT") && !envContent.includes("AWS_SES_SERVICE") && !envContent.includes("AWS_SES_USER") && !envContent.includes("AWS_SES_PASS") && !envContent.includes("AWS_SES_FROM")) {
       fs14.appendFileSync(envPath, `
 
-# Gmail API Key for sending emails`);
+# AWS SES API Key for sending emails`);
       fs14.appendFileSync(envPath, `
-GMAIL_HOST=`);
+AWS_SES_HOST=`);
       fs14.appendFileSync(envPath, `
-GMAIL_PORT=`);
+AWS_SES_PORT=`);
       fs14.appendFileSync(envPath, `
-GMAIL_SERVICE=`);
+AWS_SES_SERVICE=`);
       fs14.appendFileSync(envPath, `
-GMAIL_MAIL=`);
+AWS_SES_USER=`);
       fs14.appendFileSync(envPath, `
-GMAIL_NAME=`);
+AWS_SES_PASS=`);
       fs14.appendFileSync(envPath, `
-GMAIL_PASSWORD=`);
+AWS_SES_FROM=`);
     }
     const templatePath = path14.resolve(
       __dirname,
-      "./template/email/emailGmail.ts"
+      "./template/email/emailAwsSes.ts"
     );
-    const libPath = path14.join(projectDir, "src", "lib");
+    const libPath = path14.join(projectDir, srcFolder, "lib");
     if (!fs14.existsSync(libPath)) {
       fs14.mkdirSync(libPath, { recursive: true });
     }
     const libDestinationPath = path14.join(libPath, "email.ts");
     fs14.copyFileSync(templatePath, libDestinationPath);
   } catch (error) {
-    console.log(chalk13.red(error));
+    console.log(chalk15.red(error));
   }
 };
 
-// email/awsSesRun.ts
-import chalk14 from "chalk";
+// email/awsSesRunTanstackState.ts
+import chalk16 from "chalk";
 import path15 from "path";
 import fs15 from "fs";
-import { fileURLToPath as fileURLToPath13 } from "url";
-var awsSesRun = async () => {
+import { fileURLToPath as fileURLToPath14 } from "url";
+var awsSesRunTanstackState = async () => {
   try {
     const projectDir = process.cwd();
     const packageJsonPath = path15.join(projectDir, "package.json");
     const packageJson2 = JSON.parse(fs15.readFileSync(packageJsonPath, "utf-8"));
-    const srcFolder = fs15.existsSync(path15.join(projectDir, "src")) ? "src" : "";
-    const __filename = fileURLToPath13(import.meta.url);
+    const __filename = fileURLToPath14(import.meta.url);
     const __dirname = path15.dirname(__filename);
     if (!packageJson2.dependencies?.nodemailer || !packageJson2.devDependencies?.["@types/nodemailer"]) {
-      console.log(chalk14.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
+      console.log(chalk16.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
       packageManager("nodemailer");
       packageManager("@types/nodemailer", true);
     }
     if (!packageJson2.dependencies?.["@react-email/components"]) {
-      console.log(chalk14.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
+      console.log(chalk16.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
       packageManager("@react-email/components");
     }
     const envPath = path15.join(projectDir, ".env");
@@ -1515,91 +1686,84 @@ AWS_SES_FROM=`);
       __dirname,
       "./template/email/emailAwsSes.ts"
     );
-    const libPath = path15.join(projectDir, srcFolder, "lib");
+    const libPath = path15.join(projectDir, "src", "lib");
     if (!fs15.existsSync(libPath)) {
       fs15.mkdirSync(libPath, { recursive: true });
     }
     const libDestinationPath = path15.join(libPath, "email.ts");
     fs15.copyFileSync(templatePath, libDestinationPath);
   } catch (error) {
-    console.log(chalk14.red(error));
+    console.log(chalk16.red(error));
   }
 };
 
-// email/awsSesRunTanstackState.ts
-import chalk15 from "chalk";
+// email/resendRun.ts
+import chalk17 from "chalk";
 import path16 from "path";
 import fs16 from "fs";
-import { fileURLToPath as fileURLToPath14 } from "url";
-var awsSesRunTanstackState = async () => {
+import { fileURLToPath as fileURLToPath15 } from "url";
+var resendRun = async () => {
   try {
     const projectDir = process.cwd();
     const packageJsonPath = path16.join(projectDir, "package.json");
     const packageJson2 = JSON.parse(fs16.readFileSync(packageJsonPath, "utf-8"));
-    const __filename = fileURLToPath14(import.meta.url);
+    const srcFolder = fs16.existsSync(path16.join(projectDir, "src")) ? "src" : "";
+    const __filename = fileURLToPath15(import.meta.url);
     const __dirname = path16.dirname(__filename);
-    if (!packageJson2.dependencies?.nodemailer || !packageJson2.devDependencies?.["@types/nodemailer"]) {
-      console.log(chalk15.cyan("\n\u2699\uFE0F  Installing nodemailer...\n"));
-      packageManager("nodemailer");
-      packageManager("@types/nodemailer", true);
+    if (!packageJson2.dependencies?.resend) {
+      console.log(chalk17.cyan("\n\u2699\uFE0F Installing Resend...\n"));
+      packageManager("resend");
     }
     if (!packageJson2.dependencies?.["@react-email/components"]) {
-      console.log(chalk15.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
+      console.log(chalk17.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
       packageManager("@react-email/components");
     }
     const envPath = path16.join(projectDir, ".env");
     const envContent = fs16.readFileSync(envPath, "utf8");
-    if (!envContent.includes("AWS_SES_HOST") && !envContent.includes("AWS_SES_PORT") && !envContent.includes("AWS_SES_SERVICE") && !envContent.includes("AWS_SES_USER") && !envContent.includes("AWS_SES_PASS") && !envContent.includes("AWS_SES_FROM")) {
+    if (!envContent.includes("RESEND_API_KEY") && !envContent.includes("EMAIL_SENDER_NAME") && !envContent.includes("EMAIL_SENDER_ADDRESS")) {
       fs16.appendFileSync(envPath, `
 
-# AWS SES API Key for sending emails`);
-      fs16.appendFileSync(envPath, `
-AWS_SES_HOST=`);
-      fs16.appendFileSync(envPath, `
-AWS_SES_PORT=`);
-      fs16.appendFileSync(envPath, `
-AWS_SES_SERVICE=`);
+# Resend API Key for sending emails`);
       fs16.appendFileSync(envPath, `
-AWS_SES_USER=`);
+RESEND_API_KEY=`);
       fs16.appendFileSync(envPath, `
-AWS_SES_PASS=`);
+EMAIL_SENDER_NAME=Your Name`);
       fs16.appendFileSync(envPath, `
-AWS_SES_FROM=`);
+EMAIL_SENDER_ADDRESS=`);
     }
     const templatePath = path16.resolve(
       __dirname,
-      "./template/email/emailAwsSes.ts"
+      "./template/email/emailResend.ts"
     );
-    const libPath = path16.join(projectDir, "src", "lib");
+    const libPath = path16.join(projectDir, srcFolder, "lib");
     if (!fs16.existsSync(libPath)) {
       fs16.mkdirSync(libPath, { recursive: true });
     }
     const libDestinationPath = path16.join(libPath, "email.ts");
     fs16.copyFileSync(templatePath, libDestinationPath);
   } catch (error) {
-    console.log(chalk15.red(error));
+    console.log(chalk17.red(error));
   }
 };
 
-// email/resendRun.ts
-import chalk16 from "chalk";
+// email/resendRunTanstackState.ts
+import chalk18 from "chalk";
 import path17 from "path";
 import fs17 from "fs";
-import { fileURLToPath as fileURLToPath15 } from "url";
-var resendRun = async () => {
+import { fileURLToPath as fileURLToPath16 } from "url";
+var resendRunTanstackState = async () => {
   try {
     const projectDir = process.cwd();
     const packageJsonPath = path17.join(projectDir, "package.json");
     const packageJson2 = JSON.parse(fs17.readFileSync(packageJsonPath, "utf-8"));
-    const srcFolder = fs17.existsSync(path17.join(projectDir, "src")) ? "src" : "";
-    const __filename = fileURLToPath15(import.meta.url);
+    const __filename = fileURLToPath16(import.meta.url);
     const __dirname = path17.dirname(__filename);
     if (!packageJson2.dependencies?.resend) {
-      console.log(chalk16.cyan("\n\u2699\uFE0F Installing Resend...\n"));
+      console.log(chalk18.cyan("\n\u2699\uFE0F Installing Resend...\n"));
       packageManager("resend");
     }
     if (!packageJson2.dependencies?.["@react-email/components"]) {
-      console.log(chalk16.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
+      console.log(chalk18.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
       packageManager("@react-email/components");
     }
     const envPath = path17.join(projectDir, ".env");
@@ -1619,79 +1783,30 @@ EMAIL_SENDER_ADDRESS=`);
       __dirname,
       "./template/email/emailResend.ts"
     );
-    const libPath = path17.join(projectDir, srcFolder, "lib");
+    const libPath = path17.join(projectDir, "src", "lib");
     if (!fs17.existsSync(libPath)) {
       fs17.mkdirSync(libPath, { recursive: true });
     }
     const libDestinationPath = path17.join(libPath, "email.ts");
     fs17.copyFileSync(templatePath, libDestinationPath);
   } catch (error) {
-    console.log(chalk16.red(error));
-  }
-};
-
-// email/resendRunTanstackState.ts
-import chalk17 from "chalk";
-import path18 from "path";
-import fs18 from "fs";
-import { fileURLToPath as fileURLToPath16 } from "url";
-var resendRunTanstackState = async () => {
-  try {
-    const projectDir = process.cwd();
-    const packageJsonPath = path18.join(projectDir, "package.json");
-    const packageJson2 = JSON.parse(fs18.readFileSync(packageJsonPath, "utf-8"));
-    const __filename = fileURLToPath16(import.meta.url);
-    const __dirname = path18.dirname(__filename);
-    if (!packageJson2.dependencies?.resend) {
-      console.log(chalk17.cyan("\n\u2699\uFE0F Installing Resend...\n"));
-      packageManager("resend");
-    }
-    if (!packageJson2.dependencies?.["@react-email/components"]) {
-      console.log(chalk17.cyan("\n\u2699\uFE0F  Installing @react-email/components...\n"));
-      packageManager("@react-email/components");
-    }
-    const envPath = path18.join(projectDir, ".env");
-    const envContent = fs18.readFileSync(envPath, "utf8");
-    if (!envContent.includes("RESEND_API_KEY") && !envContent.includes("EMAIL_SENDER_NAME") && !envContent.includes("EMAIL_SENDER_ADDRESS")) {
-      fs18.appendFileSync(envPath, `
-
-# Resend API Key for sending emails`);
-      fs18.appendFileSync(envPath, `
-RESEND_API_KEY=`);
-      fs18.appendFileSync(envPath, `
-EMAIL_SENDER_NAME=Your Name`);
-      fs18.appendFileSync(envPath, `
-EMAIL_SENDER_ADDRESS=`);
-    }
-    const templatePath = path18.resolve(
-      __dirname,
-      "./template/email/emailResend.ts"
-    );
-    const libPath = path18.join(projectDir, "src", "lib");
-    if (!fs18.existsSync(libPath)) {
-      fs18.mkdirSync(libPath, { recursive: true });
-    }
-    const libDestinationPath = path18.join(libPath, "email.ts");
-    fs18.copyFileSync(templatePath, libDestinationPath);
-  } catch (error) {
-    console.log(chalk17.red(error));
+    console.log(chalk18.red(error));
   }
 };
 
 // cli/email.ts
+import chalk19 from "chalk";
 var email = async () => {
   const projectDir = process.cwd();
-  const packageJsonPath = path19.join(projectDir, "package.json");
-  let framework = "tanstack state";
-  if (fs19.existsSync(packageJsonPath)) {
-    const packageJson2 = JSON.parse(fs19.readFileSync(packageJsonPath, "utf-8"));
-    const hasNext = packageJson2?.dependencies?.["next"] || packageJson2?.devDependencies?.["next"];
-    framework = hasNext ? "Next js" : "tanstack state";
+  const { framework, error } = await getFramework();
+  if (error) {
+    console.log(chalk19.red(error));
+    return;
   }
   if (framework === "Next js") {
-    const srcFolder = fs19.existsSync(path19.join(projectDir, "src")) ? "src" : "";
-    const emailPath = path19.join(projectDir, srcFolder, "lib", "email.ts");
-    if (fs19.existsSync(emailPath)) {
+    const srcFolder = fs18.existsSync(path18.join(projectDir, "src")) ? "src" : "";
+    const emailPath = path18.join(projectDir, srcFolder, "lib", "email.ts");
+    if (fs18.existsSync(emailPath)) {
       const answers2 = await inquirer4.prompt([
         {
           type: "confirm",
@@ -1706,12 +1821,12 @@ var email = async () => {
     }
   }
   if (framework === "tanstack state") {
-    const srcFolderTanstackState = path19.join(projectDir, "src");
-    const libPathTanstackState = path19.join(
+    const srcFolderTanstackState = path18.join(projectDir, "src");
+    const libPathTanstackState = path18.join(
       srcFolderTanstackState,
       "lib/email.ts"
     );
-    if (fs19.existsSync(libPathTanstackState)) {
+    if (fs18.existsSync(libPathTanstackState)) {
       const answers2 = await inquirer4.prompt([
         {
           type: "confirm",
@@ -1758,19 +1873,19 @@ var forgetNext = async () => {
   try {
     const projectDir = process.cwd();
     const __filename = fileURLToPath17(import.meta.url);
-    const __dirname = path20.dirname(__filename);
-    const srcPath = path20.join(projectDir, "src");
-    const folder = fs20.existsSync(srcPath) ? "src" : "";
-    const emailFilePath = path20.join(projectDir, folder, "lib", "email.ts");
-    if (!fs20.existsSync(emailFilePath)) {
+    const __dirname = path19.dirname(__filename);
+    const srcPath = path19.join(projectDir, "src");
+    const folder = fs19.existsSync(srcPath) ? "src" : "";
+    const emailFilePath = path19.join(projectDir, folder, "lib", "email.ts");
+    if (!fs19.existsSync(emailFilePath)) {
       await email();
     }
-    const authFilePath = path20.join(projectDir, folder, "lib", "auth.ts");
-    if (!fs20.existsSync(authFilePath)) {
-      console.log(chalk18.red("auth.ts file not found."));
+    const authFilePath = path19.join(projectDir, folder, "lib", "auth.ts");
+    if (!fs19.existsSync(authFilePath)) {
+      console.log(chalk20.red("auth.ts file not found."));
       return;
     }
-    let content = fs20.readFileSync(authFilePath, "utf8");
+    let content = fs19.readFileSync(authFilePath, "utf8");
     const codeAdded = ` sendResetPassword: async ({ user, url, token }) => {
       await sendEmail({
         email: user.email!,
@@ -1814,7 +1929,7 @@ var forgetNext = async () => {
         content = before + `
  ${codeAdded}` + after;
       }
-      fs20.writeFileSync(authFilePath, content, "utf8");
+      fs19.writeFileSync(authFilePath, content, "utf8");
       if (!content.includes("import { sendEmail }")) {
         const lastImportIndex = content.lastIndexOf("import");
         const nextLineAfterLastImport = content.indexOf("\n", lastImportIndex) + 1;
@@ -1824,128 +1939,128 @@ var forgetNext = async () => {
 import { sendEmail } from "./email";
 `;
         content = beforeImports + newImports + afterImports;
-        fs20.writeFileSync(authFilePath, content, "utf8");
+        fs19.writeFileSync(authFilePath, content, "utf8");
       }
-      const componentPath = path20.resolve(
+      const componentPath = path19.resolve(
         __dirname,
         "./template/email/reset-password.tsx"
       );
-      const destinationPath = path20.join(
+      const destinationPath = path19.join(
         projectDir,
         folder,
         "components",
         "email"
       );
-      if (!fs20.existsSync(destinationPath)) {
-        fs20.mkdirSync(destinationPath, { recursive: true });
+      if (!fs19.existsSync(destinationPath)) {
+        fs19.mkdirSync(destinationPath, { recursive: true });
       }
-      const emailDestinationPath = path20.join(
+      const emailDestinationPath = path19.join(
         destinationPath,
         "reset-password.tsx"
       );
-      if (fs20.existsSync(componentPath)) {
-        fs20.copyFileSync(componentPath, emailDestinationPath);
+      if (fs19.existsSync(componentPath)) {
+        fs19.copyFileSync(componentPath, emailDestinationPath);
       }
-      const forgetComponentPath = path20.resolve(
+      const forgetComponentPath = path19.resolve(
         __dirname,
         "./template/components/ForgetComponent.tsx"
       );
-      const componentsDestinationPath = path20.join(
+      const componentsDestinationPath = path19.join(
         projectDir,
         folder,
         "components",
         "authverse"
       );
-      if (!fs20.existsSync(componentsDestinationPath)) {
-        fs20.mkdirSync(componentsDestinationPath, { recursive: true });
+      if (!fs19.existsSync(componentsDestinationPath)) {
+        fs19.mkdirSync(componentsDestinationPath, { recursive: true });
       }
-      const forgetDestinationPath = path20.join(
+      const forgetDestinationPath = path19.join(
         componentsDestinationPath,
         "ForgetComponent.tsx"
       );
-      if (fs20.existsSync(forgetComponentPath)) {
-        fs20.copyFileSync(forgetComponentPath, forgetDestinationPath);
+      if (fs19.existsSync(forgetComponentPath)) {
+        fs19.copyFileSync(forgetComponentPath, forgetDestinationPath);
       }
-      const resetComponentPath = path20.resolve(
+      const resetComponentPath = path19.resolve(
         __dirname,
         "./template/components/ResetComponent.tsx"
       );
-      const resetDestinationPath = path20.join(
+      const resetDestinationPath = path19.join(
         componentsDestinationPath,
         "ResetComponent.tsx"
       );
-      if (fs20.existsSync(resetComponentPath)) {
-        fs20.copyFileSync(resetComponentPath, resetDestinationPath);
+      if (fs19.existsSync(resetComponentPath)) {
+        fs19.copyFileSync(resetComponentPath, resetDestinationPath);
       }
-      const authTemplatePath = path20.resolve(
+      const authTemplatePath = path19.resolve(
         __dirname,
         "./template/app-auth-uiDesign"
       );
-      const appDestinationPath = path20.join(projectDir, folder, "app", "auth");
-      if (!fs20.existsSync(appDestinationPath)) {
-        fs20.mkdirSync(appDestinationPath, { recursive: true });
+      const appDestinationPath = path19.join(projectDir, folder, "app", "auth");
+      if (!fs19.existsSync(appDestinationPath)) {
+        fs19.mkdirSync(appDestinationPath, { recursive: true });
       }
-      const forgetDestinationDir = path20.join(appDestinationPath, "forget");
-      if (!fs20.existsSync(forgetDestinationDir)) {
-        fs20.mkdirSync(forgetDestinationDir, { recursive: true });
+      const forgetDestinationDir = path19.join(appDestinationPath, "forget");
+      if (!fs19.existsSync(forgetDestinationDir)) {
+        fs19.mkdirSync(forgetDestinationDir, { recursive: true });
       }
-      const forgetPageDestinationPath = path20.join(
+      const forgetPageDestinationPath = path19.join(
         forgetDestinationDir,
         "page.tsx"
       );
-      fs20.copyFileSync(
+      fs19.copyFileSync(
         `${authTemplatePath}/forget/page.tsx`,
         forgetPageDestinationPath
       );
-      const resetDestinationDir = path20.join(
+      const resetDestinationDir = path19.join(
         appDestinationPath,
         "reset-password"
       );
-      if (!fs20.existsSync(resetDestinationDir)) {
-        fs20.mkdirSync(resetDestinationDir, { recursive: true });
+      if (!fs19.existsSync(resetDestinationDir)) {
+        fs19.mkdirSync(resetDestinationDir, { recursive: true });
       }
-      const resetPageDestinationPath = path20.join(
+      const resetPageDestinationPath = path19.join(
         resetDestinationDir,
         "page.tsx"
       );
-      fs20.copyFileSync(
+      fs19.copyFileSync(
         `${authTemplatePath}/reset-password/page.tsx`,
         resetPageDestinationPath
       );
       console.log(
-        chalk18.green("Successfully added forget and reset-password pages")
+        chalk20.green("Successfully added forget and reset-password pages")
       );
     } else {
       console.log(
-        chalk18.red("Could not find emailAndPassword configuration in auth.ts")
+        chalk20.red("Could not find emailAndPassword configuration in auth.ts")
       );
     }
   } catch (error) {
-    console.log(chalk18.red("Error adding sendResetPassword:"), error);
+    console.log(chalk20.red("Error adding sendResetPassword:"), error);
   }
 };
 
 // script/forgetTanstack.ts
-import chalk19 from "chalk";
-import path21 from "path";
+import chalk21 from "chalk";
+import path20 from "path";
 import { fileURLToPath as fileURLToPath18 } from "url";
-import fs21 from "fs";
+import fs20 from "fs";
 var forgetTanstack = async () => {
   try {
     const projectDir = process.cwd();
     const __filename = fileURLToPath18(import.meta.url);
-    const __dirname = path21.dirname(__filename);
-    const srcPath = path21.join(projectDir, "src");
-    const emailFilePath = path21.join(srcPath, "lib", "email.ts");
-    if (!fs21.existsSync(emailFilePath)) {
+    const __dirname = path20.dirname(__filename);
+    const srcPath = path20.join(projectDir, "src");
+    const emailFilePath = path20.join(srcPath, "lib", "email.ts");
+    if (!fs20.existsSync(emailFilePath)) {
       await email();
     }
-    const authFilePath = path21.join(srcPath, "lib", "auth.ts");
-    if (!fs21.existsSync(authFilePath)) {
-      console.log(chalk19.red("auth.ts file not found."));
+    const authFilePath = path20.join(srcPath, "lib", "auth.ts");
+    if (!fs20.existsSync(authFilePath)) {
+      console.log(chalk21.red("auth.ts file not found."));
       return;
     }
-    let content = fs21.readFileSync(authFilePath, "utf8");
+    let content = fs20.readFileSync(authFilePath, "utf8");
     const codeAdded = `sendResetPassword: async ({ user, url, token }) => {
       await sendEmail({
         email: user.email!,
@@ -1989,7 +2104,7 @@ var forgetTanstack = async () => {
         content = before + `
  ${codeAdded}` + after;
       }
-      fs21.writeFileSync(authFilePath, content, "utf8");
+      fs20.writeFileSync(authFilePath, content, "utf8");
       if (!content.includes("import { sendEmail }")) {
         const lastImportIndex = content.lastIndexOf("import");
         const nextLineAfterLastImport = content.indexOf("\n", lastImportIndex) + 1;
@@ -1999,99 +2114,97 @@ var forgetTanstack = async () => {
 import { sendEmail } from "./email";
 `;
         content = beforeImports + newImports + afterImports;
-        fs21.writeFileSync(authFilePath, content, "utf8");
+        fs20.writeFileSync(authFilePath, content, "utf8");
       }
-      const componentPath = path21.resolve(
+      const componentPath = path20.resolve(
         __dirname,
         "./template/email/reset-password.tsx"
       );
-      const destinationPath = path21.join(srcPath, "components", "email");
-      if (!fs21.existsSync(destinationPath)) {
-        fs21.mkdirSync(destinationPath, { recursive: true });
+      const destinationPath = path20.join(srcPath, "components", "email");
+      if (!fs20.existsSync(destinationPath)) {
+        fs20.mkdirSync(destinationPath, { recursive: true });
       }
-      const emailDestinationPath = path21.join(
+      const emailDestinationPath = path20.join(
         destinationPath,
         "reset-password.tsx"
       );
-      if (fs21.existsSync(componentPath)) {
-        fs21.copyFileSync(componentPath, emailDestinationPath);
+      if (fs20.existsSync(componentPath)) {
+        fs20.copyFileSync(componentPath, emailDestinationPath);
       }
-      const forgetComponentPath = path21.resolve(
+      const forgetComponentPath = path20.resolve(
         __dirname,
         "./template/TanstackState/components/ForgetComponent.tsx"
       );
-      const componentsDestinationPath = path21.join(
+      const componentsDestinationPath = path20.join(
         srcPath,
         "components",
         "authverse"
       );
-      if (!fs21.existsSync(componentsDestinationPath)) {
-        fs21.mkdirSync(componentsDestinationPath, { recursive: true });
+      if (!fs20.existsSync(componentsDestinationPath)) {
+        fs20.mkdirSync(componentsDestinationPath, { recursive: true });
       }
-      const forgetDestinationPath = path21.join(
+      const forgetDestinationPath = path20.join(
         componentsDestinationPath,
         "ForgetComponent.tsx"
       );
-      if (fs21.existsSync(forgetComponentPath)) {
-        fs21.copyFileSync(forgetComponentPath, forgetDestinationPath);
+      if (fs20.existsSync(forgetComponentPath)) {
+        fs20.copyFileSync(forgetComponentPath, forgetDestinationPath);
       }
-      const resetComponentPath = path21.resolve(
+      const resetComponentPath = path20.resolve(
         __dirname,
         "./template/TanstackState/components/ResetComponent.tsx"
       );
-      const resetDestinationPath = path21.join(
+      const resetDestinationPath = path20.join(
         componentsDestinationPath,
         "ResetComponent.tsx"
       );
-      if (fs21.existsSync(resetComponentPath)) {
-        fs21.copyFileSync(resetComponentPath, resetDestinationPath);
+      if (fs20.existsSync(resetComponentPath)) {
+        fs20.copyFileSync(resetComponentPath, resetDestinationPath);
       }
-      const authTemplatePath = path21.resolve(
+      const authTemplatePath = path20.resolve(
         __dirname,
         "./template/TanstackState/routes/auth"
       );
-      const routesDestinationPath = path21.join(srcPath, "routes", "auth");
-      if (!fs21.existsSync(routesDestinationPath)) {
-        fs21.mkdirSync(routesDestinationPath, { recursive: true });
+      const routesDestinationPath = path20.join(srcPath, "routes", "auth");
+      if (!fs20.existsSync(routesDestinationPath)) {
+        fs20.mkdirSync(routesDestinationPath, { recursive: true });
       }
-      const forgetPageDestinationPath = path21.join(
+      const forgetPageDestinationPath = path20.join(
         routesDestinationPath,
         "forget.tsx"
       );
-      fs21.copyFileSync(
+      fs20.copyFileSync(
         `${authTemplatePath}/forget.tsx`,
         forgetPageDestinationPath
       );
-      const resetPageDestinationPath = path21.join(
+      const resetPageDestinationPath = path20.join(
         routesDestinationPath,
         "reset-password.tsx"
       );
-      fs21.copyFileSync(
+      fs20.copyFileSync(
         `${authTemplatePath}/reset-password.tsx`,
         resetPageDestinationPath
       );
       console.log(
-        chalk19.green("Successfully added forget and reset-password pages")
+        chalk21.green("Successfully added forget and reset-password pages")
       );
     } else {
       console.log(
-        chalk19.red("Could not find emailAndPassword configuration in auth.ts")
+        chalk21.red("Could not find emailAndPassword configuration in auth.ts")
       );
     }
   } catch (error) {
-    console.log(chalk19.red("Error adding sendResetPassword:"), error);
+    console.log(chalk21.red("Error adding sendResetPassword:"), error);
   }
 };
 
 // cli/forget.ts
-var forget = () => {
-  const projectDir = process.cwd();
-  const packageJsonPath = path22.join(projectDir, "package.json");
-  let framework = "tanstack state";
-  if (fs22.existsSync(packageJsonPath)) {
-    const packageJson2 = JSON.parse(fs22.readFileSync(packageJsonPath, "utf-8"));
-    const hasNext = packageJson2?.dependencies?.["next"] || packageJson2?.devDependencies?.["next"];
-    framework = hasNext ? "Next js" : "tanstack state";
+import chalk22 from "chalk";
+var forget = async () => {
+  const { framework, error } = await getFramework();
+  if (error) {
+    console.log(chalk22.red(error));
+    return;
   }
   if (framework === "Next js") {
     return forgetNext();
@@ -2102,32 +2215,30 @@ var forget = () => {
 };
 
 // cli/verification.ts
-import chalk22 from "chalk";
-import fs25 from "fs";
-import path25 from "path";
+import chalk25 from "chalk";
 
 // script/verifyNext.ts
-import chalk20 from "chalk";
-import fs23 from "fs";
-import path23 from "path";
+import chalk23 from "chalk";
+import fs21 from "fs";
+import path21 from "path";
 import { fileURLToPath as fileURLToPath19 } from "url";
 var verifyNext = async () => {
   try {
     const projectDir = process.cwd();
     const __filename = fileURLToPath19(import.meta.url);
-    const __dirname = path23.dirname(__filename);
-    const srcPath = path23.join(projectDir, "src");
-    const folder = fs23.existsSync(srcPath) ? "src" : "";
-    const emailFilePath = path23.join(projectDir, folder, "lib", "email.ts");
-    if (!fs23.existsSync(emailFilePath)) {
+    const __dirname = path21.dirname(__filename);
+    const srcPath = path21.join(projectDir, "src");
+    const folder = fs21.existsSync(srcPath) ? "src" : "";
+    const emailFilePath = path21.join(projectDir, folder, "lib", "email.ts");
+    if (!fs21.existsSync(emailFilePath)) {
       await email();
     }
-    const authFilePath = path23.join(projectDir, folder, "lib", "auth.ts");
-    if (!fs23.existsSync(authFilePath)) {
-      console.log(chalk20.red("auth.ts file not found."));
+    const authFilePath = path21.join(projectDir, folder, "lib", "auth.ts");
+    if (!fs21.existsSync(authFilePath)) {
+      console.log(chalk23.red("auth.ts file not found."));
       return;
     }
-    let content = fs23.readFileSync(authFilePath, "utf8");
+    let content = fs21.readFileSync(authFilePath, "utf8");
     if (content.includes("emailAndPassword: {")) {
       const start = content.indexOf("emailAndPassword: {");
       let end = start;
@@ -2187,46 +2298,46 @@ var verifyNext = async () => {
 `;
       content = content.slice(0, nextLine) + imports + content.slice(nextLine);
     }
-    fs23.writeFileSync(authFilePath, content, "utf8");
-    const templatePath = path23.resolve(
+    fs21.writeFileSync(authFilePath, content, "utf8");
+    const templatePath = path21.resolve(
       __dirname,
       "./template/email/EmailVerification.tsx"
     );
-    const componentsDir = path23.join(projectDir, folder, "components", "email");
-    if (!fs23.existsSync(componentsDir)) {
-      fs23.mkdirSync(componentsDir, { recursive: true });
+    const componentsDir = path21.join(projectDir, folder, "components", "email");
+    if (!fs21.existsSync(componentsDir)) {
+      fs21.mkdirSync(componentsDir, { recursive: true });
     }
-    const destFile = path23.join(componentsDir, "EmailVerification.tsx");
-    if (fs23.existsSync(templatePath) && !fs23.existsSync(destFile)) {
-      fs23.copyFileSync(templatePath, destFile);
+    const destFile = path21.join(componentsDir, "EmailVerification.tsx");
+    if (fs21.existsSync(templatePath) && !fs21.existsSync(destFile)) {
+      fs21.copyFileSync(templatePath, destFile);
     }
-    console.log(chalk20.green("Email verification successfully configured"));
+    console.log(chalk23.green("Email verification successfully configured"));
   } catch (error) {
-    console.log(chalk20.red(String(error)));
+    console.log(chalk23.red(String(error)));
   }
 };
 
 // script/verifyTanstack.ts
-import chalk21 from "chalk";
-import fs24 from "fs";
-import path24 from "path";
+import chalk24 from "chalk";
+import fs22 from "fs";
+import path22 from "path";
 import { fileURLToPath as fileURLToPath20 } from "url";
 var verifyTanstack = async () => {
   try {
     const projectDir = process.cwd();
     const __filename = fileURLToPath20(import.meta.url);
-    const __dirname = path24.dirname(__filename);
-    const srcPath = path24.join(projectDir, "src");
-    const emailFilePath = path24.join(srcPath, "lib", "email.ts");
-    if (!fs24.existsSync(emailFilePath)) {
+    const __dirname = path22.dirname(__filename);
+    const srcPath = path22.join(projectDir, "src");
+    const emailFilePath = path22.join(srcPath, "lib", "email.ts");
+    if (!fs22.existsSync(emailFilePath)) {
       await email();
     }
-    const authFilePath = path24.join(srcPath, "lib", "auth.ts");
-    if (!fs24.existsSync(authFilePath)) {
-      console.log(chalk21.red("auth.ts file not found."));
+    const authFilePath = path22.join(srcPath, "lib", "auth.ts");
+    if (!fs22.existsSync(authFilePath)) {
+      console.log(chalk24.red("auth.ts file not found."));
       return;
     }
-    let content = fs24.readFileSync(authFilePath, "utf8");
+    let content = fs22.readFileSync(authFilePath, "utf8");
     if (content.includes("emailAndPassword: {")) {
       const start = content.indexOf("emailAndPassword: {");
       let end = start;
@@ -2286,35 +2397,32 @@ var verifyTanstack = async () => {
 `;
       content = content.slice(0, nextLine) + imports + content.slice(nextLine);
     }
-    fs24.writeFileSync(authFilePath, content, "utf8");
-    const templatePath = path24.resolve(
+    fs22.writeFileSync(authFilePath, content, "utf8");
+    const templatePath = path22.resolve(
       __dirname,
       "./template/email/EmailVerification.tsx"
     );
-    const componentsDir = path24.join(srcPath, "components", "email");
-    if (!fs24.existsSync(componentsDir)) {
-      fs24.mkdirSync(componentsDir, { recursive: true });
+    const componentsDir = path22.join(srcPath, "components", "email");
+    if (!fs22.existsSync(componentsDir)) {
+      fs22.mkdirSync(componentsDir, { recursive: true });
     }
-    const destFile = path24.join(componentsDir, "EmailVerification.tsx");
-    if (fs24.existsSync(templatePath) && !fs24.existsSync(destFile)) {
-      fs24.copyFileSync(templatePath, destFile);
+    const destFile = path22.join(componentsDir, "EmailVerification.tsx");
+    if (fs22.existsSync(templatePath) && !fs22.existsSync(destFile)) {
+      fs22.copyFileSync(templatePath, destFile);
     }
-    console.log(chalk21.green("Email verification successfully configured"));
+    console.log(chalk24.green("Email verification successfully configured"));
   } catch (error) {
-    console.log(chalk21.red(String(error)));
+    console.log(chalk24.red(String(error)));
   }
 };
 
 // cli/verification.ts
 var verification = async () => {
   try {
-    const projectDir = process.cwd();
-    const packageJsonPath = path25.join(projectDir, "package.json");
-    let framework = "tanstack state";
-    if (fs25.existsSync(packageJsonPath)) {
-      const packageJson2 = JSON.parse(fs25.readFileSync(packageJsonPath, "utf-8"));
-      const hasNext = packageJson2?.dependencies?.["next"] || packageJson2?.devDependencies?.["next"];
-      framework = hasNext ? "Next js" : "tanstack state";
+    const { framework, error } = await getFramework();
+    if (error) {
+      console.log(chalk25.red(error));
+      return;
     }
     if (framework === "Next js") {
       await verifyNext();
@@ -2323,7 +2431,47 @@ var verification = async () => {
       await verifyTanstack();
     }
   } catch (error) {
-    console.log(chalk22.red(error.message));
+    console.log(chalk25.red(error.message));
+  }
+};
+
+// cli/initCmd.ts
+import chalk26 from "chalk";
+var initCmd = async (cmd) => {
+  try {
+    const { framework, error } = await getFramework();
+    if (error) {
+      console.log(chalk26.red(error));
+      return;
+    }
+    if (framework === "Next js" && cmd.orm === "prisma") {
+      await prismaRun({
+        database: cmd.db,
+        authUi: cmd.authUi === "yes" ? true : false,
+        cmd: true
+      });
+    }
+    if (framework === "Next js" && cmd.orm === "drizzle") {
+      await drizzleRun({
+        authUi: cmd.authUi === "yes" ? true : false,
+        cmd: true
+      });
+    }
+    if (framework === "tanstack state" && cmd.orm === "prisma") {
+      await prismaRunTanstackState({
+        authUi: cmd.authUi === "yes" ? true : false,
+        database: cmd.db,
+        cmd: true
+      });
+    }
+    if (framework === "tanstack state" && cmd.orm === "drizzle") {
+      await drizzleRunTanstackState({
+        authUi: cmd.authUi === "yes" ? true : false,
+        cmd: true
+      });
+    }
+  } catch (error) {
+    console.log(chalk26.red(error));
   }
 };
 
@@ -2335,11 +2483,23 @@ program.name("authverse").description("CLI tool for creating authverse projects"
   "-v, --version",
   "display the version number"
 );
-program.command("init").description("Select project template and configuration").action(async () => {
-  await initAnswer();
+program.command("init").description("Select project template and configuration").option("--orm <type>", "Select ORM (prisma, drizzle)").option("--db <type>", "Select database (mysql, postgres, mongodb)").option("--authUi <value>", "Include auth UI (yes/no)").action(async (cmd) => {
+  if (!cmd.orm || !cmd.db || !cmd.authUi) {
+    await initAnswer();
+  } else {
+    await initCmd(cmd);
+  }
+});
+program.command("add <provider>").description("Add a new authentication provider").action(async (provider) => {
+  await providers({ provider });
+});
+program.command("forget").description("Forget stored configurations").action(async () => {
+  await forget();
+});
+program.command("email").description("Configure email settings").action(async () => {
+  await email();
+});
+program.command("verify").description("Verify authentication setup").action(async () => {
+  await verification();
 });
-program.command("add <provider>").description("Add a new authentication provider").action((provider) => providers({ provider }));
-program.command("forget").description("Forget stored configurations").action(forget);
-program.command("email").description("Configure email settings").action(email);
-program.command("verify").description("Verify authentication setup").action(verification);
 program.parse(process.argv);