create-better-t-stack 3.7.3-canary.8e4d5716 → 3.7.3-canary.98ba1e7a

package/src/helpers/addons/ruler-setup.ts

@@ -1,139 +0,0 @@
-import path from "node:path";
-import { autocompleteMultiselect, isCancel, log, spinner } from "@clack/prompts";
-import { execa } from "execa";
-import fs from "fs-extra";
-import pc from "picocolors";
-import type { ProjectConfig } from "../../types";
-import { exitCancelled } from "../../utils/errors";
-import { getPackageExecutionCommand } from "../../utils/package-runner";
-
-export async function setupRuler(config: ProjectConfig) {
-  const { packageManager, projectDir } = config;
-
-  try {
-    log.info("Setting up Ruler...");
-
-    const rulerDir = path.join(projectDir, ".ruler");
-
-    if (!(await fs.pathExists(rulerDir))) {
-      log.error(
-        pc.red(
-          "Ruler template directory not found. Please ensure ruler addon is properly installed.",
-        ),
-      );
-      return;
-    }
-
-    const EDITORS = {
-      amp: { label: "AMP" },
-      copilot: { label: "GitHub Copilot" },
-      claude: { label: "Claude Code" },
-      codex: { label: "OpenAI Codex CLI" },
-      cursor: { label: "Cursor" },
-      windsurf: { label: "Windsurf" },
-      cline: { label: "Cline" },
-      aider: { label: "Aider" },
-      firebase: { label: "Firebase Studio" },
-      "gemini-cli": { label: "Gemini CLI" },
-      junie: { label: "Junie" },
-      kilocode: { label: "Kilo Code" },
-      opencode: { label: "OpenCode" },
-      crush: { label: "Crush" },
-      zed: { label: "Zed" },
-      qwen: { label: "Qwen" },
-      amazonqcli: { label: "Amazon Q CLI" },
-      augmentcode: { label: "AugmentCode" },
-      firebender: { label: "Firebender" },
-      goose: { label: "Goose" },
-      jules: { label: "Jules" },
-      kiro: { label: "Kiro" },
-      openhands: { label: "Open Hands" },
-      roo: { label: "RooCode" },
-      trae: { label: "Trae AI" },
-      warp: { label: "Warp" },
-    } as const;
-
-    const selectedEditors = await autocompleteMultiselect({
-      message: "Select AI assistants for Ruler",
-      options: Object.entries(EDITORS).map(([key, v]) => ({
-        value: key,
-        label: v.label,
-      })),
-      required: false,
-    });
-
-    if (isCancel(selectedEditors)) return exitCancelled("Operation cancelled");
-
-    if (selectedEditors.length === 0) {
-      log.info("No AI assistants selected. To apply rules later, run:");
-      log.info(
-        pc.cyan(
-          `${getPackageExecutionCommand(packageManager, "@intellectronica/ruler@latest apply --local-only")}`,
-        ),
-      );
-      return;
-    }
-
-    const configFile = path.join(rulerDir, "ruler.toml");
-    const currentConfig = await fs.readFile(configFile, "utf-8");
-
-    let updatedConfig = currentConfig;
-
-    const defaultAgentsLine = `default_agents = [${selectedEditors.map((editor) => `"${editor}"`).join(", ")}]`;
-    updatedConfig = updatedConfig.replace(/default_agents = \[\]/, defaultAgentsLine);
-
-    await fs.writeFile(configFile, updatedConfig);
-
-    await addRulerScriptToPackageJson(projectDir, packageManager);
-
-    const s = spinner();
-    s.start("Applying rules with Ruler...");
-
-    try {
-      const rulerApplyCmd = getPackageExecutionCommand(
-        packageManager,
-        `@intellectronica/ruler@latest apply --agents ${selectedEditors.join(",")} --local-only`,
-      );
-      await execa(rulerApplyCmd, {
-        cwd: projectDir,
-        env: { CI: "true" },
-        shell: true,
-      });
-
-      s.stop("Applied rules with Ruler");
-    } catch {
-      s.stop(pc.red("Failed to apply rules"));
-    }
-  } catch (error) {
-    log.error(pc.red("Failed to set up Ruler"));
-    if (error instanceof Error) {
-      console.error(pc.red(error.message));
-    }
-  }
-}
-
-async function addRulerScriptToPackageJson(
-  projectDir: string,
-  packageManager: ProjectConfig["packageManager"],
-) {
-  const rootPackageJsonPath = path.join(projectDir, "package.json");
-
-  if (!(await fs.pathExists(rootPackageJsonPath))) {
-    log.warn("Root package.json not found, skipping ruler:apply script addition");
-    return;
-  }
-
-  const packageJson = await fs.readJson(rootPackageJsonPath);
-
-  if (!packageJson.scripts) {
-    packageJson.scripts = {};
-  }
-
-  const rulerApplyCommand = getPackageExecutionCommand(
-    packageManager,
-    "@intellectronica/ruler@latest apply --local-only",
-  );
-  packageJson.scripts["ruler:apply"] = rulerApplyCommand;
-
-  await fs.writeJson(rootPackageJsonPath, packageJson, { spaces: 2 });
-}

