create-better-t-stack 3.7.3-canary.7cbb05fc → 3.7.3-canary.8e4d5716

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

@@ -0,0 +1,103 @@
+import path from "node:path";
+import { isCancel, log, select, 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 { exitCancelled } from "../../utils/errors";
+import { getPackageExecutionCommand } from "../../utils/package-runner";
+
+type FumadocsTemplate =
+  | "next-mdx"
+  | "waku"
+  | "react-router"
+  | "react-router-spa"
+  | "tanstack-start";
+
+const TEMPLATES = {
+  "next-mdx": {
+    label: "Next.js: Fumadocs MDX",
+    hint: "Recommended template with MDX support",
+    value: "+next+fuma-docs-mdx",
+  },
+  waku: {
+    label: "Waku: Content Collections",
+    hint: "Template using Waku with content collections",
+    value: "waku",
+  },
+  "react-router": {
+    label: "React Router: MDX Remote",
+    hint: "Template for React Router with MDX remote",
+    value: "react-router",
+  },
+  "react-router-spa": {
+    label: "React Router: SPA",
+    hint: "Template for React Router SPA",
+    value: "react-router-spa",
+  },
+  "tanstack-start": {
+    label: "Tanstack Start: MDX Remote",
+    hint: "Template for Tanstack Start with MDX remote",
+    value: "tanstack-start",
+  },
+} as const;
+
+export async function setupFumadocs(config: ProjectConfig) {
+  const { packageManager, projectDir } = config;
+
+  try {
+    log.info("Setting up Fumadocs...");
+
+    const template = await select<FumadocsTemplate>({
+      message: "Choose a template",
+      options: Object.entries(TEMPLATES).map(([key, template]) => ({
+        value: key as FumadocsTemplate,
+        label: template.label,
+        hint: template.hint,
+      })),
+      initialValue: "next-mdx",
+    });
+
+    if (isCancel(template)) return exitCancelled("Operation cancelled");
+
+    const templateArg = TEMPLATES[template].value;
+
+    const commandWithArgs = `create-fumadocs-app@latest fumadocs --template ${templateArg} --src --pm ${packageManager} --no-git`;
+
+    const fumadocsInitCommand = getPackageExecutionCommand(packageManager, commandWithArgs);
+
+    const appsDir = path.join(projectDir, "apps");
+    await fs.ensureDir(appsDir);
+
+    const s = spinner();
+    s.start("Running Fumadocs create command...");
+
+    await execa(fumadocsInitCommand, {
+      cwd: appsDir,
+      env: { CI: "true" },
+      shell: true,
+    });
+
+    const fumadocsDir = path.join(projectDir, "apps", "fumadocs");
+    const packageJsonPath = path.join(fumadocsDir, "package.json");
+
+    if (await fs.pathExists(packageJsonPath)) {
+      const packageJson = await fs.readJson(packageJsonPath);
+      packageJson.name = "fumadocs";
+
+      if (packageJson.scripts?.dev) {
+        packageJson.scripts.dev = `${packageJson.scripts.dev} --port=4000`;
+      }
+
+      await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    }
+
+    s.stop("Fumadocs setup complete!");
+  } catch (error) {
+    log.error(pc.red("Failed to set up Fumadocs"));
+    if (error instanceof Error) {
+      consola.error(pc.red(error.message));
+    }
+  }
+}

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

@@ -0,0 +1,139 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,96 @@
+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

@@ -0,0 +1,232 @@
+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

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