# Contributing to create-bhvr

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

## Code of Conduct

This project and everyone participating in it is governed by the [Code of Conduct](CODE_OF_CONDUCT.md). By participating, you are expected to uphold this code.

## 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.

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

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

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

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

  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,

    projectOptions.yes,

  );

  const dependenciesInstalled = await installDependencies(

    projectOptions.projectName,

    projectOptions.yes,

  );

  return {

    projectName: projectOptions.projectName,

    gitInitialized,

    dependenciesInstalled,

    template: projectOptions.template,

  };

export * from "./initialize-git";

export * from "./install-dependencies";

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

export * from "./scaffold-template";

import { consola } from "consola";

import { execa } from "execa";

import ora from "ora";

import pc from "picocolors";

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 = ora("Initializing git repository...").start();

  try {

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

    spinner.succeed("Git repository initialized");

    return true;

  } catch (err: unknown) {

    spinner.fail("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 ora from "ora";

import pc from "picocolors";

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

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

  try {

    await execa("bun", ["--version"]);

    return "bun";

  } catch (e) {

    // bun is not installed

  }

  try {

    await execa("pnpm", ["--version"]);

    return "pnpm";

  } catch (e) {

    // pnpm is not installed

  }

  return "npm";

}

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 = ora(

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

  ).start();

  try {

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

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

    return true;

  } catch (err) {

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

    console.log(

      pc.yellow(

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

      ),

    );

    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 | null> {

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

      return null;

    }

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

      return null;

    }

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

      return null;

    }

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

      return null;

    }

    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 ora from "ora";

import pc from "picocolors";

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: 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 = ora("Downloading template...").start();

  try {

    const emitter = degit(repoUrl, {

      cache: false,

      force: true,

      verbose: false,

    });

    await emitter.clone(projectPath);

    spinner.succeed(`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.fail("Failed to download template");

    throw err;

  }

}

  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;