package/src/helpers/addons/starlight-setup.ts

@@ -1,51 +0,0 @@
-import path from "node:path";
-import { spinner } from "@clack/prompts";
-import consola from "consola";
-import { execa } from "execa";
-import fs from "fs-extra";
-import pc from "picocolors";
-import type { ProjectConfig } from "../../types";
-import { getPackageExecutionCommand } from "../../utils/package-runner";
-
-export async function setupStarlight(config: ProjectConfig) {
-  const { packageManager, projectDir } = config;
-  const s = spinner();
-
-  try {
-    s.start("Setting up Starlight docs...");
-
-    const starlightArgs = [
-      "docs",
-      "--template",
-      "starlight",
-      "--no-install",
-      "--add",
-      "tailwind",
-      "--no-git",
-      "--skip-houston",
-    ];
-    const starlightArgsString = starlightArgs.join(" ");
-
-    const commandWithArgs = `create-astro@latest ${starlightArgsString}`;
-
-    const starlightInitCommand = getPackageExecutionCommand(packageManager, commandWithArgs);
-
-    const appsDir = path.join(projectDir, "apps");
-    await fs.ensureDir(appsDir);
-
-    await execa(starlightInitCommand, {
-      cwd: appsDir,
-      env: {
-        CI: "true",
-      },
-      shell: true,
-    });
-
-    s.stop("Starlight docs setup successfully!");
-  } catch (error) {
-    s.stop(pc.red("Failed to set up Starlight docs"));
-    if (error instanceof Error) {
-      consola.error(pc.red(error.message));
-    }
-  }
-}

package/src/helpers/addons/tauri-setup.ts

@@ -1,96 +0,0 @@
-import path from "node:path";
-import { spinner } from "@clack/prompts";
-import { consola } from "consola";
-import { execa } from "execa";
-import fs from "fs-extra";
-import pc from "picocolors";
-import type { ProjectConfig } from "../../types";
-import { addPackageDependency } from "../../utils/add-package-deps";
-import { getPackageExecutionCommand } from "../../utils/package-runner";
-
-export async function setupTauri(config: ProjectConfig) {
-  const { packageManager, frontend, projectDir } = config;
-  const s = spinner();
-  const clientPackageDir = path.join(projectDir, "apps/web");
-
-  if (!(await fs.pathExists(clientPackageDir))) {
-    return;
-  }
-
-  try {
-    s.start("Setting up Tauri desktop app support...");
-
-    await addPackageDependency({
-      devDependencies: ["@tauri-apps/cli"],
-      projectDir: clientPackageDir,
-    });
-
-    const clientPackageJsonPath = path.join(clientPackageDir, "package.json");
-    if (await fs.pathExists(clientPackageJsonPath)) {
-      const packageJson = await fs.readJson(clientPackageJsonPath);
-
-      packageJson.scripts = {
-        ...packageJson.scripts,
-        tauri: "tauri",
-        "desktop:dev": "tauri dev",
-        "desktop:build": "tauri build",
-      };
-
-      await fs.writeJson(clientPackageJsonPath, packageJson, { spaces: 2 });
-    }
-
-    const _hasTanstackRouter = frontend.includes("tanstack-router");
-    const hasReactRouter = frontend.includes("react-router");
-    const hasNuxt = frontend.includes("nuxt");
-    const hasSvelte = frontend.includes("svelte");
-    const _hasSolid = frontend.includes("solid");
-    const hasNext = frontend.includes("next");
-
-    const devUrl =
-      hasReactRouter || hasSvelte
-        ? "http://localhost:5173"
-        : hasNext
-          ? "http://localhost:3001"
-          : "http://localhost:3001";
-
-    const frontendDist = hasNuxt
-      ? "../.output/public"
-      : hasSvelte
-        ? "../build"
-        : hasNext
-          ? "../.next"
-          : hasReactRouter
-            ? "../build/client"
-            : "../dist";
-
-    const tauriArgs = [
-      "init",
-      `--app-name=${path.basename(projectDir)}`,
-      `--window-title=${path.basename(projectDir)}`,
-      `--frontend-dist=${frontendDist}`,
-      `--dev-url=${devUrl}`,
-      `--before-dev-command="${packageManager} run dev"`,
-      `--before-build-command="${packageManager} run build"`,
-    ];
-    const tauriArgsString = tauriArgs.join(" ");
-
-    const commandWithArgs = `@tauri-apps/cli@latest ${tauriArgsString}`;
-
-    const tauriInitCommand = getPackageExecutionCommand(packageManager, commandWithArgs);
-
-    await execa(tauriInitCommand, {
-      cwd: clientPackageDir,
-      env: {
-        CI: "true",
-      },
-      shell: true,
-    });
-
-    s.stop("Tauri desktop app support configured successfully!");
-  } catch (error) {
-    s.stop(pc.red("Failed to set up Tauri"));
-    if (error instanceof Error) {
-      consola.error(pc.red(error.message));
-    }
-  }
-}

