@reliverse/dler 1.7.92 → 1.7.93

package/bin/app/providers/better-t-stack/helpers/project-generation/env-setup.js

@@ -0,0 +1,193 @@
+import path from "node:path";
+import fs from "@reliverse/relifso";
+import { generateAuthSecret } from "../setup/auth-setup.js";
+export async function addEnvVariablesToFile(filePath, variables) {
+  await fs.ensureDir(path.dirname(filePath));
+  let envContent = "";
+  if (await fs.pathExists(filePath)) {
+    envContent = await fs.readFile(filePath, "utf8");
+  }
+  let modified = false;
+  let contentToAdd = "";
+  const exampleVariables = [];
+  for (const { key, value, condition } of variables) {
+    if (condition) {
+      const regex = new RegExp(`^${key}=.*$`, "m");
+      const valueToWrite = value ?? "";
+      exampleVariables.push(`${key}=`);
+      if (regex.test(envContent)) {
+        const existingMatch = envContent.match(regex);
+        if (existingMatch && existingMatch[0] !== `${key}=${valueToWrite}`) {
+          envContent = envContent.replace(regex, `${key}=${valueToWrite}`);
+          modified = true;
+        }
+      } else {
+        contentToAdd += `${key}=${valueToWrite}
+`;
+        modified = true;
+      }
+    }
+  }
+  if (contentToAdd) {
+    if (envContent.length > 0 && !envContent.endsWith("\n")) {
+      envContent += "\n";
+    }
+    envContent += contentToAdd;
+  }
+  if (modified) {
+    await fs.writeFile(filePath, envContent.trimEnd());
+  }
+  const exampleFilePath = filePath.replace(/\.env$/, ".env.example");
+  let exampleEnvContent = "";
+  if (await fs.pathExists(exampleFilePath)) {
+    exampleEnvContent = await fs.readFile(exampleFilePath, "utf8");
+  }
+  let exampleModified = false;
+  let exampleContentToAdd = "";
+  for (const exampleVar of exampleVariables) {
+    const key = exampleVar.split("=")[0];
+    const regex = new RegExp(`^${key}=.*$`, "m");
+    if (!regex.test(exampleEnvContent)) {
+      exampleContentToAdd += `${exampleVar}
+`;
+      exampleModified = true;
+    }
+  }
+  if (exampleContentToAdd) {
+    if (exampleEnvContent.length > 0 && !exampleEnvContent.endsWith("\n")) {
+      exampleEnvContent += "\n";
+    }
+    exampleEnvContent += exampleContentToAdd;
+  }
+  if (exampleModified || !await fs.pathExists(exampleFilePath)) {
+    await fs.writeFile(exampleFilePath, exampleEnvContent.trimEnd());
+  }
+}
+export async function setupEnvironmentVariables(config) {
+  const { backend, frontend, database, auth, examples, dbSetup, projectDir } = config;
+  const hasReactRouter = frontend.includes("react-router");
+  const hasTanStackRouter = frontend.includes("tanstack-router");
+  const hasTanStackStart = frontend.includes("tanstack-start");
+  const hasNextJs = frontend.includes("next");
+  const hasNuxt = frontend.includes("nuxt");
+  const hasSvelte = frontend.includes("svelte");
+  const hasSolid = frontend.includes("solid");
+  const hasWebFrontend = hasReactRouter || hasTanStackRouter || hasTanStackStart || hasNextJs || hasNuxt || hasSolid || hasSvelte;
+  if (hasWebFrontend) {
+    const clientDir = path.join(projectDir, "apps/web");
+    if (await fs.pathExists(clientDir)) {
+      let envVarName = "VITE_SERVER_URL";
+      let serverUrl = "http://localhost:3000";
+      if (hasNextJs) {
+        envVarName = "NEXT_PUBLIC_SERVER_URL";
+      } else if (hasNuxt) {
+        envVarName = "NUXT_PUBLIC_SERVER_URL";
+      } else if (hasSvelte) {
+        envVarName = "PUBLIC_SERVER_URL";
+      }
+      if (backend === "convex") {
+        if (hasNextJs) envVarName = "NEXT_PUBLIC_CONVEX_URL";
+        else if (hasNuxt) envVarName = "NUXT_PUBLIC_CONVEX_URL";
+        else if (hasSvelte) envVarName = "PUBLIC_CONVEX_URL";
+        else envVarName = "VITE_CONVEX_URL";
+        serverUrl = "https://<YOUR_CONVEX_URL>";
+      }
+      const clientVars = [
+        {
+          key: envVarName,
+          value: serverUrl,
+          condition: true
+        }
+      ];
+      await addEnvVariablesToFile(path.join(clientDir, ".env"), clientVars);
+    }
+  }
+  if (frontend.includes("native-nativewind") || frontend.includes("native-unistyles")) {
+    const nativeDir = path.join(projectDir, "apps/native");
+    if (await fs.pathExists(nativeDir)) {
+      let envVarName = "EXPO_PUBLIC_SERVER_URL";
+      let serverUrl = "http://localhost:3000";
+      if (backend === "convex") {
+        envVarName = "EXPO_PUBLIC_CONVEX_URL";
+        serverUrl = "https://<YOUR_CONVEX_URL>";
+      }
+      const nativeVars = [
+        {
+          key: envVarName,
+          value: serverUrl,
+          condition: true
+        }
+      ];
+      await addEnvVariablesToFile(path.join(nativeDir, ".env"), nativeVars);
+    }
+  }
+  if (backend === "convex") {
+    return;
+  }
+  const serverDir = path.join(projectDir, "apps/server");
+  if (!await fs.pathExists(serverDir)) {
+    return;
+  }
+  const envPath = path.join(serverDir, ".env");
+  let corsOrigin = "http://localhost:3001";
+  if (hasReactRouter || hasSvelte) {
+    corsOrigin = "http://localhost:5173";
+  }
+  let databaseUrl = null;
+  const specializedSetup = dbSetup === "turso" || dbSetup === "prisma-postgres" || dbSetup === "mongodb-atlas" || dbSetup === "neon" || dbSetup === "supabase";
+  if (database !== "none" && !specializedSetup) {
+    switch (database) {
+      case "postgres":
+        databaseUrl = "postgresql://postgres:password@localhost:5432/postgres";
+        break;
+      case "mysql":
+        databaseUrl = "mysql://root:password@localhost:3306/mydb";
+        break;
+      case "mongodb":
+        databaseUrl = "mongodb://localhost:27017/mydatabase";
+        break;
+      case "sqlite":
+        if (config.runtime === "workers") {
+          databaseUrl = "http://127.0.0.1:8080";
+        } else {
+          databaseUrl = "file:./local.db";
+        }
+        break;
+    }
+  }
+  const serverVars = [
+    {
+      key: "CORS_ORIGIN",
+      value: corsOrigin,
+      condition: true
+    },
+    {
+      key: "BETTER_AUTH_SECRET",
+      value: generateAuthSecret(),
+      condition: !!auth
+    },
+    {
+      key: "BETTER_AUTH_URL",
+      value: "http://localhost:3000",
+      condition: !!auth
+    },
+    {
+      key: "DATABASE_URL",
+      value: databaseUrl,
+      condition: database !== "none" && !specializedSetup
+    },
+    {
+      key: "GOOGLE_GENERATIVE_AI_API_KEY",
+      value: "",
+      condition: examples?.includes("ai") || false
+    }
+  ];
+  await addEnvVariablesToFile(envPath, serverVars);
+  if (config.runtime === "workers") {
+    const devVarsPath = path.join(serverDir, ".dev.vars");
+    try {
+      await fs.copy(envPath, devVarsPath);
+    } catch (_err) {
+    }
+  }
+}

