rebar-js 1.0.0

package/dist/index.js

@@ -0,0 +1,1319 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/prompts/basic.ts
+import { select, input } from "@inquirer/prompts";
+
+// src/utils/display.ts
+var isColorSupported = process.stdout.isTTY && !process.env.NO_COLOR;
+var style = (open, close = 39) => {
+  const c = open === 1 ? 22 : open === 2 ? 22 : close;
+  return (s) => isColorSupported ? `\x1B[${open}m${s}\x1B[${c}m` : s;
+};
+var colors = {
+  cyan: style(36),
+  green: style(32),
+  red: style(31),
+  yellow: style(33),
+  blue: style(34),
+  magenta: style(35),
+  gray: style(90),
+  bold: style(1),
+  dim: style(2)
+};
+var SYM = {
+  check: "\u2713",
+  cross: "\u2717",
+  arrow: "\u276F",
+  bullet: "\u25CF"
+};
+function banner() {
+  console.log(`
+  ${colors.cyan(colors.bold("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"))}
+  ${colors.cyan("\u2551")}          ${colors.magenta(colors.bold("R E B A R"))}           ${colors.cyan("\u2551")}
+  ${colors.cyan("\u2551")}    ${colors.gray("project scaffold CLI")}      ${colors.cyan("\u2551")}
+  ${colors.cyan(colors.bold("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2559"))}
+  `);
+}
+function step(num, msg) {
+  console.log(`
+  ${colors.cyan(colors.bold(`${SYM.arrow} Step ${num}`))}${colors.gray(":")} ${colors.bold(msg)}`);
+  console.log(colors.gray(`  ${"\u2500".repeat(50)}`));
+}
+function success(msg) {
+  console.log(`  ${colors.green(`${SYM.check} ${msg}`)}`);
+}
+function error(msg) {
+  console.log(`  ${colors.red(`${SYM.cross} ${msg}`)}`);
+}
+function info(msg) {
+  console.log(`  ${colors.blue("\u2139")} ${msg}`);
+}
+function done() {
+  console.log(`
+  ${colors.green(colors.bold(`${SYM.check} All done!`))}
+  ${colors.gray("Happy coding!")}
+  `);
+}
+
+// src/prompts/basic.ts
+async function choosePackageManager() {
+  return await select({
+    message: `${colors.cyan("\u276F")} Pick a package manager`,
+    choices: [
+      {
+        name: "npm",
+        value: "npm",
+        description: "Node package manager"
+      },
+      {
+        name: "yarn",
+        value: "yarn",
+        description: "Fast, reliable, and secure dependency management"
+      },
+      {
+        name: "bun",
+        value: "bun",
+        description: "All-in-one JavaScript runtime & package manager"
+      },
+      {
+        name: "pnpm",
+        value: "pnpm",
+        description: "Fast, disk-space efficient package manager",
+        disabled: "(not supported \u2014 pnpm install --ignore-scripts breaks builds)"
+      }
+    ]
+  });
+}
+async function chooseFramework(manager) {
+  return await select({
+    message: `${colors.cyan("\u276F")} Pick a framework`,
+    choices: [
+      {
+        name: "Next.js",
+        value: "nextjs",
+        description: "React framework with SSR, app router, and more",
+        disabled: manager === "pnpm" ? "(not recommended with pnpm)" : false
+      },
+      {
+        name: "Vite (React)",
+        value: "vite",
+        description: "Lightning-fast React SPA with Vite"
+      },
+      {
+        name: "Express",
+        value: "express",
+        description: "Minimalist Node.js backend framework"
+      },
+      {
+        name: "Expo",
+        value: "expo",
+        description: "Universal React Native apps for iOS, Android, and web"
+      },
+      {
+        name: "Electron",
+        value: "electron",
+        description: "Desktop apps with web technologies",
+        disabled: manager === "bun" ? "(not supported with bun)" : false
+      }
+    ]
+  });
+}
+async function typeProjectName() {
+  const str = await input({
+    message: `${colors.cyan("\u276F")} Project name`,
+    default: "my-app"
+  });
+  return str.trim() || "my-app";
+}
+
+// src/prompts/electronFramework.ts
+import { select as select2 } from "@inquirer/prompts";
+var electronFramework = async () => {
+  return await select2({
+    message: `${colors.cyan("\u276F")} Pick a build tool for Electron`,
+    choices: [
+      {
+        name: "Electron Forge",
+        value: "electron forge",
+        description: "Official all-in-one toolchain for Electron"
+      },
+      {
+        name: "Electron Vite",
+        value: "electron vite",
+        description: "Fast HMR with Vite for Electron"
+      }
+    ]
+  });
+};
+
+// src/setup/electron.ts
+import { spawn } from "child_process";
+var buildElectronApp = async (manager) => {
+  step(1, "Build tool");
+  await electronFramework();
+  step(2, "Scaffolding Electron app");
+  info("Launching interactive Electron quick-start...\n");
+  const child = spawn(manager, ["create", "@quick-start/electron"], {
+    stdio: "inherit",
+    cwd: process.cwd(),
+    shell: true
+  });
+  child.on("close", (code) => process.exit(code ?? 0));
+};
+
+// src/setup/expo.ts
+import { spawn as spawn2 } from "child_process";
+var buildExpoApp = (manager) => {
+  step(1, "Scaffolding Expo app");
+  info("Launching interactive Expo setup...\n");
+  const child = spawn2(
+    manager === "npm" ? "npx" : manager,
+    ["create", "expo-app"],
+    {
+      stdio: "inherit",
+      shell: true,
+      cwd: process.cwd()
+    }
+  );
+  child.on("close", (code) => {
+    process.exit(code ?? 0);
+  });
+};
+
+// src/prompts/express.ts
+import { checkbox } from "@inquirer/prompts";
+var expressPrompts = async (manager) => {
+  return await checkbox({
+    message: `${colors.cyan("\u276F")} Extra tools to include`,
+    choices: [
+      {
+        name: "TypeScript",
+        value: "typescript",
+        description: "Static type checking for safer code",
+        disabled: manager === "bun" ? "Always enabled with bun" : false,
+        checked: manager === "bun" ? true : false
+      },
+      {
+        name: "Git",
+        value: "git",
+        description: "Initialize a git repository"
+      },
+      {
+        name: "ESLint",
+        value: "eslint",
+        description: "Code quality & consistency"
+      },
+      {
+        name: "Path Aliasing (@/*)",
+        value: "pathAliasing",
+        description: "Clean imports with @/ prefix"
+      }
+    ]
+  });
+};
+
+// src/scripts/common.ts
+import { execSync } from "child_process";
+import fs, { mkdirSync, existsSync, unlinkSync, writeFileSync, readFileSync } from "fs";
+import path from "path";
+
+// src/constants/common.ts
+var gitignore = `
+/node_modules
+/.pnp
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/versions
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+/dist
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# env files (can opt-in for committing if needed)
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts
+
+drizzle
+`;
+
+// src/scripts/common.ts
+var initializeProject = (manager) => {
+  const command = manager === "pnpm" ? `${manager} init` : `${manager} init -y`;
+  execSync(command, {
+    stdio: "inherit"
+  });
+  if (manager !== "bun") {
+    execSync(`npm  pkg set type=module`, {
+      stdio: "inherit"
+    });
+  }
+};
+var createRepo = (name) => {
+  if (!existsSync(name))
+    mkdirSync(name, { recursive: true });
+};
+var createRepoAndCd = (name) => {
+  process.chdir(path.resolve(name));
+};
+var changeDir = (name) => {
+  process.chdir(path.resolve(name));
+};
+var removeFile = (name) => {
+  if (existsSync(name)) {
+    unlinkSync(name);
+  }
+};
+var writeData = (name, data) => {
+  const dir = name.split("/").slice(0, -1).join("/");
+  if (dir) createRepo(dir);
+  writeFileSync(name, data);
+};
+var addPackage = (manager, packageName) => {
+  const command = manager === "npm" ? `npm i ${packageName}` : `${manager} add ${packageName}`;
+  execSync(command, {
+    stdio: "inherit"
+  });
+};
+var addDevPackage = (manager, packageName) => {
+  const command = manager === "npm" ? `npm i -D ${packageName}` : `${manager} add -D ${packageName}`;
+  execSync(command, {
+    stdio: "inherit"
+  });
+};
+var packageExecutor = (manager, pkg) => {
+  const exeMap = {
+    npm: "npx",
+    pnpm: "npx",
+    yarn: "npx",
+    bun: "bunx"
+  };
+  const executor = exeMap[manager];
+  execSync(`${executor} ${pkg}`, {
+    stdio: "inherit"
+  });
+};
+var moduleExecutor = (manager, command) => {
+  const exeMap = {
+    npm: "npx",
+    pnpm: "npx",
+    yarn: "npx",
+    bun: "bunx"
+  };
+  const executor = exeMap[manager];
+  execSync(`${executor} ${command}`, {
+    stdio: "inherit"
+  });
+};
+var addScripts = (scripts) => {
+  const path2 = "./package.json";
+  const pkg = JSON.parse(fs.readFileSync(path2, "utf-8"));
+  pkg.scripts = pkg.scripts || {};
+  scripts.forEach((prop) => {
+    pkg.scripts[prop.key] = prop.command;
+  });
+  writeData(path2, JSON.stringify(pkg, null, 2));
+};
+var initializeGit = (git) => {
+  if (git) {
+    writeData(".gitignore", gitignore);
+    execSync("git init", {
+      stdio: "inherit"
+    });
+  }
+  return;
+};
+var pathAliasingConfig = (filename, language) => {
+  let file;
+  if (language === "ts") {
+    file = JSON.parse(readFileSync(filename, "utf-8"));
+  } else {
+    file = {
+      compilerOptions: {}
+    };
+  }
+  const compiler = file.compilerOptions || {};
+  compiler.paths = compiler.paths || {};
+  const key = "@/*";
+  compiler.paths[key] = ["./src/*"];
+  file.compilerOptions = compiler;
+  writeData(filename, JSON.stringify(file, null, 2));
+};
+
+// src/scripts/express.ts
+import { writeFile } from "fs/promises";
+
+// src/constants/express.ts
+var tsconfig = `{
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist",
+
+    "target": "ESNext",
+    "module": "NodeNext",
+
+    "strict": true,
+    "moduleDetection": "force",
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+
+    "skipLibCheck": true,
+    "types": []
+  },
+  "include": ["src"],
+  "exclude": ["dist", "node_modules"]
+}`;
+var expressBoilerplate = (language) => {
+  if (language === "ts") {
+    return `
+import express, { type Request, type Response } from "express";
+
+const app = express();
+
+app.get("/", (_req: Request, res: Response) => {
+  res.send("Hello World!");
+});
+
+app.listen(3000, () => {
+  console.log("Example app listening on port 3000");
+});
+`;
+  }
+  return `
+import express from "express";
+
+const app = express();
+
+app.get("/", (_req, res) => {
+  res.send("Hello World!");
+});
+
+app.listen(3000, () => {
+  console.log("Example app listening on port 3000");
+});
+`;
+};
+var eslint = (language) => {
+  if (language === "ts") {
+    return `
+import js from "@eslint/js";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+
+export default [
+ js.configs.recommended,
+ ...tseslint.configs.recommended,
+
+ {
+   files: ["**/*.ts"],
+
+   languageOptions: {
+     parser: tseslint.parser,
+
+     parserOptions: {
+       project: "./tsconfig.json",
+     },
+
+     globals: {
+       ...globals.node,
+     },
+   },
+
+   rules: {
+     "@typescript-eslint/no-unused-vars": [
+       "warn",
+       {
+         argsIgnorePattern: "^_",
+         varsIgnorePattern: "^_",
+       },
+     ],
+
+     "@typescript-eslint/consistent-type-imports": "warn",
+
+     "no-console": "off",
+     "eqeqeq": ["error", "always"],
+     "curly": ["error", "all"],
+     "prefer-const": "warn",
+   },
+ },
+
+ {
+   ignores: [
+     "node_modules",
+     "dist",
+     "build",
+     "coverage",
+   ],
+ },
+];
+`;
+  }
+  return `
+    import js from "@eslint/js";
+    import globals from "globals";
+    
+    export default [
+      js.configs.recommended,
+    
+      {
+        files: ["**/*.js"],
+    
+        languageOptions: {
+          ecmaVersion: "latest",
+          sourceType: "module",
+    
+          globals: {
+            ...globals.node,
+          },
+        },
+    
+        rules: {
+          // code quality
+          "no-unused-vars": [
+            "warn",
+            {
+              argsIgnorePattern: "^_",
+              varsIgnorePattern: "^_",
+            },
+          ],
+    
+          "no-console": "off",
+          "no-debugger": "warn",
+    
+          // async/backend safety
+          "no-async-promise-executor": "error",
+          "require-await": "warn",
+    
+          // style-ish
+          "object-shorthand": "warn",
+          "prefer-const": "warn",
+    
+          // common backend mistakes
+          "eqeqeq": ["error", "always"],
+          "curly": ["error", "all"],
+    
+          // imports
+          "no-duplicate-imports": "error",
+        },
+      },
+    
+      {
+        ignores: [
+          "node_modules",
+          "dist",
+          "build",
+          "coverage",
+          ".env",
+        ],
+      },
+    ];
+    `;
+};
+
+// src/scripts/express.ts
+var expressServer = async ({ manager, ts }) => {
+  initializeProject(manager);
+  removeFile("index.ts");
+  addPackage(manager, "express@5.2.1");
+  createRepo("src");
+  if (ts) {
+    addDevPackage(manager, "typescript@5.9.3 tsx@4.21.0 nodemon@3.1.9 @types/node@25.6.2 @types/express@5.0.6");
+    moduleExecutor(manager, "tsc --init");
+    await writeFile("src/index.ts", expressBoilerplate("ts"));
+    await writeFile("tsconfig.json", tsconfig);
+    addDevScripts(ts, manager === "bun" ? "bun" : "node");
+  } else {
+    await writeFile("src/index.js", expressBoilerplate("js"));
+    addDevScripts(ts, manager === "bun" ? "bun" : "node");
+  }
+};
+var addDevScripts = (ts, runtime) => {
+  const scripts = [];
+  if (ts === true) {
+    scripts.push(
+      {
+        key: "build",
+        command: "tsc"
+      },
+      {
+        key: "start",
+        command: `${runtime} dist/index.js`
+      },
+      {
+        key: "dev",
+        command: "tsx src/index.ts"
+      }
+    );
+  } else {
+    scripts.push(
+      {
+        key: "start",
+        command: `${runtime} src/index.js`
+      }
+    );
+  }
+  addScripts(scripts);
+};
+var addEslint = ({ eslint: eslint2, ts, manager }) => {
+  if (!eslint2) {
+    return;
+  }
+  if (ts) {
+    addDevPackage(manager, "eslint@9.26.0 @eslint/js@9.26.0 globals@16.0.0 typescript@5.9.3 typescript-eslint@8.59.2 jiti@2.7.0");
+    writeData("eslint.config.js", eslint("ts"));
+  } else {
+    addDevPackage(manager, "eslint@9.26.0 @eslint/js@9.26.0 globals@16.0.0");
+    writeData("eslint.config.js", eslint("js"));
+  }
+  const scripts = [];
+  scripts.push(
+    {
+      key: "lint",
+      command: "eslint ."
+    },
+    {
+      key: "lint:fix",
+      command: "eslint . --fix"
+    }
+  );
+  addScripts(scripts);
+};
+var expressPathAliasing = ({ ts, pathAliasing }) => {
+  if (!pathAliasing) {
+    return;
+  }
+  if (ts) {
+    pathAliasingConfig("tsconfig.json", "ts");
+  } else {
+    pathAliasingConfig("jsconfig.json", "js");
+  }
+};
+
+// src/setup/express.ts
+var buildExpressApp = async (manager) => {
+  step(1, "Project name");
+  const name = await typeProjectName();
+  step(2, "Extra tools");
+  const answers = await expressPrompts(manager);
+  const ts = answers.includes("typescript");
+  const git = answers.includes("git");
+  const eslint2 = answers.includes("eslint");
+  const pathAliasing = answers.includes("pathAliasing");
+  step(3, "Creating project directory");
+  createRepoAndCd(name);
+  step(4, "Setting up Express server");
+  await expressServer({ manager, ts });
+  success("Express project created");
+  if (git) {
+    step(5, "Initializing Git repository");
+    initializeGit(git);
+    success("Git repository initialized");
+  }
+  if (eslint2) {
+    step(6, "Setting up ESLint");
+    addEslint({ eslint: eslint2, ts, manager });
+    success("ESLint configured");
+  }
+  if (pathAliasing) {
+    step(7, "Setting up path aliasing");
+    expressPathAliasing({ ts, pathAliasing });
+    success("Path aliasing configured");
+  }
+  done();
+};
+
+// src/prompts/nextjs.ts
+import { checkbox as checkbox2, select as select3 } from "@inquirer/prompts";
+var nextChoices = {
+  husky: { name: "Husky", description: "Git hooks made easy" },
+  shadcn: { name: "shadcn/ui", description: "Beautifully designed React components" },
+  trpc: { name: "tRPC", description: "End-to-end typesafe APIs" },
+  Drizzle: { name: "Drizzle ORM", description: "TypeScript ORM for SQL" },
+  reactCompiler: { name: "React Compiler", description: "Optimize React rendering" },
+  betterAuth: { name: "Better Auth", description: "Authentication framework (auto-includes Drizzle)" }
+};
+var nextjsChoices = async () => {
+  const answers = await checkbox2({
+    message: `${colors.cyan("\u276F")} Extra tools to include`,
+    choices: Object.entries(nextChoices).map(
+      ([value, meta]) => ({
+        name: meta.name,
+        value,
+        description: meta.description
+      })
+    )
+  });
+  const selected = new Set(answers);
+  if (selected.has("betterAuth")) {
+    selected.add("Drizzle");
+  }
+  return Array.from(selected);
+};
+var linter = async () => {
+  return await select3({
+    message: `${colors.cyan("\u276F")} Pick a linter`,
+    choices: [
+      { name: "ESLint", value: "eslint", description: "Standard linter with rich ecosystem" },
+      { name: "Biome", value: "biome", description: "Fast, modern linter & formatter" },
+      { name: "None", value: "None", description: "Skip linter setup" }
+    ]
+  });
+};
+
+// src/scripts/nextjs.ts
+import { execSync as execSync2 } from "child_process";
+import { appendFileSync, readFileSync as readFileSync2 } from "fs";
+var scaffoldCommandMap = {
+  npm: "npx create-next-app@latest",
+  pnpm: "pnpm create next-app",
+  yarn: "yarn create next-app",
+  bun: "bunx create-next-app"
+};
+var buildFlags = (answer, linter2) => {
+  const flagsArray = ["--tailwind", "--ts", "--src-dir", "--app", "--no-agents-md", "--skip-install", `--import-alias "@/*"`];
+  if (answer.includes("reactCompiler")) flagsArray.push("--react-compiler");
+  else flagsArray.push("--no-react-compiler");
+  switch (linter2) {
+    case "biome":
+      flagsArray.push("--biome");
+      break;
+    case "eslint":
+      flagsArray.push("--eslint");
+      break;
+    default:
+      flagsArray.push("--no-eslint");
+  }
+  return flagsArray;
+};
+var installNextApp = (manager, flagsArray, name) => {
+  if (manager === "pnpm")
+    flagsArray.push("--skip-install");
+  const flagString = flagsArray.join(" ");
+  const scaffoldCommand = `${scaffoldCommandMap[manager]} ${name} ${flagString} `;
+  execSync2(scaffoldCommand, {
+    stdio: "inherit"
+  });
+  changeDir(name);
+  if (manager === "pnpm") {
+    execSync2("pnpm install --config.ignore-scripts=false --no-frozen-lockfile", {
+      stdio: "inherit"
+    });
+  }
+};
+var shadcnInstall = (manager, shadcn) => {
+  if (!shadcn) return;
+  packageExecutor(manager, "shadcn@latest init --preset b0 --template next");
+  packageExecutor(manager, "shadcn@latest add --all");
+};
+var trpcSetup = (manager, trpc) => {
+  if (!trpc) return;
+  addPackage(
+    manager,
+    "@trpc/server@11.17.0 @trpc/client@11.17.0 @trpc/react-query@11.17.0 @trpc/next@11.17.0 @tanstack/react-query@5.100.10 superjson@2.2.5 zod@3.24.3"
+  );
+  createRepo("src/server/routers");
+  writeData(
+    "src/server/trpc.ts",
+    `import { initTRPC } from "@trpc/server"
+import superjson from "superjson"
+import { ZodError } from "zod"
+
+const t = initTRPC.create({
+  transformer: superjson,
+  errorFormatter({ shape, error }) {
+    return {
+      ...shape,
+      data: {
+        ...shape.data,
+        zodError: error.cause instanceof ZodError ? error.cause.flatten() : null,
+      },
+    }
+  },
+})
+
+export const createTRPCRouter = t.router
+export const publicProcedure = t.procedure`
+  );
+  writeData(
+    "src/server/routers/_app.ts",
+    `import { createTRPCRouter } from "@/server/trpc"
+
+export const appRouter = createTRPCRouter({})
+
+export type AppRouter = typeof appRouter`
+  );
+  createRepo("src/trpc");
+  writeData(
+    "src/trpc/react.tsx",
+    `"use client"
+
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query"
+import { loggerLink, unstable_httpBatchStreamLink } from "@trpc/client"
+import { createTRPCReact } from "@trpc/react-query"
+import { useState } from "react"
+import type { AppRouter } from "@/server/routers/_app"
+import superjson from "superjson"
+
+export const trpc = createTRPCReact<AppRouter>()
+
+function getBaseUrl() {
+  if (typeof window !== "undefined") return ""
+  if (process.env.VERCEL_URL) return "https://" + process.env.VERCEL_URL
+  return "http://localhost:" + (process.env.PORT ?? 3000)
+}
+
+export function TRPCReactProvider(props: { children: React.ReactNode }) {
+  const [queryClient] = useState(() => new QueryClient())
+  const [trpcClient] = useState(() =>
+    trpc.createClient({
+      links: [
+        loggerLink({
+          enabled: (op) =>
+            process.env.NODE_ENV === "development" ||
+            (op.direction === "down" && op.result instanceof Error),
+        }),
+        unstable_httpBatchStreamLink({
+          transformer: superjson,
+          url: getBaseUrl() + "/api/trpc",
+        }),
+      ],
+    })
+  )
+
+  return (
+    <QueryClientProvider client={queryClient}>
+      <trpc.Provider client={trpcClient} queryClient={queryClient}>
+        {props.children}
+      </trpc.Provider>
+    </QueryClientProvider>
+  )
+}`
+  );
+  writeData(
+    "src/trpc/server.ts",
+    `import { createTRPCClient, httpBatchLink } from "@trpc/client"
+import type { AppRouter } from "@/server/routers/_app"
+import superjson from "superjson"
+
+export const trpc = createTRPCClient<AppRouter>({
+  links: [
+    httpBatchLink({
+      url: "/api/trpc",
+      transformer: superjson,
+    }),
+  ],
+})`
+  );
+  createRepo("src/app/api/trpc/[trpc]");
+  writeData(
+    "src/app/api/trpc/[trpc]/route.ts",
+    `import { fetchRequestHandler } from "@trpc/server/adapters/fetch"
+import { appRouter } from "@/server/routers/_app"
+
+const handler = (req: Request) =>
+  fetchRequestHandler({
+    endpoint: "/api/trpc",
+    req,
+    router: appRouter,
+  })
+
+export { handler as GET, handler as POST }`
+  );
+  const layoutPath = "src/app/layout.tsx";
+  const layout = readFileSync2(layoutPath, "utf-8");
+  const updated = layout.replace(
+    'import "./globals.css"',
+    'import "./globals.css"\nimport { TRPCReactProvider } from "@/trpc/react"'
+  ).replace(
+    /\{children\}(\s*)(<\/body>)/,
+    "<TRPCReactProvider>{children}</TRPCReactProvider>$1$2"
+  );
+  writeData(layoutPath, updated);
+};
+var drizzleSetup = (manager, drizzle) => {
+  if (!drizzle) return;
+  addPackage(manager, "drizzle-orm@0.45.2 pg@9.6.0");
+  addDevPackage(manager, "drizzle-kit@0.31.10 tsx@4.21.0 @types/pg@latest");
+  appendFileSync(".env", "DATABASE_URL=\n");
+  writeData(
+    "drizzle.config.ts",
+    `import { defineConfig } from "drizzle-kit"
+export default defineConfig({
+  schema: "./src/db/schema",
+  out: "./drizzle",
+  dialect: "postgresql",
+  dbCredentials: { url: process.env.DATABASE_URL | "" },
+})`
+  );
+  createRepo("src/db");
+  writeData(
+    "src/db/schema/user.ts",
+    `import { integer, pgTable, varchar } from "drizzle-orm/pg-core";
+  export const usersTable = pgTable("users", {
+    id: integer().primaryKey().generatedAlwaysAsIdentity(),
+    name: varchar().notNull(),
+    age: integer().notNull(),
+    email: varchar().notNull().unique(),
+  });`
+  );
+  writeData(
+    "src/config/db.ts",
+    `import { drizzle } from "drizzle-orm/node-postgres";
+  import { Pool } from "pg";
+  const pool = new Pool({
+    connectionString: process.env.DATABASE_URL!,
+  });
+  export const db = drizzle({ client: pool });`
+  );
+  addScripts([
+    {
+      key: "db:generate",
+      command: "drizzle-kit generate"
+    },
+    {
+      key: "db:migrate",
+      command: "drizzle-kit migrate"
+    },
+    {
+      key: "db:push",
+      command: "drizzle-kit push"
+    }
+  ]);
+};
+var huskySetup = (manager, husky) => {
+  if (!husky) return;
+  addDevPackage(manager, "husky@9.1.7");
+  packageExecutor(manager, "husky init");
+};
+var authSetup = (manager, auth) => {
+  if (!auth) return;
+  createRepo("src/lib");
+  addPackage(manager, "better-auth@1.6.9");
+  appendFileSync(".env", "BETTER_AUTH_URL=http://localhost:3000\nBETTER_AUTH_SECRET=0zNTvTuWUIH0rBOSbVTofnA6Ojq4zcHCl+INhkkiGy8=\n");
+  const authContent = `import { betterAuth } from "better-auth";
+      import { drizzleAdapter } from "better-auth/adapters/drizzle";
+      import { db } from "@/config/db"; 
+      export const auth = betterAuth({
+          database: drizzleAdapter(db, {
+              provider: "pg", 
+          }),
+          emailAndPassword: { 
+             enabled: true, 
+           },  socialProviders: { 
+              github: { 
+                clientId: process.env.GITHUB_CLIENT_ID as string, 
+                clientSecret: process.env.GITHUB_CLIENT_SECRET as string, 
+              }, 
+            }, 
+      });`;
+  writeData("src/lib/auth.ts", authContent);
+  removeFile("src/db/schema/user.ts");
+  packageExecutor(manager, `auth@latest generate --output "src/db/schema/user.ts" --yes`);
+  createRepo("src/app/api/auth/[...all]");
+  writeData(
+    "src/app/api/auth/[...all]/route.ts",
+    `import { auth } from "@/lib/auth"
+import { toNextJsHandler } from "better-auth/next-js"
+export const { POST, GET } = toNextJsHandler(auth)`
+  );
+  writeData("src/lib/auth-client.ts", `
+    import { createAuthClient } from "better-auth/react"
+    export const authClient = createAuthClient({
+        /** The base URL of the server (optional if you're using the same domain) */
+        baseURL: "http://localhost:3000"
+    })
+    `);
+};
+
+// src/setup/nextjs.ts
+var buildNextApp = async (manager) => {
+  step(1, "Project name");
+  const name = await typeProjectName();
+  step(2, "Extra tools");
+  const choices = await nextjsChoices();
+  step(3, "Linter");
+  const linterChoice = await linter();
+  const trpc = choices.includes("trpc");
+  const shadcn = choices.includes("shadcn");
+  const drizzle = choices.includes("Drizzle");
+  const husky = choices.includes("husky");
+  const auth = choices.includes("betterAuth");
+  step(4, "Scaffolding Next.js project");
+  const flags = buildFlags(choices, linterChoice);
+  installNextApp(manager, flags, name);
+  success("Next.js project created");
+  if (shadcn) {
+    step(5, "Installing shadcn/ui");
+    shadcnInstall(manager, shadcn);
+    success("shadcn/ui installed");
+  }
+  if (trpc) {
+    step(6, "Setting up tRPC");
+    trpcSetup(manager, trpc);
+    success("tRPC configured");
+  }
+  if (drizzle) {
+    step(7, "Setting up Drizzle ORM");
+    drizzleSetup(manager, drizzle);
+    success("Drizzle ORM configured");
+  }
+  if (husky) {
+    step(8, "Setting up Husky");
+    huskySetup(manager, husky);
+    success("Husky configured");
+  }
+  if (auth) {
+    step(9, "Setting up Better Auth");
+    authSetup(manager, auth);
+    success("Better Auth configured");
+  }
+  done();
+};
+
+// src/prompts/vite.ts
+import { checkbox as checkbox3 } from "@inquirer/prompts";
+var viteChoices = async () => {
+  const answers = await checkbox3({
+    message: `${colors.cyan("\u276F")} Extra tools to include`,
+    choices: [
+      {
+        name: "TypeScript",
+        value: "typescript",
+        description: "Static type checking"
+      },
+      {
+        name: "Path Aliasing (@/ imports)",
+        value: "pathAlising",
+        description: "Clean imports with @/ prefix (required for shadcn)"
+      },
+      {
+        name: "React Compiler",
+        value: "reactCompiler",
+        description: "Optimize React rendering automatically"
+      },
+      {
+        name: "Tailwind CSS",
+        value: "tailwind",
+        description: "Utility-first CSS framework"
+      },
+      {
+        name: "shadcn/ui",
+        value: "shadcn",
+        description: "Beautiful React components (auto-includes TS + Tailwind)"
+      },
+      {
+        name: "React Router",
+        value: "reactRouter",
+        description: "Client-side routing for SPAs"
+      }
+    ]
+  });
+  const selected = new Set(answers);
+  if (selected.has("shadcn")) {
+    selected.add("typescript");
+    selected.add("tailwind");
+  }
+  return Array.from(selected);
+};
+
+// src/scripts/vite.ts
+import { execSync as execSync3 } from "child_process";
+import { readFileSync as readFileSync3 } from "fs";
+
+// src/constants/vite.ts
+var reactRouterEntry = (language) => {
+  const appImport = language === "ts" ? `import App from "./App";` : `import App from "./App";`;
+  return `
+import ReactDOM from "react-dom/client";
+import { createBrowserRouter, RouterProvider } from "react-router";
+${appImport}
+const router = createBrowserRouter([
+  {
+    path: "/",
+    Component: App,
+  },
+]);
+
+const root = document.getElementById("root");
+
+if (!root) {
+  throw new Error("Root element not found");
+}
+
+ReactDOM.createRoot(root).render(<RouterProvider router={router} />);
+ `;
+};
+var viteAppTsconfig = () => {
+  return `
+{
+    "compilerOptions": {
+      "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+      "target": "es2023",
+      "lib": ["ES2023", "DOM"],
+      "module": "esnext",
+      "types": ["vite/client"],
+      "skipLibCheck": true,
+  
+      "moduleResolution": "bundler",
+      "allowImportingTsExtensions": true,
+      "verbatimModuleSyntax": true,
+      "moduleDetection": "force",
+      "noEmit": true,
+      "jsx": "react-jsx",
+      "paths": {
+        "@/*": ["./src/*"]
+      },
+      "noUnusedLocals": true,
+      "noUnusedParameters": true,
+      "erasableSyntaxOnly": true,
+      "noFallthroughCasesInSwitch": true
+    },
+    "include": ["src"]
+}
+
+`;
+};
+
+// src/scripts/vite.ts
+var initiateVite = ({ manager, ts, name }) => {
+  const template = ts ? "react-ts" : "react";
+  const command = `${manager} create vite ${name} --template ${template} --no-interactive`;
+  execSync3(command, {
+    stdio: "inherit"
+  });
+  changeDir(name);
+};
+var viteConfigCreate = ({ tailwind, rc, pathAliasing }) => {
+  const imports = [`import { defineConfig } from "vite";`];
+  if (rc) {
+    imports.push(`import react, { reactCompilerPreset } from "@vitejs/plugin-react";`);
+    imports.push(`import rolldownBabel from "@rolldown/plugin-babel";`);
+  } else {
+    imports.push(`import react from "@vitejs/plugin-react";`);
+  }
+  const plugins = [`react()`];
+  if (tailwind) {
+    imports.push(`import tailwindcss from "@tailwindcss/vite";`);
+    plugins.push(`tailwindcss()`);
+  }
+  if (pathAliasing) {
+    imports.push(`import path from "path";`);
+  }
+  if (rc) {
+    plugins.push(`rolldownBabel({
+      presets: [reactCompilerPreset()],
+    })`);
+  }
+  const fileCode = `
+ ${imports.join("\n")}
+
+export default defineConfig({
+  plugins: [
+    ${plugins.join(",\n    ")},
+  ],
+  ${pathAliasing ? `
+  resolve: {
+      alias: {
+        "@": path.resolve(__dirname, "./src"),
+      },
+    },
+  ` : ""}
+});
+  `;
+  return fileCode;
+};
+var rewriteViteConfig = (data, ts) => {
+  const fileName = ts ? "vite.config.ts" : "vite.config.js";
+  writeData(fileName, data);
+};
+var patchViteEslintConfigForShadcn = (shadcn) => {
+  if (!shadcn) {
+    return;
+  }
+  const fileName = "eslint.config.js";
+  const file = readFileSync3(fileName, "utf-8");
+  if (file.includes("react-refresh/only-export-components")) {
+    return;
+  }
+  const overrideBlock = `,
+  {
+    files: ["src/components/ui/**/*.tsx", "src/hooks/**/*.ts"],
+    rules: {
+      "react-refresh/only-export-components": "off",
+      "react-hooks/set-state-in-effect": "off",
+    },
+  }`;
+  const updatedFile = file.replace(/\]\s*$/, `${overrideBlock}
+]`);
+  writeData(fileName, updatedFile);
+};
+var tailwindViteSetup = (manager, tailwind) => {
+  if (!tailwind) {
+    return;
+  }
+  addPackage(manager, "tailwindcss@4.3.0 @tailwindcss/vite@4.2.4");
+  writeData("src/App.css", `@import "tailwindcss";
+`);
+};
+var reactCompilerSetup = (manager, rc) => {
+  if (!rc) {
+    return;
+  }
+  addDevPackage(manager, "@rolldown/plugin-babel@0.2.0 @babel/core@7.27.1 babel-plugin-react-compiler@19.1.0 @types/babel__core@7.20.5");
+};
+var shadcnSetup = (shadcn, manager) => {
+  if (!shadcn) {
+    return;
+  }
+  const initCommand = `${manager === "bun" ? "--bun " : ""}shadcn@latest init -d`;
+  const addCommand = `${manager === "bun" ? "--bun " : ""}shadcn@latest add --all`;
+  packageExecutor(manager, initCommand);
+  packageExecutor(manager, addCommand);
+};
+var reactRouterSetup = ({ rr, manager, ts }) => {
+  if (!rr) {
+    return;
+  }
+  addPackage(manager, "react-router@7.12.0");
+  if (ts) {
+    writeData("src/main.tsx", reactRouterEntry("ts"));
+  } else {
+    writeData("src/main.jsx", reactRouterEntry("js"));
+  }
+};
+var pathAliasingSetup = ({ pathAliasing, ts }) => {
+  if (!pathAliasing) {
+    return;
+  }
+  const language = ts ? "ts" : "js";
+  if (language === "ts") {
+    pathAliasingConfig("tsconfig.json", language);
+    writeData("tsconfig.app.json", viteAppTsconfig());
+  } else {
+    pathAliasingConfig("jsconfig.json", language);
+  }
+};
+
+// src/setup/vite.ts
+var buildViteApp = async (manager) => {
+  step(1, "Project name");
+  const name = await typeProjectName();
+  step(2, "Extra tools");
+  const answers = await viteChoices();
+  const ts = answers.includes("typescript");
+  const tailwind = answers.includes("tailwind");
+  const rc = answers.includes("reactCompiler");
+  const rr = answers.includes("reactRouter");
+  const shadcn = answers.includes("shadcn");
+  const pathAliasing = answers.includes("pathAlising");
+  step(3, "Scaffolding Vite project");
+  initiateVite({ ts, manager, name });
+  success("Vite project created");
+  const viteConfig = viteConfigCreate({ tailwind, rc, pathAliasing });
+  rewriteViteConfig(viteConfig, ts);
+  pathAliasingSetup({ pathAliasing, ts });
+  patchViteEslintConfigForShadcn(shadcn);
+  if (tailwind) {
+    step(4, "Setting up Tailwind CSS");
+    tailwindViteSetup(manager, tailwind);
+    success("Tailwind CSS configured");
+  }
+  if (rc) {
+    step(5, "Setting up React Compiler");
+    reactCompilerSetup(manager, rc);
+    success("React Compiler configured");
+  }
+  if (shadcn) {
+    step(6, "Installing shadcn/ui");
+    shadcnSetup(shadcn, manager);
+    success("shadcn/ui installed");
+  }
+  if (rr) {
+    step(7, "Setting up React Router");
+    reactRouterSetup({ rr, manager, ts });
+    success("React Router configured");
+  }
+  done();
+};
+
+// src/utils/frameworkMapper.ts
+var mapper = {
+  nextjs: buildNextApp,
+  vite: buildViteApp,
+  express: buildExpressApp,
+  electron: buildElectronApp,
+  expo: buildExpoApp
+};
+
+// src/index.ts
+var program = new Command();
+program.name("Rebar").description("Interactive CLI for scaffolding JavaScript and TypeScript projects across multiple frameworks.").version("1.0.0");
+program.command("init").description("choose a template to start").action(async () => {
+  banner();
+  info(`Let's scaffold your project! Answer a few questions to get started.
+`);
+  const manager = await choosePackageManager();
+  const fw = await chooseFramework(manager);
+  const func = mapper[fw];
+  if (!func) {
+    process.exit(1);
+  }
+  func(manager);
+});
+program.command("start").description("Enter template parameters").option("-m ,--packageManager <manager>", "package Manager: npm, bun, yarn").option("-f ,--framework <framework>", "framework: nextjs,vite,express,expo,electron").action((options) => {
+  banner();
+  const { packageManager, framework } = options;
+  if (!packageManager || !framework) {
+    error(`Missing required options. Use --packageManager and --framework.`);
+    console.log(colors.gray(`  Example: rebar start -m npm -f vite`));
+    process.exit(1);
+  }
+  if (packageManager === "pnpm") {
+    error(`pnpm is not supported (pnpm install --ignore-scripts breaks builds).`);
+    console.log(colors.gray(`  Use npm, yarn, or bun instead.`));
+    process.exit(1);
+  }
+  info(`Scaffolding a ${colors.bold(framework)} project with ${colors.bold(packageManager)}...
+`);
+  const func = mapper[framework];
+  if (!func) {
+    error(`Invalid framework "${framework}". Run ${colors.bold("rebar --help")} for options.`);
+    process.exit(1);
+  }
+  func(packageManager);
+});
+program.parse();