package/src/helpers/addons/ultracite-setup.ts

@@ -1,232 +0,0 @@
-import { autocompleteMultiselect, group, log, multiselect, spinner } from "@clack/prompts";
-import { execa } from "execa";
-import pc from "picocolors";
-import type { ProjectConfig } from "../../types";
-import { addPackageDependency } from "../../utils/add-package-deps";
-import { exitCancelled } from "../../utils/errors";
-import { getPackageExecutionCommand } from "../../utils/package-runner";
-import { setupBiome } from "./addons-setup";
-
-type UltraciteEditor = "vscode" | "zed";
-type UltraciteAgent =
-  | "vscode-copilot"
-  | "cursor"
-  | "windsurf"
-  | "zed"
-  | "claude"
-  | "codex"
-  | "kiro"
-  | "cline"
-  | "amp"
-  | "aider"
-  | "firebase-studio"
-  | "open-hands"
-  | "gemini-cli"
-  | "junie"
-  | "augmentcode"
-  | "kilo-code"
-  | "goose"
-  | "roo-code";
-
-type UltraciteHook = "cursor" | "claude";
-
-const EDITORS = {
-  vscode: {
-    label: "VSCode / Cursor / Windsurf",
-  },
-  zed: {
-    label: "Zed",
-  },
-} as const;
-
-const AGENTS = {
-  "vscode-copilot": {
-    label: "VS Code Copilot",
-  },
-  cursor: {
-    label: "Cursor",
-  },
-  windsurf: {
-    label: "Windsurf",
-  },
-  zed: {
-    label: "Zed",
-  },
-  claude: {
-    label: "Claude",
-  },
-  codex: {
-    label: "Codex",
-  },
-  kiro: {
-    label: "Kiro",
-  },
-  cline: {
-    label: "Cline",
-  },
-  amp: {
-    label: "Amp",
-  },
-  aider: {
-    label: "Aider",
-  },
-  "firebase-studio": {
-    label: "Firebase Studio",
-  },
-  "open-hands": {
-    label: "Open Hands",
-  },
-  "gemini-cli": {
-    label: "Gemini CLI",
-  },
-  junie: {
-    label: "Junie",
-  },
-  augmentcode: {
-    label: "AugmentCode",
-  },
-  "kilo-code": {
-    label: "Kilo Code",
-  },
-  goose: {
-    label: "Goose",
-  },
-  "roo-code": {
-    label: "Roo Code",
-  },
-} as const;
-
-const HOOKS = {
-  cursor: {
-    label: "Cursor",
-  },
-  claude: {
-    label: "Claude",
-  },
-} as const;
-
-function getFrameworksFromFrontend(frontend: string[]): string[] {
-  const frameworkMap: Record<string, string> = {
-    "tanstack-router": "react",
-    "react-router": "react",
-    "tanstack-start": "react",
-    next: "next",
-    nuxt: "vue",
-    "native-bare": "react",
-    "native-uniwind": "react",
-    "native-unistyles": "react",
-    svelte: "svelte",
-    solid: "solid",
-  };
-
-  const frameworks = new Set<string>();
-
-  for (const f of frontend) {
-    if (f !== "none" && frameworkMap[f]) {
-      frameworks.add(frameworkMap[f]);
-    }
-  }
-
-  return Array.from(frameworks);
-}
-
-export async function setupUltracite(config: ProjectConfig, hasHusky: boolean) {
-  const { packageManager, projectDir, frontend } = config;
-
-  try {
-    log.info("Setting up Ultracite...");
-
-    await setupBiome(projectDir);
-
-    const result = await group(
-      {
-        editors: () =>
-          multiselect<UltraciteEditor>({
-            message: "Choose editors",
-            options: Object.entries(EDITORS).map(([key, editor]) => ({
-              value: key as UltraciteEditor,
-              label: editor.label,
-            })),
-            required: true,
-          }),
-        agents: () =>
-          autocompleteMultiselect<UltraciteAgent>({
-            message: "Choose agents",
-            options: Object.entries(AGENTS).map(([key, agent]) => ({
-              value: key as UltraciteAgent,
-              label: agent.label,
-            })),
-            required: true,
-          }),
-        hooks: () =>
-          autocompleteMultiselect<UltraciteHook>({
-            message: "Choose hooks",
-            options: Object.entries(HOOKS).map(([key, hook]) => ({
-              value: key as UltraciteHook,
-              label: hook.label,
-            })),
-          }),
-      },
-      {
-        onCancel: () => {
-          exitCancelled("Operation cancelled");
-        },
-      },
-    );
-
-    const editors = result.editors as UltraciteEditor[];
-    const agents = result.agents as UltraciteAgent[];
-    const hooks = result.hooks as UltraciteHook[];
-    const frameworks = getFrameworksFromFrontend(frontend);
-
-    const ultraciteArgs = ["init", "--pm", packageManager];
-
-    if (frameworks.length > 0) {
-      ultraciteArgs.push("--frameworks", ...frameworks);
-    }
-
-    if (editors.length > 0) {
-      ultraciteArgs.push("--editors", ...editors);
-    }
-
-    if (agents.length > 0) {
-      ultraciteArgs.push("--agents", ...agents);
-    }
-
-    if (hooks.length > 0) {
-      ultraciteArgs.push("--hooks", ...hooks);
-    }
-
-    if (hasHusky) {
-      ultraciteArgs.push("--integrations", "husky", "lint-staged");
-    }
-
-    const ultraciteArgsString = ultraciteArgs.join(" ");
-    const commandWithArgs = `ultracite@latest ${ultraciteArgsString} --skip-install`;
-
-    const ultraciteInitCommand = getPackageExecutionCommand(packageManager, commandWithArgs);
-
-    const s = spinner();
-    s.start("Running Ultracite init command...");
-
-    await execa(ultraciteInitCommand, {
-      cwd: projectDir,
-      env: { CI: "true" },
-      shell: true,
-    });
-
-    if (hasHusky) {
-      await addPackageDependency({
-        devDependencies: ["husky", "lint-staged"],
-        projectDir,
-      });
-    }
-
-    s.stop("Ultracite setup successfully!");
-  } catch (error) {
-    log.error(pc.red("Failed to set up Ultracite"));
-    if (error instanceof Error) {
-      console.error(pc.red(error.message));
-    }
-  }
-}

