authverse 1.0.6 → 1.0.7-canary.2

package/dist/index.js

@@ -197,12 +197,15 @@ var prismaRun = async ({ authUi, database }) => {
       }
     } else {
       const schemaPath = path2.join(prismaDir, "schema.prisma");
-      const templatePath = path2.resolve(
-        __dirname,
-        `./template/prisma/${database}/schema.prisma_copy`
-      );
-      fs2.appendFileSync(schemaPath, "\n");
-      fs2.appendFileSync(schemaPath, fs2.readFileSync(templatePath));
+      const schemaContent = fs2.readFileSync(schemaPath, "utf-8");
+      if (!schemaContent.includes("User") && !schemaContent.includes("Session") && !schemaContent.includes("Account") && !schemaContent.includes("Verification")) {
+        const templatePath = path2.resolve(
+          __dirname,
+          `./template/prisma/${database}/schema.prisma_copy`
+        );
+        fs2.appendFileSync(schemaPath, "\n");
+        fs2.appendFileSync(schemaPath, fs2.readFileSync(templatePath));
+      }
     }
     if (!packageJson2.dependencies?.["better-auth"]) {
       console.log(chalk2.yellow("\n\u2699\uFE0F  Initializing better-auth...\n"));
@@ -406,8 +409,342 @@ 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";
+import { fileURLToPath as fileURLToPath5 } from "url";
+import fs5 from "fs";
+
+// script/authUiTanstackState.ts
+import chalk4 from "chalk";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import path4 from "path";
+import fs4 from "fs";
+var authUiTanstackState = async () => {
+  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 __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,
+      "./template/TanstackState/components"
+    );
+    const authversePathComponents = path4.join(
+      srcPath,
+      "components",
+      "authverse"
+    );
+    if (!fs4.existsSync(authversePathComponents)) {
+      fs4.mkdirSync(authversePathComponents, { recursive: true });
+    }
+    fs4.copyFileSync(
+      `${componentPath}/LoginComponent.tsx`,
+      path4.join(authversePathComponents, "LoginComponent.tsx")
+    );
+    fs4.copyFileSync(
+      `${componentPath}/SingUpComponent.tsx`,
+      path4.join(authversePathComponents, "SingUpComponent.tsx")
+    );
+    const pageRoutesPath = path4.join(`${srcPath}/routes`, "auth");
+    if (!fs4.existsSync(pageRoutesPath)) {
+      fs4.mkdirSync(pageRoutesPath, { recursive: true });
+    }
+    const templateRoutesPage = path4.resolve(
+      __dirname,
+      "./template/TanstackState/routes/auth"
+    );
+    fs4.copyFileSync(
+      `${templateRoutesPage}/login.tsx`,
+      path4.join(pageRoutesPath, "login.tsx")
+    );
+    fs4.copyFileSync(
+      `${templateRoutesPage}/signup.tsx`,
+      path4.join(pageRoutesPath, "signup.tsx")
+    );
+    const rootPath = path4.join(projectDir, "src/routes", "__root.tsx");
+    if (fs4.existsSync(rootPath)) {
+      let rootContent = fs4.readFileSync(rootPath, "utf-8");
+      if (!rootContent.includes("Toaster")) {
+        rootContent = `import { Toaster } from "@/components/ui/sonner";
+${rootContent}`;
+      }
+      if (!rootContent.includes("<Toaster")) {
+        rootContent = rootContent.replace(
+          /<\/body>/,
+          "    <Toaster />\n  </body>"
+        );
+      }
+      fs4.writeFileSync(rootPath, rootContent, "utf-8");
+    }
+    console.log(chalk4.green("\nSetup completed!\n"));
+  } catch (error) {
+    console.log(chalk4.red("Auth Ui Tanstack State Error: ", error));
+  }
+};
+
+// script/prismaRunTanstackState.ts
+var prismaRunTanstackState = async ({
+  authUi,
+  database
+}) => {
+  try {
+    const projectDir = process.cwd();
+    const __filename = fileURLToPath5(import.meta.url);
+    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"]) {
+      console.log(chalk5.cyan("\n\u2699\uFE0F  Initializing Prisma...\n"));
+      if (database !== "Mongodb") {
+        packageManager("prisma", true);
+        packageManager("@prisma/client");
+        if (database === "Mysql") {
+          packageManager("@prisma/adapter-mariadb");
+        }
+        if (database === "Postgresql") {
+          packageManager("@prisma/adapter-pg");
+        }
+      } else if (database === "Mongodb") {
+        packageManager("prisma@6.19.0", true);
+        packageManager("@prisma/client@6.19.0");
+      }
+    }
+    const prismaDir = path5.join(projectDir, "prisma");
+    if (!fs5.existsSync(prismaDir)) {
+      console.log(chalk5.yellow("\n\u2699\uFE0F  Initializing Prisma...\n"));
+      runCommand("prisma init");
+      const templatePath = path5.resolve(
+        __dirname,
+        `./template/prisma/${database}/schema.prisma`
+      );
+      if (!fs5.existsSync(prismaDir)) {
+        fs5.mkdirSync(prismaDir, { recursive: true });
+      }
+      const destinationPath = path5.join(prismaDir, "schema.prisma");
+      fs5.copyFileSync(templatePath, destinationPath);
+      if (database === "Mongodb") {
+        const prismaConfigPath = path5.resolve(
+          __dirname,
+          `./template/config/prisma.config.ts`
+        );
+        const prismaConfigDestinationPath = path5.join("", "prisma.config.ts");
+        fs5.copyFileSync(prismaConfigPath, prismaConfigDestinationPath);
+      }
+    } 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")) {
+        const templatePath = path5.resolve(
+          __dirname,
+          `./template/prisma/${database}/schema.prisma_copy`
+        );
+        fs5.appendFileSync(schemaPath, "\n");
+        fs5.appendFileSync(schemaPath, fs5.readFileSync(templatePath));
+      }
+    }
+    if (!packageJson2.dependencies?.["better-auth"]) {
+      console.log(chalk5.yellow("\n\u2699\uFE0F  Initializing better-auth...\n"));
+      packageManager("better-auth");
+    }
+    const secret = await GenerateSecret();
+    const envPath = path5.join(projectDir, ".env");
+    const envContent = fs5.readFileSync(envPath, "utf-8");
+    if (!envContent.includes("BETTER_AUTH_SECRET")) {
+      fs5.appendFileSync(envPath, `
+
+BETTER_AUTH_SECRET=${secret}`);
+    }
+    if (!envContent.includes("BETTER_AUTH_URL")) {
+      fs5.appendFileSync(envPath, `
+BETTER_AUTH_URL=http://localhost:3000
+`);
+    }
+    const srcPath = path5.join(projectDir, "src");
+    const libPath = path5.join(srcPath, "lib");
+    if (!fs5.existsSync(libPath)) {
+      fs5.mkdirSync(libPath, { recursive: true });
+    }
+    const authTemplatePath = path5.resolve(
+      __dirname,
+      `./template/TanstackState/lib/${database}/auth.ts`
+    );
+    const authDestinationPath = path5.join(libPath, "auth.ts");
+    fs5.copyFileSync(authTemplatePath, authDestinationPath);
+    const authClientTemplatePath = path5.resolve(
+      __dirname,
+      "./template/lib/auth-client.ts"
+    );
+    const authClientDestinationPath = path5.join(libPath, "auth-client.ts");
+    fs5.copyFileSync(authClientTemplatePath, authClientDestinationPath);
+    const middlewarePath = path5.join(srcPath, "middleware");
+    if (!fs5.existsSync(middlewarePath)) {
+      fs5.mkdirSync(middlewarePath, { recursive: true });
+    }
+    const authMiddlewareTemplatePath = path5.resolve(
+      __dirname,
+      `./template/TanstackState/middleware/auth.ts`
+    );
+    const authMiddlewareDestinationPath = path5.join(middlewarePath, "auth.ts");
+    fs5.copyFileSync(authMiddlewareTemplatePath, authMiddlewareDestinationPath);
+    const fileRouteTemplatePath = path5.resolve(
+      __dirname,
+      `./template/TanstackState/routes/$.ts`
+    );
+    const fileRouteDestinationPath = path5.join(
+      srcPath,
+      "routes",
+      "api",
+      "auth"
+    );
+    if (!fs5.existsSync(fileRouteDestinationPath)) {
+      fs5.mkdirSync(fileRouteDestinationPath, { recursive: true });
+    }
+    const apiDestinationPath = path5.join(fileRouteDestinationPath, "$.ts");
+    fs5.copyFileSync(fileRouteTemplatePath, apiDestinationPath);
+    if (authUi) {
+      await authUiTanstackState();
+    } else {
+      console.log(
+        chalk5.green(
+          "\nPrisma setup completed successfully and better-auth installed\n"
+        )
+      );
+    }
+  } catch (err) {
+    console.log(chalk5.red("Prisma Run Tanstack State Error: ", err));
+  }
+};
+
+// script/drizzleRunTanstackState.ts
+import chalk6 from "chalk";
+import path6 from "path";
+import fs6 from "fs";
+import { fileURLToPath as fileURLToPath6 } from "url";
+var drizzleRunTanstackState = async (authUi) => {
+  try {
+    const projectDir = process.cwd();
+    const packageJsonPath = path6.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(fs6.readFileSync(packageJsonPath, "utf-8"));
+    if (!packageJson2.dependencies["better-auth"]) {
+      console.log(chalk6.cyan("\n\u2699\uFE0F  Initializing better auth...\n"));
+      packageManager("better-auth");
+    }
+    if (!packageJson2.dependencies["drizzle-orm"] && !packageJson2.dependencies["drizzle-orm"] && !packageJson2.dependencies["drizzle-kit"] && !packageJson2.devDependencies["drizzle-kit"]) {
+      console.log(chalk6.cyan("\n\u2699\uFE0F  Initializing drizzle...\n"));
+      packageManager("drizzle-orm @neondatabase/serverless dotenv");
+      packageManager("drizzle-kit", true);
+    }
+    const __filename = fileURLToPath6(import.meta.url);
+    const __dirname = path6.dirname(__filename);
+    const envPath = path6.join(projectDir, ".env");
+    if (!fs6.existsSync(envPath)) {
+      fs6.writeFileSync(envPath, "DATABASE_URL=\n");
+    }
+    const secret = await GenerateSecret();
+    const envContent = fs6.readFileSync(envPath, "utf-8");
+    if (!envContent.includes("BETTER_AUTH_SECRET")) {
+      fs6.appendFileSync(envPath, `
+
+BETTER_AUTH_SECRET=${secret}`);
+    }
+    if (!envContent.includes("BETTER_AUTH_URL")) {
+      fs6.appendFileSync(envPath, `
+BETTER_AUTH_URL=http://localhost:3000
+`);
+    }
+    const srcPath = path6.join(projectDir, "src");
+    const libPath = path6.join(srcPath, "lib");
+    if (!fs6.existsSync(libPath)) {
+      fs6.mkdirSync(libPath, { recursive: true });
+    }
+    const authTemplatePath = path6.resolve(
+      __dirname,
+      "./template/TanstackState/lib/auth-drizzle.ts"
+    );
+    const authDestinationPath = path6.join(libPath, "auth.ts");
+    fs6.copyFileSync(authTemplatePath, authDestinationPath);
+    const authClientTemplatePath = path6.resolve(
+      __dirname,
+      "./template/lib/auth-client.ts"
+    );
+    const authClientDestinationPath = path6.join(libPath, "auth-client.ts");
+    fs6.copyFileSync(authClientTemplatePath, authClientDestinationPath);
+    const dbTemplatePath = path6.resolve(__dirname, "./template/db");
+    const dbDir = path6.join(projectDir, "db");
+    if (!fs6.existsSync(dbDir)) {
+      fs6.mkdirSync(dbDir, { recursive: true });
+    }
+    const dbDestinationPath = path6.join(dbDir, "drizzle.ts");
+    fs6.copyFileSync(`${dbTemplatePath}/drizzle.ts`, dbDestinationPath);
+    const schemaDestinationPath = path6.join(dbDir, "schema.ts");
+    fs6.copyFileSync(`${dbTemplatePath}/schema.ts`, schemaDestinationPath);
+    const drizzleConfigTemplatePath = path6.resolve(
+      __dirname,
+      "./template/config/drizzle.config.ts"
+    );
+    const drizzleConfigDestinationPath = path6.join(
+      projectDir,
+      "drizzle.config.ts"
+    );
+    fs6.copyFileSync(drizzleConfigTemplatePath, drizzleConfigDestinationPath);
+    const middlewarePath = path6.join(srcPath, "middleware");
+    if (!fs6.existsSync(middlewarePath)) {
+      fs6.mkdirSync(middlewarePath, { recursive: true });
+    }
+    const authMiddlewareTemplatePath = path6.resolve(
+      __dirname,
+      `./template/TanstackState/middleware/auth.ts`
+    );
+    const authMiddlewareDestinationPath = path6.join(middlewarePath, "auth.ts");
+    fs6.copyFileSync(authMiddlewareTemplatePath, authMiddlewareDestinationPath);
+    const fileRouteTemplatePath = path6.resolve(
+      __dirname,
+      `./template/TanstackState/routes/$.ts`
+    );
+    const fileRouteDestinationPath = path6.join(
+      srcPath,
+      "routes",
+      "api",
+      "auth"
+    );
+    if (!fs6.existsSync(fileRouteDestinationPath)) {
+      fs6.mkdirSync(fileRouteDestinationPath, { recursive: true });
+    }
+    const apiDestinationPath = path6.join(fileRouteDestinationPath, "$.ts");
+    fs6.copyFileSync(fileRouteTemplatePath, apiDestinationPath);
+    if (authUi) {
+      await authUiTanstackState();
+    } else {
+      console.log(
+        chalk6.green(
+          "\nDrizzle setup completed successfully and better-auth installed\n"
+        )
+      );
+    }
+  } catch (err) {
+    console.error(chalk6.red("Drizzle setup failed:"), err);
+  }
+};
+
 // cli/init.ts
 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";
