@reliverse/dler 1.7.153 → 2.0.1

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

@@ -1,193 +0,0 @@
-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/impl/providers/better-t-stack/helpers/project-generation/install-dependencies.d.ts

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

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

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

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

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

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

@@ -1,228 +0,0 @@
-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 callCmd = 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, callCmd, runtime) : "";
-  const tauriInstructions = addons?.includes("tauri") ? getTauriInstructions(callCmd) : "";
-  const lintingInstructions = hasHuskyOrBiome ? getLintingInstructions(callCmd) : "";
-  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(callCmd) : "";
-  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++}.`)} ${callCmd} dev:setup ${re.dim(
-      "(this will guide you through Convex project setup)"
-    )}
-`;
-    output += `${re.cyan(`${stepCounter++}.`)} ${callCmd} dev
-`;
-  } else {
-    if (runtime !== "workers") {
-      output += `${re.cyan(`${stepCounter++}.`)} ${callCmd} 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(callCmd) {
-  return `${re.bold("Linting and formatting:")}
-${re.cyan(
-    "\u2022"
-  )} Format and lint fix: ${`${callCmd} check`}
-`;
-}
-function getDatabaseInstructions(database, orm, callCmd, 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: ${`${callCmd} db:push`}`);
-    instructions.push(`${re.cyan("\u2022")} Database UI: ${`${callCmd} db:studio`}`);
-  } else if (orm === "drizzle") {
-    instructions.push(`${re.cyan("\u2022")} Apply schema: ${`${callCmd} db:push`}`);
-    instructions.push(`${re.cyan("\u2022")} Database UI: ${`${callCmd} db:studio`}`);
-    if (database === "sqlite") {
-      instructions.push(
-        `${re.cyan("\u2022")} Start local DB (if needed): ${`cd apps/server && ${callCmd} 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(callCmd) {
-  return `
-${re.bold("Desktop app with Tauri:")}
-${re.cyan(
-    "\u2022"
-  )} Start desktop app: ${`cd apps/web && ${callCmd} desktop:dev`}
-${re.cyan(
-    "\u2022"
-  )} Build desktop app: ${`cd apps/web && ${callCmd} 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(callCmd) {
-  return `
-${re.bold("Documentation with Starlight:")}
-${re.cyan(
-    "\u2022"
-  )} Start docs site: ${`cd apps/docs && ${callCmd} dev`}
-${re.cyan(
-    "\u2022"
-  )} Build docs site: ${`cd apps/docs && ${callCmd} 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/impl/providers/better-t-stack/helpers/project-generation/project-config.d.ts

@@ -1,3 +0,0 @@
-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/impl/providers/better-t-stack/helpers/project-generation/project-config.js

@@ -1,224 +0,0 @@
-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}`);
-  }
-}