package/src/helpers/addons/vite-pwa-setup.ts

@@ -1,59 +0,0 @@
-import { type CallExpression, Node, type ObjectLiteralExpression, SyntaxKind } from "ts-morph";
-import { ensureArrayProperty, tsProject } from "../../utils/ts-morph";
-
-export async function addPwaToViteConfig(viteConfigPath: string, projectName: string) {
-  const sourceFile = tsProject.addSourceFileAtPathIfExists(viteConfigPath);
-  if (!sourceFile) {
-    throw new Error("vite config not found");
-  }
-
-  const hasImport = sourceFile
-    .getImportDeclarations()
-    .some((imp) => imp.getModuleSpecifierValue() === "vite-plugin-pwa");
-
-  if (!hasImport) {
-    sourceFile.insertImportDeclaration(0, {
-      namedImports: ["VitePWA"],
-      moduleSpecifier: "vite-plugin-pwa",
-    });
-  }
-
-  const defineCall = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).find((expr) => {
-    const expression = expr.getExpression();
-    return Node.isIdentifier(expression) && expression.getText() === "defineConfig";
-  });
-
-  if (!defineCall) {
-    throw new Error("Could not find defineConfig call in vite config");
-  }
-
-  const callExpr = defineCall as CallExpression;
-  const configObject = callExpr.getArguments()[0] as ObjectLiteralExpression | undefined;
-  if (!configObject) {
-    throw new Error("defineConfig argument is not an object literal");
-  }
-
-  const pluginsArray = ensureArrayProperty(configObject, "plugins");
-
-  const alreadyPresent = pluginsArray
-    .getElements()
-    .some((el) => el.getText().startsWith("VitePWA("));
-
-  if (!alreadyPresent) {
-    pluginsArray.addElement(
-      `VitePWA({
-  registerType: "autoUpdate",
-  manifest: {
-    name: "${projectName}",
-    short_name: "${projectName}",
-    description: "${projectName} - PWA Application",
-    theme_color: "#0c0c0c",
-  },
-  pwaAssets: { disabled: false, config: true },
-  devOptions: { enabled: true },
-})`,
-    );
-  }
-
-  await tsProject.save();
-}

