git.stevedylan.dev

Merge pull request #8 from 0xZ0uk/feat/biome-support e97189a3

Added support for Biome linter

Steve Simkins · 2025-07-09 19:18 4 file(s) · +431 −323

bun.lock +6 −6

4	4		"": {
5	5		"name": "create-bhvr",
6	6		"dependencies": {
7		-	"chalk": "^5.3.0",
	7	+	"chalk": "^5.4.1",
8	8		"commander": "^11.1.0",
9	9		"degit": "^2.8.4",
10		-	"execa": "^7.1.1",
	10	+	"execa": "^7.2.0",
11	11		"figlet": "^1.8.1",
12		-	"fs-extra": "^11.2.0",
	12	+	"fs-extra": "^11.3.0",
13	13		"ora": "^6.3.1",
14	14		"prompts": "^2.4.2",
15	15		},

17	17		"@types/degit": "^2.8.6",
18	18		"@types/figlet": "^1.7.0",
19	19		"@types/fs-extra": "^11.0.4",
20		-	"@types/inquirer": "^9.0.7",
21		-	"@types/node": "^20.11.17",
	20	+	"@types/inquirer": "^9.0.8",
	21	+	"@types/node": "^20.19.0",
22	22		"@types/prompts": "^2.4.9",
23	23		"ts-node": "^10.9.2",
24		-	"typescript": "^5.3.3",
	24	+	"typescript": "^5.8.3",
25	25		},
26	26		},
27	27		},

src/index.ts +44 −43

import { displayBanner, createProject, DEFAULT_REPO } from "./utils";

program
	.name("create-bhvr")
	.description("Create a bhvr monorepo starter project")
	.argument("[project-directory]", "directory to create the project in")
	.option("-y, --yes", "skip confirmation prompts")
	.option("--ts, --typescript", "use TypeScript (default)")
	.option(
		"--repo <repo>",
		"specify a custom GitHub repository as source",
		DEFAULT_REPO,
	)
	.option(
		"--template <template>",
		"specify a template (default, tailwind, shadcn)",
		"default",
	)
	.option("--branch <branch>", "specify a branch to use from the repository")
	.option("--rpc", "use Hono RPC client for type-safe API communication")
  .name("create-bhvr")
  .description("Create a bhvr monorepo starter project")
  .argument("[project-directory]", "directory to create the project in")
  .option("-y, --yes", "skip confirmation prompts")
  .option("--ts, --typescript", "use TypeScript (default)")
  .option(
    "--repo <repo>",
    "specify a custom GitHub repository as source",
    DEFAULT_REPO,
  )
  .option(
    "--template <template>",
    "specify a template (default, tailwind, shadcn)",
    "default",
  )
  .option("--branch <branch>", "specify a branch to use from the repository")
  .option("--rpc", "use Hono RPC client for type-safe API communication")
	.option("--linter <linter>", "specify the linter to use (eslint or biome)")
	.action(async (projectDirectory, options) => {
		try {
			displayBanner();
			const result = await createProject(projectDirectory, options);
			if (result) {
				console.log(chalk.green.bold("🎉 Project created successfully!"));
				console.log("\nNext steps:");
    try {
      displayBanner();
      const result = await createProject(projectDirectory, options);
      if (result) {
        console.log(chalk.green.bold("🎉 Project created successfully!"));
        console.log("\nNext steps:");

				if (!result.dependenciesInstalled) {
					console.log(chalk.cyan(`  cd ${result.projectName}`));
					console.log(chalk.cyan("  bun install"));
				} else {
					console.log(chalk.cyan(`  cd ${result.projectName}`));
				}
        if (!result.dependenciesInstalled) {
          console.log(chalk.cyan(`  cd ${result.projectName}`));
          console.log(chalk.cyan("  bun install"));
        } else {
          console.log(chalk.cyan(`  cd ${result.projectName}`));
        }

				console.log(chalk.cyan("  bun run dev:client   # Start the client"));
				console.log(
					chalk.cyan(
						"  bun run dev:server   # Start the server in another terminal",
					),
				);
				console.log(chalk.cyan("  bun run dev          # Start all"));
				process.exit(0);
			}
		} catch (err) {
			console.error(chalk.red("Error creating project:"), err);
			process.exit(1);
		}
	});
        console.log(chalk.cyan("  bun run dev:client   # Start the client"));
        console.log(
          chalk.cyan(
            "  bun run dev:server   # Start the server in another terminal",
          ),
        );
        console.log(chalk.cyan("  bun run dev          # Start all"));
        process.exit(0);
      }
    } catch (err) {
      console.error(chalk.red("Error creating project:"), err);
      process.exit(1);
    }
  });

