# Contributing to create-bhvr

First off, thank you for considering contributing to `create-bhvr`.

## How Can I Contribute?

### Reporting Bugs

If you find a bug, please make sure the bug has not already been reported by searching on GitHub under [Issues](https://github.com/stevedylandev/bhvr/issues). If you're unable to find an open issue addressing the problem, [open a new one](https://github.com/stevedylandev/bhvr/issues/new). Be sure to include a **title and clear description**, as much relevant information as possible, and a **code sample** or an **executable test case** demonstrating the expected behavior that is not occurring.

### Suggesting Enhancements

If you have an idea for an enhancement, please make sure the enhancement has not already been suggested by searching on GitHub under [Issues](https://github.com/stevedylandev/bhvr/issues). If you're unable to find an open issue addressing the suggestion, [open a new one](https://github.com/stevedylandev/bhvr/issues/new). Be sure to include a **title and clear description** of the enhancement you're suggesting.

### Submitting a Pull Request

1.  Fork the repository and create your branch from `main`.

2.  Run `bun install` to install the dependencies.

3.  Make your changes.

4.  Run `bun run build` to make sure your changes build correctly.

5.  Issue that pull request!

## License

By contributing, you agree that your contributions will be licensed under its MIT License.

# create-bhvr 🦫

![cover](https://cdn.stevedylan.dev/ipfs/bafybeievx27ar5qfqyqyud7kemnb5n2p4rzt2matogi6qttwkpxonqhra4)

[![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/stevedylandev/create-bhvr/blob/main/LICENSE)

![create-bhvr version](https://img.shields.io/npm/v/create-bhvr.svg?label=%20)

A command-line interface (CLI) to quickly scaffold a new `bhvr` project. `bhvr` is a full-stack TypeScript monorepo starter with shared types, using Bun, Hono, Vite, and React.

## Getting Started

To create a new `bhvr` project, run any of the following commands and follow the interactive prompts:

```bash

# Using Bun

bun create bhvr@latest my-bhvr-app

```

This will create a new directory called `my-bhvr-app` inside the current folder.

## Features

- **Interactive Setup**: A simple and fast interactive CLI to guide you through project setup.

- **Multiple Templates**: Choose from several templates to get started:

    - `default`: A basic setup with Bun, Hono, Vite, and React.

    - `tailwind`: Includes Tailwind CSS for styling.

    - `shadcn`: Pre-configured with Tailwind CSS and shadcn/ui.

- **Optional RPC**: Automatically configure Hono RPC for end-to-end type-safe API communication.

- **Linter Choice**: Choose between ESLint (default) or Biome for code linting and formatting.

- **Automated Setup**: Handles `git` initialization and dependency installation for you.

## Command-Line Options

You can also use command-line options to skip the interactive prompts:

| Option                  | Description                                            | Default   |

| ----------------------- | ------------------------------------------------------ | --------- |

| `[project-directory]`   | The name of the directory to create the project in.    | -         |

| `-y, --yes`             | Skip all confirmation prompts and use default values.  | `false`   |

| `--template <template>` | Specify a template (`default`, `tailwind`, `shadcn`).  | `default` |

| `--rpc`                 | Use Hono RPC for type-safe API communication.          | `false`   |

| `--linter <linter>`     | Specify the linter to use (`eslint` or `biome`).       | `eslint`  |

| `--branch <branch>`     | Specify a branch to use from the repository.           | `main`    |

## Contributing

We welcome contributions from the community! Whether it's reporting a bug, suggesting a new feature, or submitting a pull request, your help is appreciated.

Please read our [**CONTRIBUTING.md**](CONTRIBUTING.md) for detailed guidelines on how to get started.

## Links

- [License (MIT)](LICENSE)

- [Contributing](CONTRIBUTING.md)

- [Website](https://bhvr.dev)

        "consola": "^3.4.2",

        "picocolors": "^1.1.1",

        "yocto-spinner": "^1.0.0",

    "commander": ["commander@11.1.0", "", {}, "sha512-yPVavfyCcRhmorC7rWlkHn15b4wDVgVmBA7kV4QVBsF7kv/9TKJAbAXVTxvTnwP8HHKjRCJDClKbciiYS7p0DQ=="],

    "consola": ["consola@3.4.2", "", {}, "sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA=="],

    "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="],

    "yocto-spinner": ["yocto-spinner@1.0.0", "", { "dependencies": { "yoctocolors": "^2.1.1" } }, "sha512-VPX8P/+Z2Fnpx8PC/JELbxp3QRrBxjAekio6yulGtA5gKt9YyRc5ycCb+NHgZCbZ0kx9KxwZp7gC6UlrCcCdSQ=="],

    "yoctocolors": ["yoctocolors@2.1.1", "", {}, "sha512-GQHQqAopRhwU8Kt1DDM8NjibDXHC8eoh1erhGAJPEyveY9qqVeXvVikNKrDz69sHowPMorbPUrH/mx8c50eiBQ=="],

  "name": "create-bhvr",

  "version": "0.3.12",

  "description": "Create a new bhvr project",

  "type": "module",

  "main": "./dist/index.js",

  "types": "./dist/index.d.ts",

  "bin": {

    "create-bhvr": "./dist/index.js"

  },

  "files": [

    "dist"

  ],

  "scripts": {

    "build": "bun build src/index.ts --outdir dist --target node",

    "start": "bun ./dist/index.js"

  },

  "keywords": [

    "bun",

    "vite",

    "react",

    "hono",

    "monorepo",

    "starter",

    "template",

    "create"

  ],

  "author": "Steve Simkins",

  "license": "MIT",

  "devDependencies": {

    "@types/degit": "^2.8.6",

    "@types/figlet": "^1.7.0",

    "@types/fs-extra": "^11.0.4",

    "@types/inquirer": "^9.0.8",

    "@types/node": "^20.19.0",

    "@types/prompts": "^2.4.9",

    "ts-node": "^10.9.2",

    "typescript": "^5.8.3"

  },

  "dependencies": {

    "commander": "^11.1.0",

    "consola": "^3.4.2",

    "degit": "^2.8.4",

    "execa": "^7.2.0",

    "figlet": "^1.8.1",

    "fs-extra": "^11.3.0",

    "picocolors": "^1.1.1",

    "yocto-spinner": "^1.0.0"

  },

  "engines": {

    "node": ">=18"

  }

import pc from "picocolors";

import { displayBanner } from "@/lib/display-banner";

import type { ProjectOptions } from "@/types";

import { createProject } from "../lib/create-project";

export const create = async (

  projectDirectory: string,

  options: ProjectOptions,

) => {

  try {

    displayBanner();

    const result = await createProject(projectDirectory, options);

    if (result) {

      console.log(pc.green(pc.bold("🎉 Project created successfully!")));

      console.log("\nNext steps:");

      if (!result.dependenciesInstalled) {

        console.log(pc.cyan(`  cd ${result.projectName}`));

        console.log(pc.cyan("  bun install"));

      } else {

        console.log(pc.cyan(`  cd ${result.projectName}`));

      }

      console.log(pc.cyan("  bun run dev:client   # Start the client"));

      console.log(

        pc.cyan(

          "  bun run dev:server   # Start the server in another terminal",

        ),

      );

      console.log(pc.cyan("  bun run dev          # Start all"));

      process.exit(0);

    }

  } catch (err) {

    console.error(pc.red("Error creating project:"), err);

    process.exit(1);

  }

};

import { create } from "@/commands/create";

import { program } from "@/program";

import { DEFAULT_REPO } from "./utils";

  .option("--linter <linter>", "specify the linter to use (eslint or biome)")

  .action(create);

import type { ProjectOptions, ProjectResult } from "@/types";

import { initializeGit } from "./initialize-git";

import { installDependencies } from "./install-dependencies";

import { promptForOptions } from "./prompt-for-options";

import { scaffoldTemplate } from "./scaffold-template";

export async function createProject(

  projectDirectory: string,

  options: ProjectOptions,

): Promise<ProjectResult | null> {

  const projectOptions = await promptForOptions({

    ...options,

    projectName: projectDirectory,

  });

  if (!projectOptions) {

    return null;

  }

  const scaffolded = await scaffoldTemplate(projectOptions);

  if (!scaffolded) {

    return null;

  }

  const gitInitialized = await initializeGit(

    projectOptions.projectName ?? projectDirectory,

    projectOptions.yes,

  );

  const dependenciesInstalled = await installDependencies(

    projectOptions.projectName ?? projectDirectory,

    projectOptions.yes,

  );

  return {

    projectName: projectOptions.projectName ?? projectDirectory,

    gitInitialized,

    dependenciesInstalled,

    template: projectOptions.template ?? "default",

  };

}

import { consola } from "consola";

import figlet from "figlet";

import pc from "picocolors";

export function displayBanner() {

  const text = figlet.textSync("bhvr", {

    font: "Big",

    horizontalLayout: "default",

    verticalLayout: "default",

    width: 80,

    whitespaceBreak: true,

  });

  console.log("\n");

  console.log(pc.yellowBright(text));

  consola.info(`${pc.cyan("🦫 Lets build 🦫")}`);

  consola.info(`${pc.blue("https://github.com/stevedylandev/bhvr")}\n`);

}

export * from "./create-project";

export * from "./display-banner";

export * from "./initialize-git";

export * from "./install-dependencies";

export * from "./patch-files-rpc";

export * from "./prompt-for-options";

export * from "./scaffold-template";

export * from "./setup-biome";

import { consola } from "consola";

import { execa } from "execa";

import pc from "picocolors";

import yoctoSpinner from "yocto-spinner";

import { tryCatch } from "@/utils/try-catch";

export async function initializeGit(

  projectPath: string,

  skipConfirmation?: boolean,

): Promise<boolean> {

  if (!skipConfirmation) {

    const { data: gitResponse, error } = await tryCatch(

      consola.prompt("Initialize a git repository?", {

        type: "confirm",

        initial: true,

        cancel: "reject",

      }),

    );

    if (error) {

      console.log(pc.yellow("Project creation cancelled."));

      return false;

    }

    if (!gitResponse) {

      return false;

    }

  }

  const spinner = yoctoSpinner({

    text: "Initializing git repository...",

  }).start();

  try {

    await execa("git", ["init"], { cwd: projectPath });

    spinner.success("Git repository initialized");

    return true;

  } catch (err: unknown) {

    spinner.error("Failed to initialize git repository. Is git installed?");

    if (err instanceof Error) {

      consola.error(pc.red("Git error:"), err.message);

    } else {

      consola.error(pc.red("Git error: Unknown error"));

    }

    return false;

  }

}

import { consola } from "consola";

import { execa } from "execa";

import pc from "picocolors";

import yoctoSpinner from "yocto-spinner";

import { tryCatch } from "@/utils/try-catch";

async function getPackageManager(): Promise<"bun"> {

  const { error } = await tryCatch(execa("bun", ["--version"]));

  if (error) {

    consola.error(new Error("Bun is not installed."));

    consola.warn("Please install bun from https://bun.sh/");

    process.exit(1);

  }

  return "bun";

}

export async function installDependencies(

  projectPath: string,

  skipConfirmation?: boolean,

): Promise<boolean> {

  if (!skipConfirmation) {

    const { data: depsResponse, error } = await tryCatch(

      consola.prompt("Install dependencies?", {

        type: "confirm",

        initial: true,

        cancel: "reject",

      }),

    );

    if (error) {

      console.log(pc.yellow("Project creation cancelled."));

      return false;

    }

    if (!depsResponse) {

      return false;

    }

  }

  const packageManager = await getPackageManager();

  const spinner = yoctoSpinner({

    text: `Installing dependencies with ${packageManager}...`,

  }).start();

  try {

    await execa(packageManager, ["install"], { cwd: projectPath });

    spinner.success(`Dependencies installed with ${packageManager}`);

    return true;

  } catch (_err) {

    spinner.error("Failed to install dependencies.");

    console.log(

      pc.yellow(

        "You can install them manually after navigating to the project directory.",

      ),

    );

    return false;

  }

}

import path from "node:path";

import { consola } from "consola";

import { execa } from "execa";

import fs from "fs-extra";

import pc from "picocolors";

import yoctoSpinner from "yocto-spinner";

import {

  defaultTemplate,

  honoClientTemplate,

  honoRpcTemplate,

  shadcnTemplate,

  tailwindTemplate,

} from "@/utils/templates";

export async function patchFilesForRPC(

  projectPath: string,

  templateChoice: string,

): Promise<boolean> {

  const spinner = yoctoSpinner({ text: "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);

    if (!clientPkg.dependencies.hono) {

      await execa("bun", ["install", "hono"], { cwd: projectPath });

    }

    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);

    // 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 });

    // 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");

    // 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;

    // 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.success("RPC client setup completed");

    return true;

  } catch (err: unknown) {

    spinner.error("Failed to set up RPC client");

    if (err instanceof Error) {

      consola.error(pc.red("Error:"), err.message);

    } else {

      consola.error(pc.red("Error: Unknown error"));

    }

    return false;

  }

}

import { consola } from "consola";

import pc from "picocolors";

import type { ProjectOptions } from "@/types";

import { TEMPLATES } from "@/utils/templates";

import { tryCatch } from "@/utils/try-catch";

export async function promptForOptions(

  options: ProjectOptions,

): Promise<ProjectOptions> {

  let projectName = options.projectName;

  if (!projectName && !options.yes) {

    const { data, error } = await tryCatch(

      consola.prompt(pc.yellow("What is the name of your project?"), {

        type: "text",

        default: "my-bhvr-app",

        placeholder: "my-bhvr-app",

        cancel: "reject",

      }),

    );

    if (!data || error) {

      consola.error(pc.red("Project creation cancelled."));

      process.exit(1);

    }

    projectName = data;

  }

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

  if (!options.yes && !options.branch) {

    const templateChoices = Object.keys(TEMPLATES).map((key) => ({

      label: `${key} (${TEMPLATES[key]?.description})`,

      value: key,

    }));

    const { data, error } = await tryCatch(

      consola.prompt(pc.yellow("Select a template:"), {

        type: "select",

        options: templateChoices,

        initial: "default",

        cancel: "reject",

      }),

    );

    if (!data || error) {

      consola.error("Project creation cancelled.");

      process.exit(1);

    }

    templateChoice = data;

  }

  let useRpc = options.rpc;

  if (!options.yes && !options.rpc) {

    const { data: rpcResponse, error } = await tryCatch(

      consola.prompt("Use Hono RPC client for type-safe API communication?", {

        type: "confirm",

        initial: false,

      }),

    );

    if (error) {

      consola.error("Project creation cancelled.");

      process.exit(1);

    }

    useRpc = rpcResponse;

  }

  let linter = options.linter;

  if (!options.yes && !options.linter) {

    const { data: linterResponse, error } = await tryCatch(

      consola.prompt("Select a linter:", {

        type: "select",

        options: [

          { label: "ESLint (default)", value: "eslint" },

          { label: "Biome", value: "biome" },

        ],

        initial: "eslint",

        cancel: "reject",

      }),

    );

    if (error) {

      console.log(pc.yellow("Project creation cancelled."));

      process.exit(1);

    }

    linter = linterResponse as "eslint" | "biome";

  }

  return {

    ...options,

    projectName,

    template: templateChoice,

    rpc: useRpc,

    linter,

  };

}

import path from "node:path";

import degit from "degit";

import fs from "fs-extra";

import pc from "picocolors";

import yoctoSpinner from "yocto-spinner";

import type { ProjectOptions } from "@/types";

import { DEFAULT_REPO } from "@/utils/constants";

import { TEMPLATES } from "@/utils/templates";

import { patchFilesForRPC } from "./patch-files-rpc";

import { setupBiome } from "./setup-biome";

export async function scaffoldTemplate(

  options: Required<ProjectOptions>,

): Promise<boolean> {

  const { projectName, template, repo, branch, rpc, linter } = options;

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

  if (fs.existsSync(projectPath)) {

    const files = fs.readdirSync(projectPath);

    if (files.length > 0) {

      await fs.emptyDir(projectPath);

    }

  }

  fs.ensureDirSync(projectPath);

  const repoPath = repo || DEFAULT_REPO;

  const templateConfig =

    TEMPLATES[template as keyof typeof TEMPLATES] || TEMPLATES.default;

  const repoBranch = branch || (templateConfig?.branch ?? "main");

  const repoUrl = `${repoPath}#${repoBranch}`;

  const spinner = yoctoSpinner({ text: "Downloading template..." }).start();

  try {

    const emitter = degit(repoUrl, {

      cache: false,

      force: true,

      verbose: false,

    });

    await emitter.clone(projectPath);

    spinner.success(`Template downloaded successfully (${template} 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 gitDir = path.join(projectPath, ".git");

    if (fs.existsSync(gitDir)) {

      await fs.remove(gitDir);

      console.log(pc.blue("Removed .git directory"));

    }

    if (rpc) {

      await patchFilesForRPC(projectPath, template);

    }

    if (linter === "biome") {

      await setupBiome(projectPath);

    }

    return true;

  } catch (err) {

    spinner.error("Failed to download template");

    throw err;

  }

}

import path from "node:path";

import { execa } from "execa";

import fs from "fs-extra";

import pc from "picocolors";

import yoctoSpinner from "yocto-spinner";

export async function setupBiome(projectPath: string): Promise<void> {

  const spinner = yoctoSpinner({ text: "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");

    // Remove ESLint config file

    if (fs.existsSync(eslintConfigPath)) {

      await fs.remove(eslintConfigPath);

    }

    // 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 (eslintDeps.length > 0) {

      spinner.text = "Replacing ESLint dependencies...";

      await execa("bun", ["remove", ...eslintDeps], { cwd: clientPath });

    }

    // Install Biome in the root of the project

    spinner.text = "Installing Biome...";

    await execa("bun", ["add", "-D", "@biomejs/biome"], { cwd: projectPath });

    // 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 });

    // 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 });

    // 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 });

    }

    spinner.success("Biome setup complete.");

  } catch (error) {

    spinner.error("Biome setup failed.");

    if (error instanceof Error) {

      console.error(pc.red("\nError:"), error.message);

    } else {

      console.error(pc.red("\nError: Unknown error during Biome setup."));

    }

  }

}

import { Command } from "commander";

export const program = new Command();

  branch: string;

  description: string;

  projectName?: string;

  yes?: boolean;

  typescript?: boolean;

  repo?: string;

  template?: string;

  branch?: string;

  rpc?: boolean;

  linter?: "eslint" | "biome";

  projectName: string;

  gitInitialized: boolean;

  dependenciesInstalled: boolean;

  template: string;

export const DEFAULT_REPO = "stevedylandev/bhvr";