package/bin/app/providers/better-t-stack/helpers/project-generation/install-dependencies.d.ts

@@ -0,0 +1,6 @@
+import type { Addons, PackageManager } from "../../types.js";
+export declare function installDependencies({ projectDir, packageManager, }: {
+    projectDir: string;
+    packageManager: PackageManager;
+    addons?: Addons[];
+}): Promise<void>;

package/bin/app/providers/better-t-stack/helpers/project-generation/install-dependencies.js

@@ -0,0 +1,25 @@
+import { re } from "@reliverse/relico";
+import { relinka } from "@reliverse/relinka";
+import { spinner } from "@reliverse/rempts";
+import { $ } from "execa";
+export async function installDependencies({
+  projectDir,
+  packageManager
+}) {
+  const s = spinner({
+    text: `Running ${packageManager} install...`
+  });
+  try {
+    s.start(`Running ${packageManager} install...`);
+    await $({
+      cwd: projectDir,
+      stderr: "inherit"
+    })`${packageManager} install`;
+    s.stop("Dependencies installed successfully");
+  } catch (error) {
+    s.stop(re.red("Failed to install dependencies"));
+    if (error instanceof Error) {
+      relinka("error", re.red(`Installation error: ${error.message}`));
+    }
+  }
+}

package/bin/app/providers/better-t-stack/helpers/project-generation/post-installation.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectConfig } from "../../types.js";
+export declare function displayPostInstallInstructions(config: ProjectConfig & {
+    depsInstalled: boolean;
+}): void;