program.parse();

src/types.ts +3 −2

	description: string;
}

export interface ProjectOptions {
export type ProjectOptions = {
	yes?: boolean;
	typescript?: boolean;
	repo?: string;
	template?: string;
	branch?: string;
	rpc?: boolean;
}
	linter?: 'eslint' | 'biome';
};

export interface ProjectResult {
	projectName: string;

src/utils/helpers.ts +378 −272

import path from "node:path";
import fs from "fs-extra";
import {
	honoRpcTemplate,
	honoClientTemplate,
	shadcnTemplate,
	tailwindTemplate,
	defaultTemplate,
	TEMPLATES,
  honoRpcTemplate,
  honoClientTemplate,
  shadcnTemplate,
  tailwindTemplate,
  defaultTemplate,
  TEMPLATES,
} from "./templates";
import type { ProjectOptions, ProjectResult } from "../types";
import degit from "degit";

export const DEFAULT_REPO = "stevedylandev/bhvr";

export function displayBanner() {
	try {
		const text = figlet.textSync("bhvr", {
			font: "Big",
			horizontalLayout: "default",
			verticalLayout: "default",
			width: 80,
			whitespaceBreak: true,
		});
  try {
    const text = figlet.textSync("bhvr", {
      font: "Big",
      horizontalLayout: "default",
      verticalLayout: "default",
      width: 80,
      whitespaceBreak: true,
    });

		console.log("\n");
		console.log(chalk.yellowBright(text));
	} catch (error) {
		console.log("\n");
		console.log(chalk.yellowBright("B H V R"));
		console.log(chalk.yellow("=========="));
	}
    console.log("\n");
    console.log(chalk.yellowBright(text));
  } catch (error) {
    console.log("\n");
    console.log(chalk.yellowBright("B H V R"));
    console.log(chalk.yellow("=========="));
  }

	console.log(`\n${chalk.cyan("🦫 Lets build 🦫")}\n`);
	console.log(`${chalk.blue("https://github.com/stevedylandev/bhvr")}\n`);
  console.log(`\n${chalk.cyan("🦫 Lets build 🦫")}\n`);
  console.log(`${chalk.blue("https://github.com/stevedylandev/bhvr")}\n`);
}

export async function patchFilesForRPC(
	projectPath: string,
	templateChoice: string,
  projectPath: string,
  templateChoice: string,
): Promise<boolean> {
	const spinner = ora("Setting up RPC client...").start();
  const spinner = ora("Setting up RPC client...").start();

	try {
		// 1. Update client package.json to ensure hono client is installed
		const clientPkgPath = path.join(projectPath, "client", "package.json");
		const clientPkg = await fs.readJson(clientPkgPath);
  try {
    // 1. Update client package.json to ensure hono client is installed
    const clientPkgPath = path.join(projectPath, "client", "package.json");
    const clientPkg = await fs.readJson(clientPkgPath);

		if (!clientPkg.dependencies.hono) {
			await execa("bun", ["install", "hono"], { cwd: projectPath });
		}
    if (!clientPkg.dependencies.hono) {
      await execa("bun", ["install", "hono"], { cwd: projectPath });
    }

		await fs.writeJson(clientPkgPath, clientPkg, { spaces: 2 });
    await fs.writeJson(clientPkgPath, clientPkg, { spaces: 2 });

		// 2. Update server package.json dev script for RPC
		const serverPkgPath = path.join(projectPath, "server", "package.json");
		const serverPkg = await fs.readJson(serverPkgPath);
    // 2. Update server package.json dev script for RPC
    const serverPkgPath = path.join(projectPath, "server", "package.json");
    const serverPkg = await fs.readJson(serverPkgPath);

		// Update the dev script to include TypeScript compilation
		serverPkg.scripts.dev = "bun --watch run src/index.ts && tsc --watch";
    // Update the dev script to include TypeScript compilation
    serverPkg.scripts.dev = "bun --watch run src/index.ts && tsc --watch";

		await fs.writeJson(serverPkgPath, serverPkg, { spaces: 2 });
    await fs.writeJson(serverPkgPath, serverPkg, { spaces: 2 });

		// 3. Server modification for RPC export type (no client imports)
		const serverIndexPath = path.join(projectPath, "server", "src", "index.ts");
		await fs.writeFile(serverIndexPath, honoRpcTemplate, "utf8");
    // 3. Server modification for RPC export type (no client imports)
    const serverIndexPath = path.join(projectPath, "server", "src", "index.ts");
    await fs.writeFile(serverIndexPath, honoRpcTemplate, "utf8");

		// 4. Create separate client helper file
		const clientHelperPath = path.join(
			projectPath,
			"server",
			"src",
			"client.ts",
		);
		await fs.writeFile(clientHelperPath, honoClientTemplate, "utf8");
    // 4. Create separate client helper file
    const clientHelperPath = path.join(
      projectPath,
      "server",
      "src",
      "client.ts",
    );
    await fs.writeFile(clientHelperPath, honoClientTemplate, "utf8");

		// 5. Update App.tsx based on template selection using switch statement
		const appTsxPath = path.join(projectPath, "client", "src", "App.tsx");
    // 5. Update App.tsx based on template selection using switch statement
    const appTsxPath = path.join(projectPath, "client", "src", "App.tsx");

		// Determine template content based on the template type
		let updatedAppContent: string;
    // Determine template content based on the template type
    let updatedAppContent: string;

		// Select template based on choice
		switch (templateChoice) {
			case "shadcn":
				updatedAppContent = shadcnTemplate;
				break;
			case "tailwind":
				updatedAppContent = tailwindTemplate;
				break;
			default:
				updatedAppContent = defaultTemplate;
				break;
		}
    // Select template based on choice
    switch (templateChoice) {
      case "shadcn":
        updatedAppContent = shadcnTemplate;
        break;
      case "tailwind":
        updatedAppContent = tailwindTemplate;
        break;
      default:
        updatedAppContent = defaultTemplate;
        break;
    }

		await fs.writeFile(appTsxPath, updatedAppContent, "utf8");
		spinner.succeed("RPC client setup completed");
		return true;
	} catch (err: unknown) {
		spinner.fail("Failed to set up RPC client");
		if (err instanceof Error) {
			console.error(chalk.red("Error:"), err.message);
		} else {
			console.error(chalk.red("Error: Unknown error"));
		}
		return false;
	}
    await fs.writeFile(appTsxPath, updatedAppContent, "utf8");
    spinner.succeed("RPC client setup completed");
    return true;
  } catch (err: unknown) {
    spinner.fail("Failed to set up RPC client");
    if (err instanceof Error) {
      console.error(chalk.red("Error:"), err.message);
    } else {
      console.error(chalk.red("Error: Unknown error"));
    }
    return false;
  }
}

export async function createProject(
	projectDirectory: string,
	options: ProjectOptions,
  projectDirectory: string,
  options: ProjectOptions,
): Promise<ProjectResult | null> {
	let projectName = projectDirectory;
  let projectName = projectDirectory;

	if (!projectName && !options.yes) {
		const response = await prompts({
			type: "text",
			name: "projectName",
			message: "What is the name of your project?",
			initial: "my-bhvr-app",
		});
  if (!projectName && !options.yes) {
    const response = await prompts({
      type: "text",
      name: "projectName",
      message: "What is the name of your project?",
      initial: "my-bhvr-app",
    });

		if (!response.projectName) {
			console.log(chalk.yellow("Project creation cancelled."));
			return null;
		}
    if (!response.projectName) {
      console.log(chalk.yellow("Project creation cancelled."));
      return null;
    }

		projectName = response.projectName;
	} else if (!projectName) {
		projectName = "my-bhvr-app";
	}
    projectName = response.projectName;
  } else if (!projectName) {
    projectName = "my-bhvr-app";
  }

	let templateChoice = options.template || "default";
  let templateChoice = options.template || "default";

	if (!options.yes && !options.branch) {
		const templateChoices = Object.keys(TEMPLATES).map((key) => ({
			title: `${key} (${TEMPLATES[key]?.description})`,
			value: key,
		}));
  if (!options.yes && !options.branch) {
    const templateChoices = Object.keys(TEMPLATES).map((key) => ({
      title: `${key} (${TEMPLATES[key]?.description})`,
      value: key,
    }));

		const templateResponse = await prompts({
			type: "select",
			name: "template",
			message: "Select a template:",
			choices: templateChoices,
			initial: 0,
		});
    const templateResponse = await prompts({
      type: "select",
      name: "template",
      message: "Select a template:",
      choices: templateChoices,
      initial: 0,
    });

		if (templateResponse.template === undefined) {
			console.log(chalk.yellow("Project creation cancelled."));
			return null;
		}
    if (templateResponse.template === undefined) {
      console.log(chalk.yellow("Project creation cancelled."));
      return null;
    }

		templateChoice = templateResponse.template;
	}
    templateChoice = templateResponse.template;
  }

	const projectPath = path.resolve(process.cwd(), projectName);
  const projectPath = path.resolve(process.cwd(), projectName);

	if (fs.existsSync(projectPath)) {
		const files = fs.readdirSync(projectPath);
  if (fs.existsSync(projectPath)) {
    const files = fs.readdirSync(projectPath);

		if (files.length > 0 && !options.yes) {
			const { overwrite } = await prompts({
				type: "confirm",
				name: "overwrite",
				message: `The directory ${projectName} already exists and is not empty. Do you want to overwrite it?`,
				initial: false,
			});
    if (files.length > 0 && !options.yes) {
      const { overwrite } = await prompts({
        type: "confirm",
        name: "overwrite",
        message: `The directory ${projectName} already exists and is not empty. Do you want to overwrite it?`,
        initial: false,
      });

			if (!overwrite) {
				console.log(chalk.yellow("Project creation cancelled."));
				return null;
			}
      if (!overwrite) {
        console.log(chalk.yellow("Project creation cancelled."));
        return null;
      }

			await fs.emptyDir(projectPath);
		}
	}
      await fs.emptyDir(projectPath);
    }
  }

	fs.ensureDirSync(projectPath);
  fs.ensureDirSync(projectPath);

	const repoPath = options.repo || DEFAULT_REPO;
	const templateConfig =
		TEMPLATES[templateChoice as keyof typeof TEMPLATES] || TEMPLATES.default;
	const branch = options.branch || (templateConfig?.branch ?? "main");
	const repoUrl = `${repoPath}#${branch}`;
	const spinner = ora("Downloading template...").start();
  const repoPath = options.repo || DEFAULT_REPO;
  const templateConfig =
    TEMPLATES[templateChoice as keyof typeof TEMPLATES] || TEMPLATES.default;
  const branch = options.branch || (templateConfig?.branch ?? "main");
  const repoUrl = `${repoPath}#${branch}`;
  const spinner = ora("Downloading template...").start();

	try {
		const emitter = degit(repoUrl, {
			cache: false,
			force: true,
			verbose: false,
		});
  try {
    const emitter = degit(repoUrl, {
      cache: false,
      force: true,
      verbose: false,
    });

		await emitter.clone(projectPath);
		spinner.succeed(
			`Template downloaded successfully (${templateChoice} template)`,
		);
    await emitter.clone(projectPath);
    spinner.succeed(
      `Template downloaded successfully (${templateChoice} template)`,
    );

		const pkgJsonPath = path.join(projectPath, "package.json");
		if (fs.existsSync(pkgJsonPath)) {
			const pkgJson = await fs.readJson(pkgJsonPath);
			pkgJson.name = projectName;
			await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
		}
    const pkgJsonPath = path.join(projectPath, "package.json");
    if (fs.existsSync(pkgJsonPath)) {
      const pkgJson = await fs.readJson(pkgJsonPath);
      pkgJson.name = projectName;
      await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
    }

		const gitDir = path.join(projectPath, ".git");
		if (fs.existsSync(gitDir)) {
			await fs.remove(gitDir);
			console.log(chalk.blue("Removed .git directory"));
		}
    const gitDir = path.join(projectPath, ".git");
    if (fs.existsSync(gitDir)) {
      await fs.remove(gitDir);
      console.log(chalk.blue("Removed .git directory"));
    }

		let useRpc = options.rpc;
    let useRpc = options.rpc;

		if (!options.yes && !options.rpc) {
			const rpcResponse = await prompts({
				type: "confirm",
				name: "useRpc",
				message: "Use Hono RPC client for type-safe API communication?",
				initial: false,
			});
    if (!options.yes && !options.rpc) {
      const rpcResponse = await prompts({
        type: "confirm",
        name: "useRpc",
        message: "Use Hono RPC client for type-safe API communication?",
        initial: false,
      });

      if (rpcResponse.useRpc === undefined) {
        console.log(chalk.yellow("Project creation cancelled."));
        return null;
      }

      useRpc = rpcResponse.useRpc;
    }

    if (useRpc) {
      await patchFilesForRPC(projectPath, templateChoice);
    }

    let linter = options.linter;

    if (!options.yes && !options.linter) {
      const linterResponse = await prompts({
        type: "select",
        name: "linter",
        message: "Select a linter:",
        choices: [
          { title: "ESLint (default)", value: "eslint" },
          { title: "Biome", value: "biome" },
        ],
        initial: 0,
      });

      if (linterResponse.linter === undefined) {
        console.log(chalk.yellow("Project creation cancelled."));
        return null;
      }

      linter = linterResponse.linter;
    }

    if (linter === "biome") {
      await setupBiome(projectPath);
    }

    let gitInitialized = false;

    if (!options.yes) {
      const gitResponse = await prompts({
        type: "confirm",
        name: "initGit",
        message: "Initialize a git repository?",
        initial: true,
      });

      if (gitResponse.initGit) {
        try {
          spinner.start("Initializing git repository...");
          await execa("git", ["init"], { cwd: projectPath });
          spinner.succeed("Git repository initialized");
          gitInitialized = true;
        } catch (err: unknown) {
          spinner.fail(
            "Failed to initialize git repository. Is git installed?",
          );
          if (err instanceof Error) {
            console.error(chalk.red("Git error:"), err.message);
          } else {
            console.error(chalk.red("Git error: Unknown error"));
          }
        }
      }
    } else {
      try {
        spinner.start("Initializing git repository...");
        await execa("git", ["init"], { cwd: projectPath });
        spinner.succeed("Git repository initialized");
        gitInitialized = true;
      } catch (err) {
        spinner.fail("Failed to initialize git repository. Is git installed?");
      }
    }

    let dependenciesInstalled = false;

    if (!options.yes) {
      const depsResponse = await prompts({
        type: "confirm",
        name: "installDeps",
        message: "Install dependencies?",
        initial: true,
      });

      if (depsResponse.installDeps) {
        spinner.start("Installing dependencies...");
        try {
          await execa("bun", ["install"], { cwd: projectPath });
          spinner.succeed("Dependencies installed with bun");
          dependenciesInstalled = true;
        } catch (_bunErr) {
          try {
            spinner.text = "Installing dependencies with npm...";
            await execa("npm", ["install"], { cwd: projectPath });
            spinner.succeed("Dependencies installed with npm");
            dependenciesInstalled = true;
          } catch (_npmErr) {
            spinner.fail("Failed to install dependencies.");
            console.log(
              chalk.yellow(
                "You can install them manually after navigating to the project directory.",
              ),
            );
          }
        }
      }
    } else {
      spinner.start("Installing dependencies...");
      try {
        await execa("bun", ["install"], { cwd: projectPath });
        spinner.succeed("Dependencies installed with bun");
        dependenciesInstalled = true;
      } catch (_bunErr) {
        try {
          spinner.text = "Installing dependencies with npm...";
          await execa("npm", ["install"], { cwd: projectPath });
          spinner.succeed("Dependencies installed with npm");
          dependenciesInstalled = true;
        } catch (_npmErr) {
          spinner.fail(
            "Failed to install dependencies. You can install them manually later.",
          );
        }
      }
    }

			if (rpcResponse.useRpc === undefined) {
				console.log(chalk.yellow("Project creation cancelled."));
				return null;
			}
    return {
      projectName,
      gitInitialized,
      dependenciesInstalled,
      template: templateChoice,
    };
  } catch (err) {
    spinner.fail("Failed to download template");
    throw err;
  }
}

			useRpc = rpcResponse.useRpc;
		}
export async function setupBiome(projectPath: string): Promise<void> {
  const spinner = ora("Setting up Biome...").start();
  try {
    const clientPath = path.join(projectPath, "client");
    const clientPkgJsonPath = path.join(clientPath, "package.json");
    const eslintConfigPath = path.join(clientPath, "eslint.config.js");

		if (useRpc) {
			await patchFilesForRPC(projectPath, templateChoice);
		}
    // Remove ESLint config file
    if (fs.existsSync(eslintConfigPath)) {
      await fs.remove(eslintConfigPath);
    }

		let gitInitialized = false;
    // Read client package.json and remove ESLint dependencies
    const clientPkgJson = await fs.readJson(clientPkgJsonPath);
    const devDependencies = clientPkgJson.devDependencies || {};
    const eslintDeps = Object.keys(devDependencies).filter(
      (dep) => dep.includes("eslint") || dep.includes("@eslint"),
    );

		if (!options.yes) {
			const gitResponse = await prompts({
				type: "confirm",
				name: "initGit",
				message: "Initialize a git repository?",
				initial: true,
			});
    if (eslintDeps.length > 0) {
      spinner.text = "Replacing ESLint dependencies...";
      await execa("bun", ["remove", ...eslintDeps], { cwd: clientPath });
    }

			if (gitResponse.initGit) {
				try {
					spinner.start("Initializing git repository...");
					await execa("git", ["init"], { cwd: projectPath });
					spinner.succeed("Git repository initialized");
					gitInitialized = true;
				} catch (err: unknown) {
					spinner.fail(
						"Failed to initialize git repository. Is git installed?",
					);
					if (err instanceof Error) {
						console.error(chalk.red("Git error:"), err.message);
					} else {
						console.error(chalk.red("Git error: Unknown error"));
					}
				}
			}
		} else {
			try {
				spinner.start("Initializing git repository...");
				await execa("git", ["init"], { cwd: projectPath });
				spinner.succeed("Git repository initialized");
				gitInitialized = true;
			} catch (err) {
				spinner.fail("Failed to initialize git repository. Is git installed?");
			}
		}
    // Install Biome in the root of the project
    spinner.text = "Installing Biome...";
    await execa("bun", ["add", "-D", "@biomejs/biome"], { cwd: projectPath });

		let dependenciesInstalled = false;
    // Create biome.json in the root of the project
    spinner.text = "Creating biome.json...";
    const biomeConfig = {
      $schema: "https://biomejs.dev/schemas/1.7.3/schema.json",
      vcs: {
        enabled: true,
        clientKind: "git",
        useIgnoreFile: true,
      },
      files: { ignoreUnknown: false, ignore: [] },
      formatter: { enabled: true },
      organizeImports: { enabled: true },
      linter: {
        enabled: true,
        rules: {
          recommended: true,
        },
      },
    };
    const biomeConfigPath = path.join(projectPath, "biome.json");
    await fs.writeJson(biomeConfigPath, biomeConfig, { spaces: 2 });

		if (!options.yes) {
			const depsResponse = await prompts({
				type: "confirm",
				name: "installDeps",
				message: "Install dependencies?",
				initial: true,
			});
    // Update client package.json scripts to remove lint
    spinner.text = "Updating scripts in client/package.json...";
    const newClientPkgJson = await fs.readJson(clientPkgJsonPath);
    if (newClientPkgJson.scripts || newClientPkgJson.scripts.lint) {
      delete newClientPkgJson.scripts.lint;
    }
    await fs.writeJson(clientPkgJsonPath, newClientPkgJson, { spaces: 2 });

			if (depsResponse.installDeps) {
				spinner.start("Installing dependencies...");
				try {
					await execa("bun", ["install"], { cwd: projectPath });
					spinner.succeed("Dependencies installed with bun");
					dependenciesInstalled = true;
				} catch (bunErr) {
					try {
						spinner.text = "Installing dependencies with npm...";
						await execa("npm", ["install"], { cwd: projectPath });
						spinner.succeed("Dependencies installed with npm");
						dependenciesInstalled = true;
					} catch (npmErr) {
						spinner.fail("Failed to install dependencies.");
						console.log(
							chalk.yellow(
								"You can install them manually after navigating to the project directory.",
							),
						);
					}
				}
			}
		} else {
			spinner.start("Installing dependencies...");
			try {
				await execa("bun", ["install"], { cwd: projectPath });
				spinner.succeed("Dependencies installed with bun");
				dependenciesInstalled = true;
			} catch (bunErr) {
				try {
					spinner.text = "Installing dependencies with npm...";
					await execa("npm", ["install"], { cwd: projectPath });
					spinner.succeed("Dependencies installed with npm");
					dependenciesInstalled = true;
				} catch (npmErr) {
					spinner.fail(
						"Failed to install dependencies. You can install them manually later.",
					);
				}
			}
		}
    // Update root package.json with biome scripts
    spinner.text = "Updating scripts in root/package.json...";
    const rootPkgJsonPath = path.join(projectPath, "package.json");
    if (fs.existsSync(rootPkgJsonPath)) {
      const rootPkgJson = await fs.readJson(rootPkgJsonPath);
      rootPkgJson.scripts = rootPkgJson.scripts || {};
      rootPkgJson.scripts.format = "biome format . --write";
      rootPkgJson.scripts.lint = "biome lint .";
      await fs.writeJson(rootPkgJsonPath, rootPkgJson, { spaces: 2 });
    }

		return {
			projectName,
			gitInitialized,
			dependenciesInstalled,
			template: templateChoice,
		};
	} catch (err) {
		spinner.fail("Failed to download template");
		throw err;
	}
    spinner.succeed("Biome setup complete.");
  } catch (error) {
    spinner.fail("Biome setup failed.");
    if (error instanceof Error) {
      console.error(chalk.red("\nError:"), error.message);
    } else {
      console.error(chalk.red("\nError: Unknown error during Biome setup."));
    }
  }
}

6	6		import { displayBanner, createProject, DEFAULT_REPO } from "./utils";
7	7
8	8		program
9		-	.name("create-bhvr")
10		-	.description("Create a bhvr monorepo starter project")
11		-	.argument("[project-directory]", "directory to create the project in")
12		-	.option("-y, --yes", "skip confirmation prompts")
13		-	.option("--ts, --typescript", "use TypeScript (default)")
14		-	.option(
15		-	"--repo <repo>",
16		-	"specify a custom GitHub repository as source",
17		-	DEFAULT_REPO,
18		-	)
19		-	.option(
20		-	"--template <template>",
21		-	"specify a template (default, tailwind, shadcn)",
22		-	"default",
23		-	)
24		-	.option("--branch <branch>", "specify a branch to use from the repository")
25		-	.option("--rpc", "use Hono RPC client for type-safe API communication")
	9	+	.name("create-bhvr")
	10	+	.description("Create a bhvr monorepo starter project")
	11	+	.argument("[project-directory]", "directory to create the project in")
	12	+	.option("-y, --yes", "skip confirmation prompts")
	13	+	.option("--ts, --typescript", "use TypeScript (default)")
	14	+	.option(
	15	+	"--repo <repo>",
	16	+	"specify a custom GitHub repository as source",
	17	+	DEFAULT_REPO,
	18	+	)
	19	+	.option(
	20	+	"--template <template>",
	21	+	"specify a template (default, tailwind, shadcn)",
	22	+	"default",
	23	+	)
	24	+	.option("--branch <branch>", "specify a branch to use from the repository")
	25	+	.option("--rpc", "use Hono RPC client for type-safe API communication")
	26	+	.option("--linter <linter>", "specify the linter to use (eslint or biome)")
26	27		.action(async (projectDirectory, options) => {
27		-	try {
28		-	displayBanner();
29		-	const result = await createProject(projectDirectory, options);
30		-	if (result) {
31		-	console.log(chalk.green.bold("🎉 Project created successfully!"));
32		-	console.log("\nNext steps:");
	28	+	try {
	29	+	displayBanner();
	30	+	const result = await createProject(projectDirectory, options);
	31	+	if (result) {
	32	+	console.log(chalk.green.bold("🎉 Project created successfully!"));
	33	+	console.log("\nNext steps:");
33	34
34		-	if (!result.dependenciesInstalled) {
35		-	console.log(chalk.cyan(` cd ${result.projectName}`));
36		-	console.log(chalk.cyan(" bun install"));
37		-	} else {
38		-	console.log(chalk.cyan(` cd ${result.projectName}`));
39		-	}
	35	+	if (!result.dependenciesInstalled) {
	36	+	console.log(chalk.cyan(` cd ${result.projectName}`));
	37	+	console.log(chalk.cyan(" bun install"));
	38	+	} else {
	39	+	console.log(chalk.cyan(` cd ${result.projectName}`));
	40	+	}
40	41
41		-	console.log(chalk.cyan(" bun run dev:client # Start the client"));
42		-	console.log(
43		-	chalk.cyan(
44		-	" bun run dev:server # Start the server in another terminal",
45		-	),
46		-	);
47		-	console.log(chalk.cyan(" bun run dev # Start all"));
48		-	process.exit(0);
49		-	}
50		-	} catch (err) {
51		-	console.error(chalk.red("Error creating project:"), err);
52		-	process.exit(1);
53		-	}
54		-	});
	42	+	console.log(chalk.cyan(" bun run dev:client # Start the client"));
	43	+	console.log(
	44	+	chalk.cyan(
	45	+	" bun run dev:server # Start the server in another terminal",
	46	+	),
	47	+	);
	48	+	console.log(chalk.cyan(" bun run dev # Start all"));
	49	+	process.exit(0);
	50	+	}
	51	+	} catch (err) {
	52	+	console.error(chalk.red("Error creating project:"), err);
	53	+	process.exit(1);
	54	+	}
	55	+	});
55	56
56	57		program.parse();

3	3		description: string;
4	4		}
5	5
6		-	export interface ProjectOptions {
	6	+	export type ProjectOptions = {
7	7		yes?: boolean;
8	8		typescript?: boolean;
9	9		repo?: string;
10	10		template?: string;
11	11		branch?: string;
12	12		rpc?: boolean;
13		-	}
	13	+	linter?: 'eslint' \| 'biome';
	14	+	};
14	15
15	16		export interface ProjectResult {
16	17		projectName: string;