package/src/helpers/core/add-addons.ts

@@ -1,85 +0,0 @@
-import path from "node:path";
-import { log } from "@clack/prompts";
-import pc from "picocolors";
-import type { AddInput, Addons, ProjectConfig } from "../../types";
-import { updateBtsConfig } from "../../utils/bts-config";
-import { validateAddonCompatibility } from "../../utils/compatibility-rules";
-import { exitWithError } from "../../utils/errors";
-import { setupAddons } from "../addons/addons-setup";
-import { detectProjectConfig, isBetterTStackProject } from "./detect-project-config";
-import { installDependencies } from "./install-dependencies";
-import { setupAddonsTemplate } from "./template-manager";
-
-export async function addAddonsToProject(
-  input: AddInput & { addons: Addons[]; suppressInstallMessage?: boolean },
-) {
-  try {
-    const projectDir = input.projectDir || process.cwd();
-
-    const isBetterTStack = await isBetterTStackProject(projectDir);
-    if (!isBetterTStack) {
-      exitWithError(
-        "This doesn't appear to be a Better-T-Stack project. Please run this command from the root of a Better-T-Stack project.",
-      );
-    }
-
-    const detectedConfig = await detectProjectConfig(projectDir);
-    if (!detectedConfig) {
-      exitWithError(
-        "Could not detect the project configuration. Please ensure this is a valid Better-T-Stack project.",
-      );
-    }
-
-    const config: ProjectConfig = {
-      projectName: detectedConfig.projectName || path.basename(projectDir),
-      projectDir,
-      relativePath: ".",
-      database: detectedConfig.database || "none",
-      orm: detectedConfig.orm || "none",
-      backend: detectedConfig.backend || "none",
-      runtime: detectedConfig.runtime || "none",
-      frontend: detectedConfig.frontend || [],
-      addons: input.addons,
-      examples: detectedConfig.examples || [],
-      auth: detectedConfig.auth || "none",
-      payments: detectedConfig.payments || "none",
-      git: false,
-      packageManager: input.packageManager || detectedConfig.packageManager || "npm",
-      install: input.install || false,
-      dbSetup: detectedConfig.dbSetup || "none",
-      api: detectedConfig.api || "none",
-      webDeploy: detectedConfig.webDeploy || "none",
-      serverDeploy: detectedConfig.serverDeploy || "none",
-    };
-
-    for (const addon of input.addons) {
-      const { isCompatible, reason } = validateAddonCompatibility(addon, config.frontend);
-      if (!isCompatible) {
-        exitWithError(
-          reason || `${addon} addon is not compatible with current frontend configuration`,
-        );
-      }
-    }
-
-    await setupAddonsTemplate(projectDir, config);
-    await setupAddons(config, true);
-
-    const currentAddons = detectedConfig.addons || [];
-    const mergedAddons = [...new Set([...currentAddons, ...input.addons])];
-    await updateBtsConfig(projectDir, { addons: mergedAddons });
-
-    if (config.install) {
-      await installDependencies({
-        projectDir,
-        packageManager: config.packageManager,
-      });
-    } else if (!input.suppressInstallMessage) {
-      log.info(
-        pc.yellow(`Run ${pc.bold(`${config.packageManager} install`)} to install dependencies`),
-      );
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    exitWithError(`Error adding addons: ${message}`);
-  }
-}