package/bin/app/providers/better-t-stack/helpers/project-generation/post-installation.js

@@ -0,0 +1,228 @@
+import { re } from "@reliverse/relico";
+import { relinka } from "@reliverse/relinka";
+import { getPackageExecutionCommand } from "../../utils/get-package-execution-command.js";
+export function displayPostInstallInstructions(config) {
+  const {
+    database,
+    relativePath,
+    packageManager,
+    depsInstalled,
+    orm,
+    addons,
+    runtime,
+    frontend,
+    backend
+  } = config;
+  const isConvex = backend === "convex";
+  const runCmd = packageManager === "npm" ? "npm run" : packageManager;
+  const cdCmd = `cd ${relativePath}`;
+  const hasHuskyOrBiome = addons?.includes("husky") || addons?.includes("biome");
+  const databaseInstructions = !isConvex && database !== "none" ? getDatabaseInstructions(database, orm, runCmd, runtime) : "";
+  const tauriInstructions = addons?.includes("tauri") ? getTauriInstructions(runCmd) : "";
+  const lintingInstructions = hasHuskyOrBiome ? getLintingInstructions(runCmd) : "";
+  const nativeInstructions = frontend?.includes("native-nativewind") || frontend?.includes("native-unistyles") ? getNativeInstructions(isConvex) : "";
+  const pwaInstructions = addons?.includes("pwa") && (frontend?.includes("react-router") || frontend?.includes("tanstack-router")) ? getPwaInstructions() : "";
+  const starlightInstructions = addons?.includes("starlight") ? getStarlightInstructions(runCmd) : "";
+  const hasWeb = frontend?.some(
+    (f) => [
+      "tanstack-router",
+      "react-router",
+      "next",
+      "tanstack-start",
+      "nuxt",
+      "svelte",
+      "solid"
+    ].includes(f)
+  );
+  const hasNative = frontend?.includes("native-nativewind") || frontend?.includes("native-unistyles");
+  const bunWebNativeWarning = packageManager === "bun" && hasNative && hasWeb ? getBunWebNativeWarning() : "";
+  const noOrmWarning = !isConvex && database !== "none" && orm === "none" ? getNoOrmWarning() : "";
+  const hasReactRouter = frontend?.includes("react-router");
+  const hasSvelte = frontend?.includes("svelte");
+  const webPort = hasReactRouter || hasSvelte ? "5173" : "3001";
+  const tazeCommand = getPackageExecutionCommand(packageManager, "taze -r");
+  let output = `${re.bold("Next steps")}
+${re.cyan("1.")} ${cdCmd}
+`;
+  let stepCounter = 2;
+  if (!depsInstalled) {
+    output += `${re.cyan(`${stepCounter++}.`)} ${packageManager} install
+`;
+  }
+  if (isConvex) {
+    output += `${re.cyan(`${stepCounter++}.`)} ${runCmd} dev:setup ${re.dim(
+      "(this will guide you through Convex project setup)"
+    )}
+`;
+    output += `${re.cyan(`${stepCounter++}.`)} ${runCmd} dev
+`;
+  } else {
+    if (runtime !== "workers") {
+      output += `${re.cyan(`${stepCounter++}.`)} ${runCmd} dev
+`;
+    }
+    if (runtime === "workers") {
+      output += `${re.cyan(`${stepCounter++}.`)} bun dev
+`;
+      output += `${re.cyan(`${stepCounter++}.`)} cd apps/server && bun run cf-typegen
+`;
+    } else {
+      output += "\n";
+    }
+  }
+  output += `${re.bold("Your project will be available at:")}
+`;
+  if (hasWeb) {
+    output += `${re.cyan("\u2022")} Frontend: http://localhost:${webPort}
+`;
+  } else if (!hasNative && !addons?.includes("starlight")) {
+    output += `${re.yellow("NOTE:")} You are creating a backend-only app (no frontend selected)
+`;
+  }
+  if (!isConvex) {
+    output += `${re.cyan("\u2022")} Backend API: http://localhost:3000
+`;
+  }
+  if (addons?.includes("starlight")) {
+    output += `${re.cyan("\u2022")} Docs: http://localhost:4321
+`;
+  }
+  if (nativeInstructions) output += `
+${nativeInstructions.trim()}
+`;
+  if (databaseInstructions) output += `
+${databaseInstructions.trim()}
+`;
+  if (tauriInstructions) output += `
+${tauriInstructions.trim()}
+`;
+  if (lintingInstructions) output += `
+${lintingInstructions.trim()}
+`;
+  if (pwaInstructions) output += `
+${pwaInstructions.trim()}
+`;
+  if (starlightInstructions) output += `
+${starlightInstructions.trim()}
+`;
+  if (noOrmWarning) output += `
+${noOrmWarning.trim()}
+`;
+  if (bunWebNativeWarning) output += `
+${bunWebNativeWarning.trim()}
+`;
+  output += `
+${re.bold("Update all dependencies:\n")}${re.cyan(tazeCommand)}
+`;
+  output += `${re.bold("Like Better-T Stack?")} Please consider giving us a star on GitHub:
+`;
+  output += re.cyan("https://github.com/AmanVarshney01/create-better-t-stack");
+  relinka("info", output);
+}
+function getNativeInstructions(isConvex) {
+  const envVar = isConvex ? "EXPO_PUBLIC_CONVEX_URL" : "EXPO_PUBLIC_SERVER_URL";
+  const exampleUrl = isConvex ? "https://<YOUR_CONVEX_URL>" : "http://<YOUR_LOCAL_IP>:3000";
+  const envFileName = ".env";
+  const ipNote = isConvex ? "your Convex deployment URL (find after running 'dev:setup')" : "your local IP address";
+  let instructions = `${re.yellow(
+    "NOTE:"
+  )} For Expo connectivity issues, update apps/native/${envFileName} 
+with ${ipNote}:
+${`${envVar}=${exampleUrl}`}
+`;
+  if (isConvex) {
+    instructions += `
+${re.yellow(
+      "IMPORTANT:"
+    )} When using local development with Convex and native apps, ensure you use your local IP address 
+instead of localhost or 127.0.0.1 for proper connectivity.
+`;
+  }
+  return instructions;
+}
+function getLintingInstructions(runCmd) {
+  return `${re.bold("Linting and formatting:")}
+${re.cyan(
+    "\u2022"
+  )} Format and lint fix: ${`${runCmd} check`}
+`;
+}
+function getDatabaseInstructions(database, orm, runCmd, runtime) {
+  const instructions = [];
+  if (orm === "prisma") {
+    if (database === "sqlite") {
+      instructions.push(
+        `${re.yellow(
+          "NOTE:"
+        )} Turso support with Prisma is in Early Access and requires additional setup.`,
+        `${"Learn more at: https://www.prisma.io/docs/orm/overview/databases/turso"}`
+      );
+    }
+    if (runtime === "bun") {
+      instructions.push(
+        `${re.yellow(
+          "NOTE:"
+        )} Prisma with Bun may require additional configuration. If you encounter errors,
+follow the guidance provided in the error messages`
+      );
+    }
+    instructions.push(`${re.cyan("\u2022")} Apply schema: ${`${runCmd} db:push`}`);
+    instructions.push(`${re.cyan("\u2022")} Database UI: ${`${runCmd} db:studio`}`);
+  } else if (orm === "drizzle") {
+    instructions.push(`${re.cyan("\u2022")} Apply schema: ${`${runCmd} db:push`}`);
+    instructions.push(`${re.cyan("\u2022")} Database UI: ${`${runCmd} db:studio`}`);
+    if (database === "sqlite") {
+      instructions.push(
+        `${re.cyan("\u2022")} Start local DB (if needed): ${`cd apps/server && ${runCmd} db:local`}`
+      );
+    }
+  } else if (orm === "none") {
+    instructions.push(`${re.yellow("NOTE:")} Manual database schema setup required.`);
+  }
+  return instructions.length ? `${re.bold("Database commands:")}
+${instructions.join("\n")}` : "";
+}
+function getTauriInstructions(runCmd) {
+  return `
+${re.bold("Desktop app with Tauri:")}
+${re.cyan(
+    "\u2022"
+  )} Start desktop app: ${`cd apps/web && ${runCmd} desktop:dev`}
+${re.cyan(
+    "\u2022"
+  )} Build desktop app: ${`cd apps/web && ${runCmd} desktop:build`}
+${re.yellow(
+    "NOTE:"
+  )} Tauri requires Rust and platform-specific dependencies.
+See: ${"https://v2.tauri.app/start/prerequisites/"}`;
+}
+function getPwaInstructions() {
+  return `
+${re.bold("PWA with React Router v7:")}
+${re.yellow(
+    "NOTE:"
+  )} There is a known compatibility issue between VitePWA and React Router v7.
+See: https://github.com/vite-pwa/vite-plugin-pwa/issues/809`;
+}
+function getStarlightInstructions(runCmd) {
+  return `
+${re.bold("Documentation with Starlight:")}
+${re.cyan(
+    "\u2022"
+  )} Start docs site: ${`cd apps/docs && ${runCmd} dev`}
+${re.cyan(
+    "\u2022"
+  )} Build docs site: ${`cd apps/docs && ${runCmd} build`}`;
+}
+function getNoOrmWarning() {
+  return `
+${re.yellow(
+    "WARNING:"
+  )} Database selected without an ORM. Features requiring database access (e.g., examples, auth) need manual setup.`;
+}
+function getBunWebNativeWarning() {
+  return `
+${re.yellow(
+    "WARNING:"
+  )} 'bun' might cause issues with web + native apps in a monorepo. Use 'pnpm' if problems arise.`;
+}