+  }
+  console.log(`\u2714 Detected framework: ${framework}`);
   const answers = await inquirer.prompt([
     {
       type: "list",
@@ -429,47 +766,56 @@ var initAnswer = async () => {
       default: true
     }
   ]);
-  if (answers.orm === "Prisma") {
+  if (framework === "Next js" && answers.orm === "Prisma") {
     await prismaRun({
       authUi: answers.authUi,
       database: answers.database
     });
   }
-  if (answers.orm === "Drizzle") {
+  if (framework === "Next js" && answers.orm === "Drizzle") {
     await drizzleRun(answers.authUi);
   }
+  if (framework === "tanstack state" && answers.orm === "Prisma") {
+    await prismaRunTanstackState({
+      authUi: answers.authUi,
+      database: answers.database
+    });
+  }
+  if (framework === "tanstack state" && answers.orm === "Drizzle") {
+    await drizzleRunTanstackState(answers.authUi);
+  }
 };
 
 // index.ts
 import { readFileSync as readFileSync2 } from "fs";
 
 // cli/provider.ts
-import chalk6 from "chalk";
+import chalk11 from "chalk";
 
 // script/googleRun.ts
-import chalk4 from "chalk";
-import fs4 from "fs";
-import path4 from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import chalk7 from "chalk";
+import fs8 from "fs";
+import path8 from "path";
+import { fileURLToPath as fileURLToPath7 } from "url";
 var googleRun = async () => {
   try {
-    const __filename = fileURLToPath4(import.meta.url);
-    const __dirname = path4.dirname(__filename);
+    const __filename = fileURLToPath7(import.meta.url);
+    const __dirname = path8.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = path4.join(projectDir, "src");
-    const folder = fs4.existsSync(srcPath) ? "src" : "";
-    const authFilePath = path4.join(projectDir, folder, "lib", "auth.ts");
-    if (!fs4.existsSync(authFilePath)) {
-      console.log(chalk4.red("\u274C auth.ts file not found"));
+    const srcPath = path8.join(projectDir, "src");
+    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"));
       return;
     }
-    let content = fs4.readFileSync(authFilePath, "utf8");
+    let content = fs8.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(chalk4.red("betterAuth({}) block not found"));
+      console.log(chalk7.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("google:")) {
-      console.log(chalk4.yellow("Google provider already exists"));
+      console.log(chalk7.yellow("Google provider already exists"));
       return;
     }
     const googleProviderEntry = `
@@ -492,7 +838,7 @@ var googleRun = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(chalk4.red("Failed to parse socialProviders block"));
+        console.log(chalk7.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + googleProviderEntry + "\n  " + content.slice(insertPos);
@@ -500,7 +846,7 @@ var googleRun = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          chalk4.red(
+          chalk7.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -516,12 +862,12 @@ ${googleProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    fs4.writeFileSync(authFilePath, content, "utf8");
-    const envPath = path4.join(projectDir, ".env");
-    if (fs4.existsSync(envPath)) {
-      const envContent = fs4.readFileSync(envPath, "utf8");
+    fs8.writeFileSync(authFilePath, content, "utf8");
+    const envPath = path8.join(projectDir, ".env");
+    if (fs8.existsSync(envPath)) {
+      const envContent = fs8.readFileSync(envPath, "utf8");
       if (!envContent.includes("GOOGLE_CLIENT_ID")) {
-        fs4.appendFileSync(
+        fs8.appendFileSync(
           envPath,
           `
 
@@ -532,53 +878,53 @@ GOOGLE_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = path4.resolve(
+    const componentTemplate = path8.resolve(
       __dirname,
       "./template/components/GoogleProviders.tsx"
     );
-    const componentsDir = path4.join(
+    const componentsDir = path8.join(
       projectDir,
       folder,
       "components",
       "authverse"
     );
-    if (!fs4.existsSync(componentsDir)) {
-      fs4.mkdirSync(componentsDir, { recursive: true });
+    if (!fs8.existsSync(componentsDir)) {
+      fs8.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = path4.join(componentsDir, "GoogleProviders.tsx");
-    if (fs4.existsSync(componentTemplate)) {
-      fs4.copyFileSync(componentTemplate, componentDest);
+    const componentDest = path8.join(componentsDir, "GoogleProviders.tsx");
+    if (fs8.existsSync(componentTemplate)) {
+      fs8.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(chalk4.green("Google provider added & merged successfully"));
+    console.log(chalk7.green("Google provider added & merged successfully"));
   } catch (error) {
-    console.log(chalk4.red("googleRun error:"), error);
+    console.log(chalk7.red("googleRun error:"), error);
   }
 };
 
 // script/githubRun.ts
-import chalk5 from "chalk";
-import fs5 from "fs";
-import path5 from "path";
-import { fileURLToPath as fileURLToPath5 } from "url";
+import chalk8 from "chalk";
+import fs9 from "fs";
+import path9 from "path";
+import { fileURLToPath as fileURLToPath8 } from "url";
 var githubRun = async () => {
   try {
-    const __filename = fileURLToPath5(import.meta.url);
-    const __dirname = path5.dirname(__filename);
+    const __filename = fileURLToPath8(import.meta.url);
+    const __dirname = path9.dirname(__filename);
     const projectDir = process.cwd();
-    const srcPath = path5.join(projectDir, "src");
-    const folder = fs5.existsSync(srcPath) ? "src" : "";
-    const authFilePath = path5.join(projectDir, folder, "lib", "auth.ts");
-    if (!fs5.existsSync(authFilePath)) {
-      console.log(chalk5.red("auth.ts file not found"));
+    const srcPath = path9.join(projectDir, "src");
+    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"));
       return;
     }
-    let content = fs5.readFileSync(authFilePath, "utf8");
+    let content = fs9.readFileSync(authFilePath, "utf8");
     if (!content.includes("betterAuth({")) {
-      console.log(chalk5.red("betterAuth({}) block not found"));
+      console.log(chalk8.red("betterAuth({}) block not found"));
       return;
     }
     if (content.includes("socialProviders") && content.includes("github:")) {
-      console.log(chalk5.yellow("GitHub provider already exists"));
+      console.log(chalk8.yellow("GitHub provider already exists"));
       return;
     }
     const githubProviderEntry = `
@@ -601,7 +947,7 @@ var githubRun = async () => {
         }
       }
       if (insertPos === -1) {
-        console.log(chalk5.red("Failed to parse socialProviders block"));
+        console.log(chalk8.red("Failed to parse socialProviders block"));
         return;
       }
       content = content.slice(0, insertPos) + githubProviderEntry + "\n  " + content.slice(insertPos);
@@ -609,7 +955,7 @@ var githubRun = async () => {
       const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
       if (!databaseRegex.test(content)) {
         console.log(
-          chalk5.red(
+          chalk8.red(
             "Could not find database adapter (prismaAdapter or drizzleAdapter)"
           )
         );
@@ -625,12 +971,12 @@ ${githubProviderEntry}
 ${socialProvidersBlock}`
       );
     }
-    fs5.writeFileSync(authFilePath, content, "utf8");
-    const envPath = path5.join(projectDir, ".env");
-    if (fs5.existsSync(envPath)) {
-      const envContent = fs5.readFileSync(envPath, "utf8");
+    fs9.writeFileSync(authFilePath, content, "utf8");
+    const envPath = path9.join(projectDir, ".env");
+    if (fs9.existsSync(envPath)) {
+      const envContent = fs9.readFileSync(envPath, "utf8");
       if (!envContent.includes("GITHUB_CLIENT_ID")) {
-        fs5.appendFileSync(
+        fs9.appendFileSync(
           envPath,
           `
 
@@ -641,70 +987,297 @@ GITHUB_CLIENT_SECRET=
         );
       }
     }
-    const componentTemplate = path5.resolve(
+    const componentTemplate = path9.resolve(
       __dirname,
       "./template/components/GithubProviders.tsx"
     );
-    const componentsDir = path5.join(
+    const componentsDir = path9.join(
       projectDir,
       folder,
       "components",
       "authverse"
     );
-    if (!fs5.existsSync(componentsDir)) {
-      fs5.mkdirSync(componentsDir, { recursive: true });
+    if (!fs9.existsSync(componentsDir)) {
+      fs9.mkdirSync(componentsDir, { recursive: true });
     }
-    const componentDest = path5.join(componentsDir, "GithubProviders.tsx");
-    if (fs5.existsSync(componentTemplate)) {
-      fs5.copyFileSync(componentTemplate, componentDest);
+    const componentDest = path9.join(componentsDir, "GithubProviders.tsx");
+    if (fs9.existsSync(componentTemplate)) {
+      fs9.copyFileSync(componentTemplate, componentDest);
     }
-    console.log(chalk5.green("GitHub provider added & merged successfully"));
+    console.log(chalk8.green("GitHub provider added & merged successfully"));
   } catch (error) {
-    console.log(chalk5.red("githubRun error:"), error);
+    console.log(chalk8.red("githubRun error:"), error);
+  }
+};
+
+// cli/provider.ts
+import path12 from "path";
+import fs12 from "fs";
+
+// script/googleRunTanstackState.ts
+import chalk9 from "chalk";
+import fs10 from "fs";
+import path10 from "path";
+import { fileURLToPath as fileURLToPath9 } from "url";
+var googleRunTanstackState = async () => {
+  try {
+    const __filename = fileURLToPath9(import.meta.url);
+    const __dirname = path10.dirname(__filename);
+    const projectDir = process.cwd();
+    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"));
+      return;
+    }
+    let content = fs10.readFileSync(authFilePath, "utf8");
+    if (!content.includes("betterAuth({")) {
+      console.log(chalk9.red("betterAuth({}) block not found"));
+      return;
+    }
+    if (content.includes("socialProviders") && content.includes("google:")) {
+      console.log(chalk9.yellow("Google provider already exists"));
+      return;
+    }
+    const googleProviderEntry = `
+    google: {
+      clientId: process.env.GOOGLE_CLIENT_ID as string,
+      clientSecret: process.env.GOOGLE_CLIENT_SECRET as string,
+    },`;
+    if (content.includes("socialProviders: {")) {
+      const start = content.indexOf("socialProviders: {");
+      let braceCount = 0;
+      let insertPos = -1;
+      for (let i = start; i < content.length; i++) {
+        if (content[i] === "{") braceCount++;
+        if (content[i] === "}") {
+          braceCount--;
+          if (braceCount === 0) {
+            insertPos = i;
+            break;
+          }
+        }
+      }
+      if (insertPos === -1) {
+        console.log(chalk9.red("Failed to parse socialProviders block"));
+        return;
+      }
+      content = content.slice(0, insertPos) + googleProviderEntry + "\n  " + content.slice(insertPos);
+    } else {
+      const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
+      if (!databaseRegex.test(content)) {
+        console.log(
+          chalk9.red(
+            "Could not find database adapter (prismaAdapter or drizzleAdapter)"
+          )
+        );
+        return;
+      }
+      const socialProvidersBlock = `
+  socialProviders: {
+${googleProviderEntry}
+  },`;
+      content = content.replace(
+        databaseRegex,
+        (match) => `${match}
+${socialProvidersBlock}`
+      );
+    }
+    fs10.writeFileSync(authFilePath, content, "utf8");
+    const envPath = path10.join(projectDir, ".env");
+    if (fs10.existsSync(envPath)) {
+      const envContent = fs10.readFileSync(envPath, "utf8");
+      if (!envContent.includes("GOOGLE_CLIENT_ID")) {
+        fs10.appendFileSync(
+          envPath,
+          `
+
+# Google OAuth
+GOOGLE_CLIENT_ID=
+GOOGLE_CLIENT_SECRET=
+`
+        );
+      }
+    }
+    const componentTemplate = path10.resolve(
+      __dirname,
+      "./template/TanstackState/components/GoogleProviders.tsx"
+    );
+    const componentsDir = path10.join(srcPath, "components", "authverse");
+    if (!fs10.existsSync(componentsDir)) {
+      fs10.mkdirSync(componentsDir, { recursive: true });
+    }
+    const componentDest = path10.join(componentsDir, "GoogleProviders.tsx");
+    if (fs10.existsSync(componentTemplate)) {
+      fs10.copyFileSync(componentTemplate, componentDest);
+    }
+    console.log(chalk9.green("Google provider added & merged successfully"));
+  } catch (error) {
+    console.log(chalk9.red("googleRunTanstackState error:"), error);
+  }
+};
+
+// script/githubRunTanstackState.ts
+import chalk10 from "chalk";
+import fs11 from "fs";
+import path11 from "path";
+import { fileURLToPath as fileURLToPath10 } from "url";
+var githubRunTanstackState = async () => {
+  try {
+    const __filename = fileURLToPath10(import.meta.url);
+    const __dirname = path11.dirname(__filename);
+    const projectDir = process.cwd();
+    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"));
+      return;
+    }
+    let content = fs11.readFileSync(authFilePath, "utf8");
+    if (!content.includes("betterAuth({")) {
+      console.log(chalk10.red("betterAuth({}) block not found"));
+      return;
+    }
+    if (content.includes("socialProviders") && content.includes("github:")) {
+      console.log(chalk10.yellow("Github provider already exists"));
+      return;
+    }
+    const githubProviderEntry = `
+    github: {
+      clientId: process.env.GITHUB_CLIENT_ID as string,
+      clientSecret: process.env.GITHUB_CLIENT_SECRET as string,
+    },`;
+    if (content.includes("socialProviders: {")) {
+      const start = content.indexOf("socialProviders: {");
+      let braceCount = 0;
+      let insertPos = -1;
+      for (let i = start; i < content.length; i++) {
+        if (content[i] === "{") braceCount++;
+        if (content[i] === "}") {
+          braceCount--;
+          if (braceCount === 0) {
+            insertPos = i;
+            break;
+          }
+        }
+      }
+      if (insertPos === -1) {
+        console.log(chalk10.red("Failed to parse socialProviders block"));
+        return;
+      }
+      content = content.slice(0, insertPos) + githubProviderEntry + "\n  " + content.slice(insertPos);
+    } else {
+      const databaseRegex = /database:\s*(prismaAdapter|drizzleAdapter)\([\s\S]*?\),/;
+      if (!databaseRegex.test(content)) {
+        console.log(
+          chalk10.red(
+            "Could not find database adapter (prismaAdapter or drizzleAdapter)"
+          )
+        );
+        return;
+      }
+      const socialProvidersBlock = `
+  socialProviders: {
+${githubProviderEntry}
+  },`;
+      content = content.replace(
+        databaseRegex,
+        (match) => `${match}
+${socialProvidersBlock}`
+      );
+    }
+    fs11.writeFileSync(authFilePath, content, "utf8");
+    const envPath = path11.join(projectDir, ".env");
+    if (fs11.existsSync(envPath)) {
+      const envContent = fs11.readFileSync(envPath, "utf8");
+      if (!envContent.includes("GITHUB_CLIENT_ID")) {
+        fs11.appendFileSync(
+          envPath,
+          `
+
+# Github OAuth
+GITHUB_CLIENT_ID=
+GITHUB_CLIENT_SECRET=
+`
+        );
+      }
+    }
+    const componentTemplate = path11.resolve(
+      __dirname,
+      "./template/TanstackState/components/GithubProviders.tsx"
+    );
+    const componentsDir = path11.join(srcPath, "components", "authverse");
+    if (!fs11.existsSync(componentsDir)) {
+      fs11.mkdirSync(componentsDir, { recursive: true });
+    }
+    const componentDest = path11.join(componentsDir, "GithubProviders.tsx");
+    if (fs11.existsSync(componentTemplate)) {
+      fs11.copyFileSync(componentTemplate, componentDest);
+    }
+    console.log(chalk10.green("Github provider added & merged successfully"));
+  } catch (error) {
+    console.log(chalk10.red("githubRunTanstackState error:"), error);
   }
 };
 
 // cli/provider.ts
 var providers = async ({ provider }) => {
   try {
-    if (provider == "google") {
+    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";
+    }
+    if (framework === "Next js" && provider == "google") {
       await googleRun();
-    } else if (provider == "github") {
+    } else if (framework === "Next js" && provider == "github") {
       await githubRun();
     }
+    if (framework === "tanstack state" && provider == "google") {
+      await googleRunTanstackState();
+    } else if (framework === "tanstack state" && provider == "github") {
+      await githubRunTanstackState();
+    }
   } catch (error) {
-    console.log(chalk6.red("Error adding provider:"), error);
+    console.log(chalk11.red("Error adding provider:"), error);
   }
 };
 
 // cli/forget.ts
-import chalk7 from "chalk";
-import path6 from "path";
-import { fileURLToPath as fileURLToPath6 } from "url";
-import fs6 from "fs";
-var forget = async () => {
+import path15 from "path";
+import fs15 from "fs";
+
+// script/forgetNext.ts
+import chalk12 from "chalk";
+import path13 from "path";
+import { fileURLToPath as fileURLToPath11 } from "url";
+import fs13 from "fs";
+var forgetNext = async () => {
   try {
     const projectDir = process.cwd();
-    const packageJsonPath = path6.join(projectDir, "package.json");
-    const packageJson2 = JSON.parse(fs6.readFileSync(packageJsonPath, "utf-8"));
+    const packageJsonPath = path13.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(fs13.readFileSync(packageJsonPath, "utf-8"));
     if (!packageJson2.dependencies?.resend) {
-      console.log(chalk7.cyan("\n\u2699\uFE0F Installing Resend...\n"));
+      console.log(chalk12.cyan("\n\u2699\uFE0F Installing Resend...\n"));
       packageManager("resend");
     }
     if (!packageJson2.dependencies?.["@react-email/components"]) {
-      console.log(chalk7.cyan("\n\u2699\uFE0F Installing react email components...\n"));
+      console.log(chalk12.cyan("\n\u2699\uFE0F Installing react email components...\n"));
       packageManager("@react-email/components");
     }
-    const __filename = fileURLToPath6(import.meta.url);
-    const __dirname = path6.dirname(__filename);
-    const srcPath = path6.join(projectDir, "src");
-    const folder = fs6.existsSync(srcPath) ? "src" : "";
-    const authFilePath = path6.join(projectDir, folder, "lib", "auth.ts");
-    if (!fs6.existsSync(authFilePath)) {
-      console.log(chalk7.red("auth.ts file not found."));
+    const __filename = fileURLToPath11(import.meta.url);
+    const __dirname = path13.dirname(__filename);
+    const srcPath = path13.join(projectDir, "src");
+    const folder = fs13.existsSync(srcPath) ? "src" : "";
+    const authFilePath = path13.join(projectDir, folder, "lib", "auth.ts");
+    if (!fs13.existsSync(authFilePath)) {
+      console.log(chalk12.red("auth.ts file not found."));
       return;
     }
-    let content = fs6.readFileSync(authFilePath, "utf8");
+    let content = fs13.readFileSync(authFilePath, "utf8");
     const codeAdded = `sendResetPassword: async ({ user, url, token }) => {
       await resend.emails.send({
         from: \`\${process.env.EMAIL_SENDER_NAME} <\${process.env.EMAIL_SENDER_ADDRESS}>\`,
@@ -749,7 +1322,7 @@ var forget = async () => {
         content = before + `
  ${codeAdded}` + after;
       }
-      fs6.writeFileSync(authFilePath, content, "utf8");
+      fs13.writeFileSync(authFilePath, content, "utf8");
       if (!content.includes("import { Resend }") && !content.includes("const resend = new Resend")) {
         const lastImportIndex = content.lastIndexOf("import");
         const nextLineAfterLastImport = content.indexOf("\n", lastImportIndex) + 1;
@@ -761,117 +1334,315 @@ import ForgotPasswordEmail from "@/components/email/reset-password";
 const resend = new Resend(process.env.RESEND_API_KEY as string);
 `;
         content = beforeImports + newImports + afterImports;
-        fs6.writeFileSync(authFilePath, content, "utf8");
+        fs13.writeFileSync(authFilePath, content, "utf8");
       }
-      const envPath = path6.join(projectDir, ".env");
-      const envContent = fs6.readFileSync(envPath, "utf8");
+      const envPath = path13.join(projectDir, ".env");
+      const envContent = fs13.readFileSync(envPath, "utf8");
       if (!envContent.includes("RESEND_API_KEY") && !envContent.includes("EMAIL_SENDER_NAME") && !envContent.includes("EMAIL_SENDER_ADDRESS")) {
-        fs6.appendFileSync(envPath, `
+        fs13.appendFileSync(envPath, `
 
 # Resend API Key for sending emails`);
-        fs6.appendFileSync(envPath, `
+        fs13.appendFileSync(envPath, `
 RESEND_API_KEY=`);
-        fs6.appendFileSync(envPath, `
+        fs13.appendFileSync(envPath, `
 EMAIL_SENDER_NAME=Your Name`);
-        fs6.appendFileSync(envPath, `
+        fs13.appendFileSync(envPath, `
 EMAIL_SENDER_ADDRESS=`);
       }
-      const componentPath = path6.resolve(
+      const componentPath = path13.resolve(
         __dirname,
         "./template/email/reset-password.tsx"
       );
-      const destinationPath = path6.join(
+      const destinationPath = path13.join(
         projectDir,
         folder,
         "components",
         "email"
       );
-      if (!fs6.existsSync(destinationPath)) {
-        fs6.mkdirSync(destinationPath, { recursive: true });
+      if (!fs13.existsSync(destinationPath)) {
+        fs13.mkdirSync(destinationPath, { recursive: true });
       }
-      const emailDestinationPath = path6.join(
+      const emailDestinationPath = path13.join(
         destinationPath,
         "reset-password.tsx"
       );
-      if (fs6.existsSync(componentPath)) {
-        fs6.copyFileSync(componentPath, emailDestinationPath);
+      if (fs13.existsSync(componentPath)) {
+        fs13.copyFileSync(componentPath, emailDestinationPath);
       }
-      const forgetComponentPath = path6.resolve(
+      const forgetComponentPath = path13.resolve(
         __dirname,
         "./template/components/ForgetComponent.tsx"
       );
-      const componentsDestinationPath = path6.join(
+      const componentsDestinationPath = path13.join(
         projectDir,
         folder,
         "components",
         "authverse"
       );
-      if (!fs6.existsSync(componentsDestinationPath)) {
-        fs6.mkdirSync(componentsDestinationPath, { recursive: true });
+      if (!fs13.existsSync(componentsDestinationPath)) {
+        fs13.mkdirSync(componentsDestinationPath, { recursive: true });
       }
-      const forgetDestinationPath = path6.join(
+      const forgetDestinationPath = path13.join(
         componentsDestinationPath,
         "ForgetComponent.tsx"
       );
-      if (fs6.existsSync(forgetComponentPath)) {
-        fs6.copyFileSync(forgetComponentPath, forgetDestinationPath);
+      if (fs13.existsSync(forgetComponentPath)) {
+        fs13.copyFileSync(forgetComponentPath, forgetDestinationPath);
       }
-      const resetComponentPath = path6.resolve(
+      const resetComponentPath = path13.resolve(
         __dirname,
         "./template/components/ResetComponent.tsx"
       );
-      const resetDestinationPath = path6.join(
+      const resetDestinationPath = path13.join(
         componentsDestinationPath,
         "ResetComponent.tsx"
       );
-      if (fs6.existsSync(resetComponentPath)) {
-        fs6.copyFileSync(resetComponentPath, resetDestinationPath);
+      if (fs13.existsSync(resetComponentPath)) {
+        fs13.copyFileSync(resetComponentPath, resetDestinationPath);
       }
-      const authTemplatePath = path6.resolve(
+      const authTemplatePath = path13.resolve(
         __dirname,
         "./template/app-auth-uiDesign"
       );
-      const appDestinationPath = path6.join(projectDir, folder, "app", "auth");
-      if (!fs6.existsSync(appDestinationPath)) {
-        fs6.mkdirSync(appDestinationPath, { recursive: true });
+      const appDestinationPath = path13.join(projectDir, folder, "app", "auth");
+      if (!fs13.existsSync(appDestinationPath)) {
+        fs13.mkdirSync(appDestinationPath, { recursive: true });
       }
-      const forgetDestinationDir = path6.join(appDestinationPath, "forget");
-      if (!fs6.existsSync(forgetDestinationDir)) {
-        fs6.mkdirSync(forgetDestinationDir, { recursive: true });
+      const forgetDestinationDir = path13.join(appDestinationPath, "forget");
+      if (!fs13.existsSync(forgetDestinationDir)) {
+        fs13.mkdirSync(forgetDestinationDir, { recursive: true });
       }
-      const forgetPageDestinationPath = path6.join(
+      const forgetPageDestinationPath = path13.join(
         forgetDestinationDir,
         "page.tsx"
       );
-      fs6.copyFileSync(
+      fs13.copyFileSync(
         `${authTemplatePath}/forget/page.tsx`,
         forgetPageDestinationPath
       );
-      const resetDestinationDir = path6.join(
+      const resetDestinationDir = path13.join(
         appDestinationPath,
         "reset-password"
       );
-      if (!fs6.existsSync(resetDestinationDir)) {
-        fs6.mkdirSync(resetDestinationDir, { recursive: true });
+      if (!fs13.existsSync(resetDestinationDir)) {
+        fs13.mkdirSync(resetDestinationDir, { recursive: true });
       }
-      const resetPageDestinationPath = path6.join(
+      const resetPageDestinationPath = path13.join(
         resetDestinationDir,
         "page.tsx"
       );
-      fs6.copyFileSync(
+      fs13.copyFileSync(
         `${authTemplatePath}/reset-password/page.tsx`,
         resetPageDestinationPath
       );
       console.log(
-        chalk7.green("Successfully added forget and reset-password pages")
+        chalk12.green("Successfully added forget and reset-password pages")
+      );
+    } else {
+      console.log(
+        chalk12.red("Could not find emailAndPassword configuration in auth.ts")
+      );
+    }
+  } catch (error) {
+    console.log(chalk12.red("Error adding sendResetPassword:"), error);
+  }
+};
+
+// script/forgetTanstack.ts
+import chalk13 from "chalk";
+import path14 from "path";
+import { fileURLToPath as fileURLToPath12 } from "url";
+import fs14 from "fs";
+var forgetTanstack = async () => {
+  try {
+    const projectDir = process.cwd();
+    const packageJsonPath = path14.join(projectDir, "package.json");
+    const packageJson2 = JSON.parse(fs14.readFileSync(packageJsonPath, "utf-8"));
+    if (!packageJson2.dependencies?.resend) {
+      console.log(chalk13.cyan("\n\u2699\uFE0F Installing Resend...\n"));
+      packageManager("resend");
+    }
+    if (!packageJson2.dependencies?.["@react-email/components"]) {
+      console.log(chalk13.cyan("\n\u2699\uFE0F Installing react email components...\n"));
+      packageManager("@react-email/components");
+    }
+    const __filename = fileURLToPath12(import.meta.url);
+    const __dirname = path14.dirname(__filename);
+    const srcPath = path14.join(projectDir, "src");
+    const authFilePath = path14.join(srcPath, "lib", "auth.ts");
+    if (!fs14.existsSync(authFilePath)) {
+      console.log(chalk13.red("auth.ts file not found."));
+      return;
+    }
+    let content = fs14.readFileSync(authFilePath, "utf8");
+    const codeAdded = `sendResetPassword: async ({ user, url, token }) => {
+      await resend.emails.send({
+        from: \`\${process.env.EMAIL_SENDER_NAME} <\${process.env.EMAIL_SENDER_ADDRESS}>\`,
+        to: user.email,
+        subject: "Reset your password",
+        react: ForgotPasswordEmail({
+          username: user.name,
+          resetUrl: url,
+          userEmail: user.email,
+        }),
+      });
+    },`;
+    if (content.includes("emailAndPassword: {")) {
+      const emailAndPasswordStart = content.indexOf("emailAndPassword: {");
+      let emailAndPasswordEnd = emailAndPasswordStart;
+      let braceCount = 0;
+      let inEmailAndPassword = false;
+      for (let i = emailAndPasswordStart; i < content.length; i++) {
+        if (content[i] === "{") {
+          braceCount++;
+          inEmailAndPassword = true;
+        } else if (content[i] === "}") {
+          braceCount--;
+          if (inEmailAndPassword && braceCount === 0) {
+            emailAndPasswordEnd = i;
+            break;
+          }
+        }
+      }
+      const emailAndPasswordContent = content.substring(
+        emailAndPasswordStart,
+        emailAndPasswordEnd
+      );
+      if (emailAndPasswordContent.includes("sendResetPassword:")) {
+        content = content.replace(
+          /sendResetPassword:\s*async\s*\([^)]*\)[^{]*\{[^}]*\}[^,]*/,
+          codeAdded
+        );
+      } else {
+        const before = content.substring(0, emailAndPasswordEnd);
+        const after = content.substring(emailAndPasswordEnd);
+        content = before + `
+ ${codeAdded}` + after;
+      }
+      fs14.writeFileSync(authFilePath, content, "utf8");
+      if (!content.includes("import { Resend }") && !content.includes("const resend = new Resend")) {
+        const lastImportIndex = content.lastIndexOf("import");
+        const nextLineAfterLastImport = content.indexOf("\n", lastImportIndex) + 1;
+        const beforeImports = content.substring(0, nextLineAfterLastImport);
+        const afterImports = content.substring(nextLineAfterLastImport);
+        const newImports = `import { Resend } from "resend";
+import ForgotPasswordEmail from "@/components/email/reset-password";
+
+const resend = new Resend(process.env.RESEND_API_KEY as string);
+`;
+        content = beforeImports + newImports + afterImports;
+        fs14.writeFileSync(authFilePath, content, "utf8");
+      }
+      const envPath = path14.join(projectDir, ".env");
+      const envContent = fs14.readFileSync(envPath, "utf8");
+      if (!envContent.includes("RESEND_API_KEY") && !envContent.includes("EMAIL_SENDER_NAME") && !envContent.includes("EMAIL_SENDER_ADDRESS")) {
+        fs14.appendFileSync(envPath, `
+
+# Resend API Key for sending emails`);
+        fs14.appendFileSync(envPath, `
+RESEND_API_KEY=`);
+        fs14.appendFileSync(envPath, `
+EMAIL_SENDER_NAME=Your Name`);
+        fs14.appendFileSync(envPath, `
+EMAIL_SENDER_ADDRESS=`);
+      }
+      const componentPath = path14.resolve(
+        __dirname,
+        "./template/email/reset-password.tsx"
+      );
+      const destinationPath = path14.join(srcPath, "components", "email");
+      if (!fs14.existsSync(destinationPath)) {
+        fs14.mkdirSync(destinationPath, { recursive: true });
+      }
+      const emailDestinationPath = path14.join(
+        destinationPath,
+        "reset-password.tsx"
+      );
+      if (fs14.existsSync(componentPath)) {
+        fs14.copyFileSync(componentPath, emailDestinationPath);
+      }
+      const forgetComponentPath = path14.resolve(
+        __dirname,
+        "./template/TanstackState/components/ForgetComponent.tsx"
+      );
+      const componentsDestinationPath = path14.join(
+        srcPath,
+        "components",
+        "authverse"
+      );
+      if (!fs14.existsSync(componentsDestinationPath)) {
+        fs14.mkdirSync(componentsDestinationPath, { recursive: true });
+      }
+      const forgetDestinationPath = path14.join(
+        componentsDestinationPath,
+        "ForgetComponent.tsx"
+      );
+      if (fs14.existsSync(forgetComponentPath)) {
+        fs14.copyFileSync(forgetComponentPath, forgetDestinationPath);
+      }
+      const resetComponentPath = path14.resolve(
+        __dirname,
+        "./template/TanstackState/components/ResetComponent.tsx"
+      );
+      const resetDestinationPath = path14.join(
+        componentsDestinationPath,
+        "ResetComponent.tsx"
+      );
+      if (fs14.existsSync(resetComponentPath)) {
+        fs14.copyFileSync(resetComponentPath, resetDestinationPath);
+      }
+      const authTemplatePath = path14.resolve(
+        __dirname,
+        "./template/TanstackState/routes/auth"
+      );
+      const routesDestinationPath = path14.join(srcPath, "routes", "auth");
+      if (!fs14.existsSync(routesDestinationPath)) {
+        fs14.mkdirSync(routesDestinationPath, { recursive: true });
+      }
+      const forgetPageDestinationPath = path14.join(
+        routesDestinationPath,
+        "forget.tsx"
+      );
+      fs14.copyFileSync(
+        `${authTemplatePath}/forget.tsx`,
+        forgetPageDestinationPath
+      );
+      const resetPageDestinationPath = path14.join(
+        routesDestinationPath,
+        "reset-password.tsx"
+      );
+      fs14.copyFileSync(
+        `${authTemplatePath}/reset-password.tsx`,
+        resetPageDestinationPath
+      );
+      console.log(
+        chalk13.green("Successfully added forget and reset-password pages")
       );
     } else {
       console.log(
-        chalk7.red("Could not find emailAndPassword configuration in auth.ts")
+        chalk13.red("Could not find emailAndPassword configuration in auth.ts")
       );
     }
   } catch (error) {
-    console.log(chalk7.red("Error adding sendResetPassword:"), error);
+    console.log(chalk13.red("Error adding sendResetPassword:"), error);
+  }
+};
+
+// cli/forget.ts
+var forget = () => {
+  const projectDir = process.cwd();
+  const packageJsonPath = path15.join(projectDir, "package.json");
+  let framework = "tanstack state";
+  if (fs15.existsSync(packageJsonPath)) {
+    const packageJson2 = JSON.parse(fs15.readFileSync(packageJsonPath, "utf-8"));
+    const hasNext = packageJson2?.dependencies?.["next"] || packageJson2?.devDependencies?.["next"];
+    framework = hasNext ? "Next js" : "tanstack state";
+  }
+  if (framework === "Next js") {
+    return forgetNext();
+  }
+  if (framework === "tanstack state") {
+    return forgetTanstack();
   }
 };
 
@@ -892,7 +1663,7 @@ function isNextJsProject() {
 }
 
 // index.ts
-import chalk8 from "chalk";
+import chalk14 from "chalk";
 var packageJson = JSON.parse(readFileSync2("./package.json", "utf8"));
 var program = new Command();
 program.name("authverse").description("CLI tool for creating authverse projects").version(
@@ -902,7 +1673,7 @@ program.name("authverse").description("CLI tool for creating authverse projects"
 );
 program.command("init").description("Select project template and configuration").action(() => {
   if (!isNextJsProject) {
-    console.log(chalk8.red("Only Next.js projects are supported."));
+    console.log(chalk14.red("Only Next.js projects are supported."));
     process.exit(1);
   }
   initAnswer();