"consola": "^3.4.2",

        "picocolors": "^1.1.1",

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

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

  "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",

    "ora": "^6.3.1",

    "picocolors": "^1.1.1"

  },

  "engines": {

    "node": ">=18"

  }

import { displayBanner } from "@/lib/display-banner";import { createProject } from "../lib/create-project";import pc from "picocolors";export const create = async (projectDirectory: string, options: any) => {  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 path from "node:path";

import { consola } from "consola";

import degit from "degit";

import { execa } from "execa";

import fs from "fs-extra";

import ora from "ora";

import pc from "picocolors";

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

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

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

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

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

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

export async function createProject(

  projectDirectory: string,

  options: ProjectOptions,

): Promise<ProjectResult | null> {

  let projectName = projectDirectory;

  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;

  }

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

  if (fs.existsSync(projectPath)) {

    const files = fs.readdirSync(projectPath);

    if (files.length > 0 && !options.yes) {

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

        consola.prompt(

          `The directory ${projectName} already exists and is not empty. Do you want to overwrite it?`,

          {

            type: "confirm",

            initial: false,

          },

        ),

      );

      if (!overwrite || error) {

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

        return null;

      }

      await fs.emptyDir(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();

  try {

    const emitter = degit(repoUrl, {

      cache: false,

      force: true,

      verbose: false,

    });

    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 gitDir = path.join(projectPath, ".git");

    if (fs.existsSync(gitDir)) {

      await fs.remove(gitDir);

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

    }

    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 (!rpcResponse || error) {

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

        return null;

      }

      useRpc = rpcResponse;

    }

    if (useRpc) {

      await patchFilesForRPC(projectPath, templateChoice);

    }

    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 (!linterResponse || error) {

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

        return null;

      }

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

    }

    if (linter === "biome") {

      await setupBiome(projectPath);

    }

    let gitInitialized = false;

    if (!options.yes) {

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

      }

      if (gitResponse) {

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

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

          } else {

            consola.error(pc.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 { 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 null;

      }

      if (depsResponse) {

        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(

              pc.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.",

          );

        }

      }

    }

    return {

      projectName,

      gitInitialized,

      dependenciesInstalled,

      template: templateChoice,

    };

  } catch (err) {

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

    throw err;

  }

}

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 "./patch-files-rpc";

export * from "./setup-biome";

import path from "node:path";

import { consola } from "consola";

import { execa } from "execa";

import fs from "fs-extra";

import ora from "ora";

import pc from "picocolors";

import {

  defaultTemplate,

  honoClientTemplate,

  honoRpcTemplate,

  shadcnTemplate,

  tailwindTemplate,

} from "@/utils/templates";

export async function patchFilesForRPC(

  projectPath: string,

  templateChoice: string,

): Promise<boolean> {

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

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

    return true;

  } catch (err: unknown) {

    spinner.fail("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 path from "node:path";

import { execa } from "execa";

import fs from "fs-extra";

import ora from "ora";

import pc from "picocolors";

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

    // 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.succeed("Biome setup complete.");

  } catch (error) {

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

export const DEFAULT_REPO = "stevedylandev/bhvr";

export * from "./constants";

export * from "./try-catch";

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

type Success<T> = {

  data: T;

  error: null;

};

type Failure<E> = {

  data: null;

  error: E;

};

type Result<T, E = Error> = Success<T> | Failure<E>;

// Main wrapper function

export async function tryCatch<T, E = Error>(

  promise: Promise<T>,

): Promise<Result<T, E>> {

  try {

    const data = await promise;

    return { data, error: null };

  } catch (error) {

    return { data: null, error: error as E };

  }

}

		"noPropertyAccessFromIndexSignature": false,

    "baseUrl": ".",

    "paths": {

      "@/*": ["src/*"]

    }