package/bin/app/providers/better-t-stack/helpers/project-generation/project-config.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectConfig } from "../../types.js";
+export declare function updatePackageConfigurations(projectDir: string, options: ProjectConfig): Promise<void>;
+export declare function initializeGit(projectDir: string, useGit: boolean): Promise<void>;

package/bin/app/providers/better-t-stack/helpers/project-generation/project-config.js

@@ -0,0 +1,224 @@
+import path from "node:path";
+import { re } from "@reliverse/relico";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { $, execa } from "execa";
+export async function updatePackageConfigurations(projectDir, options) {
+  await updateRootPackageJson(projectDir, options);
+  if (options.backend !== "convex") {
+    await updateServerPackageJson(projectDir, options);
+  } else {
+    await updateConvexPackageJson(projectDir, options);
+  }
+}
+async function updateRootPackageJson(projectDir, options) {
+  const rootPackageJsonPath = path.join(projectDir, "package.json");
+  if (!await fs.pathExists(rootPackageJsonPath)) return;
+  const packageJson = await fs.readJson(rootPackageJsonPath);
+  packageJson.name = options.projectName;
+  if (!packageJson.scripts) {
+    packageJson.scripts = {};
+  }
+  const scripts = packageJson.scripts;
+  const backendPackageName = options.backend === "convex" ? `@${options.projectName}/backend` : "server";
+  let serverDevScript = "";
+  if (options.addons.includes("turborepo")) {
+    serverDevScript = `turbo -F ${backendPackageName} dev`;
+  } else if (options.packageManager === "bun") {
+    serverDevScript = `bun run --filter ${backendPackageName} dev`;
+  } else if (options.packageManager === "pnpm") {
+    serverDevScript = `pnpm --filter ${backendPackageName} dev`;
+  } else if (options.packageManager === "npm") {
+    serverDevScript = `npm run dev --workspace ${backendPackageName}`;
+  }
+  let devScript = "";
+  if (options.packageManager === "pnpm") {
+    devScript = "pnpm -r dev";
+  } else if (options.packageManager === "npm") {
+    devScript = "npm run dev --workspaces";
+  } else if (options.packageManager === "bun") {
+    devScript = "bun run --filter '*' dev";
+  }
+  const needsDbScripts = options.backend !== "convex" && options.database !== "none" && options.orm !== "none" && options.orm !== "mongoose";
+  if (options.addons.includes("turborepo")) {
+    scripts.dev = "turbo dev";
+    scripts.build = "turbo build";
+    scripts["check-types"] = "turbo check-types";
+    scripts["dev:native"] = "turbo -F native dev";
+    scripts["dev:web"] = "turbo -F web dev";
+    scripts["dev:server"] = serverDevScript;
+    if (options.backend === "convex") {
+      scripts["dev:setup"] = `turbo -F ${backendPackageName} setup`;
+    }
+    if (needsDbScripts) {
+      scripts["db:push"] = `turbo -F ${backendPackageName} db:push`;
+      scripts["db:studio"] = `turbo -F ${backendPackageName} db:studio`;
+      if (options.orm === "prisma") {
+        scripts["db:generate"] = `turbo -F ${backendPackageName} db:generate`;
+        scripts["db:migrate"] = `turbo -F ${backendPackageName} db:migrate`;
+      } else if (options.orm === "drizzle") {
+        scripts["db:generate"] = `turbo -F ${backendPackageName} db:generate`;
+        scripts["db:migrate"] = `turbo -F ${backendPackageName} db:migrate`;
+      }
+    }
+  } else if (options.packageManager === "pnpm") {
+    scripts.dev = devScript;
+    scripts.build = "pnpm -r build";
+    scripts["check-types"] = "pnpm -r check-types";
+    scripts["dev:native"] = "pnpm --filter native dev";
+    scripts["dev:web"] = "pnpm --filter web dev";
+    scripts["dev:server"] = serverDevScript;
+    if (options.backend === "convex") {
+      scripts["dev:setup"] = `pnpm --filter ${backendPackageName} setup`;
+    }
+    if (needsDbScripts) {
+      scripts["db:push"] = `pnpm --filter ${backendPackageName} db:push`;
+      scripts["db:studio"] = `pnpm --filter ${backendPackageName} db:studio`;
+      if (options.orm === "prisma") {
+        scripts["db:generate"] = `pnpm --filter ${backendPackageName} db:generate`;
+        scripts["db:migrate"] = `pnpm --filter ${backendPackageName} db:migrate`;
+      } else if (options.orm === "drizzle") {
+        scripts["db:generate"] = `pnpm --filter ${backendPackageName} db:generate`;
+        scripts["db:migrate"] = `pnpm --filter ${backendPackageName} db:migrate`;
+      }
+    }
+  } else if (options.packageManager === "npm") {
+    scripts.dev = devScript;
+    scripts.build = "npm run build --workspaces";
+    scripts["check-types"] = "npm run check-types --workspaces";
+    scripts["dev:native"] = "npm run dev --workspace native";
+    scripts["dev:web"] = "npm run dev --workspace web";
+    scripts["dev:server"] = serverDevScript;
+    if (options.backend === "convex") {
+      scripts["dev:setup"] = `npm run setup --workspace ${backendPackageName}`;
+    }
+    if (needsDbScripts) {
+      scripts["db:push"] = `npm run db:push --workspace ${backendPackageName}`;
+      scripts["db:studio"] = `npm run db:studio --workspace ${backendPackageName}`;
+      if (options.orm === "prisma") {
+        scripts["db:generate"] = `npm run db:generate --workspace ${backendPackageName}`;
+        scripts["db:migrate"] = `npm run db:migrate --workspace ${backendPackageName}`;
+      } else if (options.orm === "drizzle") {
+        scripts["db:generate"] = `npm run db:generate --workspace ${backendPackageName}`;
+        scripts["db:migrate"] = `npm run db:migrate --workspace ${backendPackageName}`;
+      }
+    }
+  } else if (options.packageManager === "bun") {
+    scripts.dev = devScript;
+    scripts.build = "bun run --filter '*' build";
+    scripts["check-types"] = "bun run --filter '*' check-types";
+    scripts["dev:native"] = "bun run --filter native dev";
+    scripts["dev:web"] = "bun run --filter web dev";
+    scripts["dev:server"] = serverDevScript;
+    if (options.backend === "convex") {
+      scripts["dev:setup"] = `bun run --filter ${backendPackageName} setup`;
+    }
+    if (needsDbScripts) {
+      scripts["db:push"] = `bun run --filter ${backendPackageName} db:push`;
+      scripts["db:studio"] = `bun run --filter ${backendPackageName} db:studio`;
+      if (options.orm === "prisma") {
+        scripts["db:generate"] = `bun run --filter ${backendPackageName} db:generate`;
+        scripts["db:migrate"] = `bun run --filter ${backendPackageName} db:migrate`;
+      } else if (options.orm === "drizzle") {
+        scripts["db:generate"] = `bun run --filter ${backendPackageName} db:generate`;
+        scripts["db:migrate"] = `bun run --filter ${backendPackageName} db:migrate`;
+      }
+    }
+  }
+  if (options.addons.includes("biome")) {
+    scripts.check = "biome check --write .";
+  }
+  if (options.addons.includes("husky")) {
+    scripts.prepare = "husky";
+    packageJson["lint-staged"] = {
+      "*.{js,ts,cjs,mjs,d.cts,d.mts,jsx,tsx,json,jsonc}": ["biome check --write ."]
+    };
+  }
+  try {
+    const { stdout } = await execa(options.packageManager, ["-v"], {
+      cwd: projectDir
+    });
+    packageJson.packageManager = `${options.packageManager}@${stdout.trim()}`;
+  } catch (_e) {
+    relinka("warn", `Could not determine ${options.packageManager} version.`);
+  }
+  if (!packageJson.workspaces) {
+    packageJson.workspaces = [];
+  }
+  const workspaces = packageJson.workspaces;
+  if (options.backend === "convex") {
+    if (!workspaces.includes("packages/*")) {
+      workspaces.push("packages/*");
+    }
+    const needsAppsDir = options.frontend.length > 0 || options.addons.includes("starlight");
+    if (needsAppsDir && !workspaces.includes("apps/*")) {
+      workspaces.push("apps/*");
+    }
+  } else {
+    if (!workspaces.includes("apps/*")) {
+      workspaces.push("apps/*");
+    }
+    if (!workspaces.includes("packages/*")) {
+      workspaces.push("packages/*");
+    }
+  }
+  await fs.writeJson(rootPackageJsonPath, packageJson, { spaces: 2 });
+}
+async function updateServerPackageJson(projectDir, options) {
+  const serverPackageJsonPath = path.join(projectDir, "apps/server/package.json");
+  if (!await fs.pathExists(serverPackageJsonPath)) return;
+  const serverPackageJson = await fs.readJson(serverPackageJsonPath);
+  if (!serverPackageJson.scripts) {
+    serverPackageJson.scripts = {};
+  }
+  const scripts = serverPackageJson.scripts;
+  if (options.database !== "none") {
+    if (options.database === "sqlite" && options.orm === "drizzle") {
+      scripts["db:local"] = "turso dev --db-file local.db";
+    }
+    if (options.orm === "prisma") {
+      scripts["db:push"] = "prisma db push --schema ./prisma/schema";
+      scripts["db:studio"] = "prisma studio";
+      scripts["db:generate"] = "prisma generate --schema ./prisma/schema";
+      scripts["db:migrate"] = "prisma migrate dev";
+    } else if (options.orm === "drizzle") {
+      scripts["db:push"] = "drizzle-kit push";
+      scripts["db:studio"] = "drizzle-kit studio";
+      scripts["db:generate"] = "drizzle-kit generate";
+      scripts["db:migrate"] = "drizzle-kit migrate";
+    }
+  }
+  await fs.writeJson(serverPackageJsonPath, serverPackageJson, {
+    spaces: 2
+  });
+}
+async function updateConvexPackageJson(projectDir, options) {
+  const convexPackageJsonPath = path.join(projectDir, "packages/backend/package.json");
+  if (!await fs.pathExists(convexPackageJsonPath)) return;
+  const convexPackageJson = await fs.readJson(convexPackageJsonPath);
+  convexPackageJson.name = `@${options.projectName}/backend`;
+  if (!convexPackageJson.scripts) {
+    convexPackageJson.scripts = {};
+  }
+  await fs.writeJson(convexPackageJsonPath, convexPackageJson, { spaces: 2 });
+}
+export async function initializeGit(projectDir, useGit) {
+  if (!useGit) return;
+  const gitVersionResult = await $({
+    cwd: projectDir,
+    reject: false,
+    stderr: "pipe"
+  })`git --version`;
+  if (gitVersionResult.exitCode !== 0) {
+    relinka("warn", re.yellow("Git is not installed"));
+    return;
+  }
+  const result = await $({
+    cwd: projectDir,
+    reject: false,
+    stderr: "pipe"
+  })`git init`;
+  if (result.exitCode !== 0) {
+    throw new Error(`Git initialization failed: ${result.stderr}`);
+  }
+}