bank20baht-cli 0.0.1

package/dist/application/create.d.ts

@@ -0,0 +1,16 @@
+import { type CreateOptions } from '../domain/create-plan.js';
+import type { CommandRunner, FileWriter, Logger, Renderer, TemplateSource } from './ports.js';
+export interface CreateDeps {
+    templates: TemplateSource;
+    renderer: Renderer;
+    writer: FileWriter;
+    runner: CommandRunner;
+    log: Logger;
+}
+export interface CreateInput extends CreateOptions {
+    dryRun: boolean;
+    force: boolean;
+}
+export declare function runCreate(input: CreateInput, deps: CreateDeps): void;
+export declare class CreateError extends Error {
+}

package/dist/application/create.js

@@ -0,0 +1,35 @@
+import { planCreate } from '../domain/create-plan.js';
+import { validateProjectName } from '../domain/naming.js';
+export function runCreate(input, deps) {
+    const errors = validateProjectName(input.name);
+    if (errors.length > 0) {
+        for (const e of errors)
+            deps.log.error(e);
+        throw new CreateError('Invalid project name.');
+    }
+    const blueprint = planCreate(input, deps.templates.load('create'), (raw, data) => deps.renderer.render(raw, data));
+    if (input.dryRun) {
+        deps.log.info(`dry-run — would create in ${blueprint.root}:`);
+        for (const f of blueprint.files)
+            deps.log.info(`  ${f.path}`);
+        for (const c of blueprint.postCommands)
+            deps.log.info(`  $ ${c.cmd} ${c.args.join(' ')}`);
+        return;
+    }
+    deps.writer.ensureUsableDir(blueprint.root, input.force);
+    deps.writer.writeFiles(blueprint);
+    deps.log.step(`${blueprint.files.length} files written to ${blueprint.root}`);
+    for (const c of blueprint.postCommands) {
+        deps.log.step(c.label);
+        deps.runner.run(c.cmd, c.args, blueprint.root);
+    }
+    deps.log.info('');
+    deps.log.info(`Done. Next:`);
+    deps.log.info(`  cd ${input.name}`);
+    if (!input.install)
+        deps.log.info('  bun install');
+    deps.log.info('  bun run dev        # web :5173 + api :3001');
+    deps.log.info('  bun run lint && bun run test && bun run build');
+}
+export class CreateError extends Error {
+}

package/dist/application/ports.d.ts

@@ -0,0 +1,23 @@
+import type { Blueprint } from '../domain/blueprint.js';
+import type { TemplateFile } from '../domain/create-plan.js';
+/** Loads a template set (e.g. "create") shipped inside the CLI package. */
+export interface TemplateSource {
+    load(set: string): TemplateFile[];
+}
+export interface Renderer {
+    render(raw: string, data: Record<string, unknown>): string;
+}
+export interface FileWriter {
+    /** Throws unless `dir` is missing/empty (or `force` is set). */
+    ensureUsableDir(dir: string, force: boolean): void;
+    writeFiles(blueprint: Blueprint): void;
+}
+export interface CommandRunner {
+    /** Runs to completion with inherited stdio; throws on non-zero exit. */
+    run(cmd: string, args: string[], cwd: string): void;
+}
+export interface Logger {
+    info(message: string): void;
+    step(message: string): void;
+    error(message: string): void;
+}

package/dist/application/ports.js

@@ -0,0 +1 @@
+export {};

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+import { resolve } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { runCreate, CreateError } from './application/create.js';
+import { DiskTemplateSource } from './infrastructure/template-source.js';
+import { HbsRenderer } from './infrastructure/hbs-renderer.js';
+import { DiskFileWriter } from './infrastructure/fs-writer.js';
+import { ShellRunner } from './infrastructure/shell-runner.js';
+const HELP = `bahtui — bun-workspace DDD scaffolding (React + Elysia + Eden)
+
+Usage:
+  bahtui create <name> [options]   scaffold a new monorepo in ./<name>
+
+Options:
+  --dry-run      print what would be generated, write nothing
+  --no-install   skip "bun install" (also skips the initial commit)
+  --no-git       skip git init + initial commit
+  --force        write into an existing non-empty directory
+  -h, --help     this help
+  -v, --version  print version
+`;
+function version() {
+    const pkg = fileURLToPath(new URL('../package.json', import.meta.url));
+    return JSON.parse(readFileSync(pkg, 'utf8')).version;
+}
+const log = {
+    info: (m) => console.log(m),
+    step: (m) => console.log(`• ${m}`),
+    error: (m) => console.error(`✖ ${m}`),
+};
+function main(argv) {
+    const args = argv.filter((a) => !a.startsWith('-'));
+    const flags = new Set(argv.filter((a) => a.startsWith('-')));
+    const [command, name] = args;
+    if (flags.has('-v') || flags.has('--version')) {
+        log.info(version());
+        return 0;
+    }
+    if (command === undefined || flags.has('-h') || flags.has('--help')) {
+        log.info(HELP);
+        return command === undefined && !flags.has('-h') && !flags.has('--help') ? 1 : 0;
+    }
+    if (command !== 'create') {
+        log.error(`Unknown command "${command}".`);
+        log.info(HELP);
+        return 1;
+    }
+    if (!name) {
+        log.error('create needs a project name: bahtui create <name>');
+        return 1;
+    }
+    try {
+        runCreate({
+            name,
+            targetDir: resolve(process.cwd(), name),
+            install: !flags.has('--no-install'),
+            git: !flags.has('--no-git'),
+            dryRun: flags.has('--dry-run'),
+            force: flags.has('--force'),
+        }, {
+            templates: new DiskTemplateSource(),
+            renderer: new HbsRenderer(),
+            writer: new DiskFileWriter(),
+            runner: new ShellRunner(),
+            log,
+        });
+        return 0;
+    }
+    catch (err) {
+        log.error(err instanceof CreateError ? err.message : String(err));
+        return 1;
+    }
+}
+process.exit(main(process.argv.slice(2)));

package/dist/domain/blueprint.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A Blueprint is WHAT will be generated, as plain data — no fs, no side
+ * effects. Adapters (fs-writer, shell-runner) make it real; --dry-run just
+ * prints it. This split is the testing seam for every generator.
+ */
+export interface FileSpec {
+    /** Path relative to the blueprint root. */
+    path: string;
+    contents: string;
+}
+export interface PostCommand {
+    cmd: string;
+    args: string[];
+    /** Human-readable step label for progress output. */
+    label: string;
+}
+export interface Blueprint {
+    /** Absolute directory every FileSpec.path is relative to. */
+    root: string;
+    files: FileSpec[];
+    /** Commands to run inside `root`, in order, after files are written. */
+    postCommands: PostCommand[];
+}

package/dist/domain/blueprint.js

@@ -0,0 +1,6 @@
+/**
+ * A Blueprint is WHAT will be generated, as plain data — no fs, no side
+ * effects. Adapters (fs-writer, shell-runner) make it real; --dry-run just
+ * prints it. This split is the testing seam for every generator.
+ */
+export {};

package/dist/domain/create-plan.d.ts

@@ -0,0 +1,24 @@
+import type { Blueprint } from './blueprint.js';
+export interface CreateOptions {
+    name: string;
+    /** Absolute path of the directory to create the project in. */
+    targetDir: string;
+    install: boolean;
+    git: boolean;
+}
+/** A template file as loaded from disk by the infrastructure layer. */
+export interface TemplateFile {
+    /** Path relative to the template set root, e.g. "apps/api/src/index.ts.hbs". */
+    relPath: string;
+    raw: string;
+}
+export type RenderFn = (raw: string, data: Record<string, unknown>) => string;
+/**
+ * Template naming conventions (the whole contract between templates/ and here):
+ * - `*.hbs`            → rendered with the data below, suffix stripped.
+ *   anything else      → copied verbatim (so files with `${{ }}` like ci.yml
+ *   never meet handlebars).
+ * - leading `_` on a basename → `.` (npm pack silently drops/renames real
+ *   .gitignore files inside packages, so templates ship `_gitignore`).
+ */
+export declare function planCreate(options: CreateOptions, templates: TemplateFile[], render: RenderFn): Blueprint;

package/dist/domain/create-plan.js

@@ -0,0 +1,44 @@
+/**
+ * Template naming conventions (the whole contract between templates/ and here):
+ * - `*.hbs`            → rendered with the data below, suffix stripped.
+ *   anything else      → copied verbatim (so files with `${{ }}` like ci.yml
+ *   never meet handlebars).
+ * - leading `_` on a basename → `.` (npm pack silently drops/renames real
+ *   .gitignore files inside packages, so templates ship `_gitignore`).
+ */
+export function planCreate(options, templates, render) {
+    const data = { name: options.name };
+    const files = templates
+        .map((t) => {
+        const isTemplate = t.relPath.endsWith('.hbs');
+        const path = undot(isTemplate ? t.relPath.slice(0, -'.hbs'.length) : t.relPath);
+        const contents = isTemplate ? render(t.raw, data) : t.raw;
+        return { path, contents };
+    })
+        .sort((a, b) => (a.path < b.path ? -1 : 1)); // codepoint order — stable across locales
+    const postCommands = [];
+    if (options.git) {
+        postCommands.push({ cmd: 'git', args: ['init', '-b', 'main'], label: 'git init' });
+    }
+    if (options.install) {
+        // after git init so husky's prepare hook finds .git
+        postCommands.push({ cmd: 'bun', args: ['install'], label: 'bun install' });
+    }
+    if (options.git && options.install) {
+        // the first commit runs the freshly installed pre-commit hook — the
+        // generated repo proves its own toolchain before the user touches it
+        postCommands.push({ cmd: 'git', args: ['add', '-A'], label: 'git add' });
+        postCommands.push({
+            cmd: 'git',
+            args: ['commit', '-m', 'chore: scaffold with bank20baht-cli'],
+            label: 'git commit (pre-commit hook runs here)',
+        });
+    }
+    return { root: options.targetDir, files, postCommands };
+}
+function undot(relPath) {
+    return relPath
+        .split('/')
+        .map((part) => (part.startsWith('_') ? `.${part.slice(1)}` : part))
+        .join('/');
+}

package/dist/domain/naming.d.ts

@@ -0,0 +1,2 @@
+/** Project-name rules: must be usable as npm scope, directory, and package name. */
+export declare function validateProjectName(name: string): string[];

package/dist/domain/naming.js

@@ -0,0 +1,18 @@
+/** Project-name rules: must be usable as npm scope, directory, and package name. */
+const NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
+const RESERVED = new Set(['node_modules', 'apps', 'libs', 'src', 'dist', 'test', 'bun']);
+export function validateProjectName(name) {
+    const errors = [];
+    if (name.length === 0)
+        errors.push('Project name is required.');
+    else if (name.length > 64)
+        errors.push('Project name must be 64 characters or fewer.');
+    if (name.length > 0 && !NAME_PATTERN.test(name)) {
+        errors.push(`"${name}" is not a valid project name — use lowercase letters, digits and dashes, starting with a letter (it becomes the @${name}/* package scope).`);
+    }
+    if (RESERVED.has(name))
+        errors.push(`"${name}" is a reserved name.`);
+    if (name.endsWith('-'))
+        errors.push('Project name must not end with a dash.');
+    return errors;
+}

package/dist/infrastructure/fs-writer.d.ts

@@ -0,0 +1,6 @@
+import type { Blueprint } from '../domain/blueprint.js';
+import type { FileWriter } from '../application/ports.js';
+export declare class DiskFileWriter implements FileWriter {
+    ensureUsableDir(dir: string, force: boolean): void;
+    writeFiles(blueprint: Blueprint): void;
+}

package/dist/infrastructure/fs-writer.js

@@ -0,0 +1,20 @@
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+export class DiskFileWriter {
+    ensureUsableDir(dir, force) {
+        if (!existsSync(dir))
+            return;
+        if (readdirSync(dir).length === 0)
+            return;
+        if (force)
+            return;
+        throw new Error(`${dir} already exists and is not empty (use --force to write anyway).`);
+    }
+    writeFiles(blueprint) {
+        for (const file of blueprint.files) {
+            const abs = join(blueprint.root, file.path);
+            mkdirSync(dirname(abs), { recursive: true });
+            writeFileSync(abs, file.contents);
+        }
+    }
+}

package/dist/infrastructure/hbs-renderer.d.ts

@@ -0,0 +1,4 @@
+import type { Renderer } from '../application/ports.js';
+export declare class HbsRenderer implements Renderer {
+    render(raw: string, data: Record<string, unknown>): string;
+}

package/dist/infrastructure/hbs-renderer.js

@@ -0,0 +1,7 @@
+import Handlebars from 'handlebars';
+export class HbsRenderer {
+    render(raw, data) {
+        // noEscape: these are code/config files, not HTML — quotes must survive.
+        return Handlebars.compile(raw, { noEscape: true, strict: true })(data);
+    }
+}

package/dist/infrastructure/shell-runner.d.ts

@@ -0,0 +1,4 @@
+import type { CommandRunner } from '../application/ports.js';
+export declare class ShellRunner implements CommandRunner {
+    run(cmd: string, args: string[], cwd: string): void;
+}

package/dist/infrastructure/shell-runner.js

@@ -0,0 +1,11 @@
+import { spawnSync } from 'node:child_process';
+export class ShellRunner {
+    run(cmd, args, cwd) {
+        const result = spawnSync(cmd, args, { cwd, stdio: 'inherit' });
+        if (result.error)
+            throw result.error;
+        if (result.status !== 0) {
+            throw new Error(`${cmd} ${args.join(' ')} exited with code ${result.status}`);
+        }
+    }
+}

package/dist/infrastructure/template-source.d.ts

@@ -0,0 +1,7 @@
+import type { TemplateFile } from '../domain/create-plan.js';
+import type { TemplateSource } from '../application/ports.js';
+export declare class DiskTemplateSource implements TemplateSource {
+    private readonly root;
+    constructor(root?: string);
+    load(set: string): TemplateFile[];
+}

package/dist/infrastructure/template-source.js

@@ -0,0 +1,25 @@
+import { readdirSync, readFileSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** templates/ sits at the package root, next to dist/ — hence ../../ from here. */
+const TEMPLATES_ROOT = fileURLToPath(new URL('../../templates', import.meta.url));
+export class DiskTemplateSource {
+    constructor(root = TEMPLATES_ROOT) {
+        this.root = root;
+    }
+    load(set) {
+        const setRoot = join(this.root, set);
+        const entries = readdirSync(setRoot, { recursive: true, withFileTypes: true });
+        const files = [];
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            const abs = join(entry.parentPath, entry.name);
+            files.push({
+                relPath: relative(setRoot, abs).split(sep).join('/'),
+                raw: readFileSync(abs, 'utf8'),
+            });
+        }
+        return files;
+    }
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "bank20baht-cli",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "Scaffold bun-workspace DDD monorepos (React + Elysia + Eden) and bahtui generators.",
+  "license": "MIT",
+  "author": "Nattapong Promthong",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bank20baht/bahtui.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/bank20baht/bahtui#readme",
+  "bugs": {
+    "url": "https://github.com/bank20baht/bahtui/issues"
+  },
+  "keywords": [
+    "cli",
+    "scaffold",
+    "generator",
+    "ddd",
+    "bun",
+    "elysia",
+    "eden",
+    "react"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "bahtui": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "handlebars": "^4.7.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4"
+  }
+}

package/templates/create/README.md.hbs

@@ -0,0 +1,32 @@
+# {{name}}
+
+Bun-workspace monorepo scaffolded by [`bank20baht-cli`](https://github.com/bank20baht/bahtui) —
+React + Elysia wired end-to-end with Eden (type-safe client, zero codegen).
+
+## Quickstart
+
+```sh
+bun install
+bun run dev        # web on :5173, api on :3001
+```
+
+## Layout (DDD taxonomy)
+
+```
+apps/web                 React 19 + Vite
+apps/api                 Elysia — exports `type App`, the Eden type anchor
+libs/shared/eden         treaty<App> — the ONE typed http client
+libs/domain/<d>/model    (later) entities + form JSON, framework-free
+libs/domain/<d>/api      (later) Elysia plugin for the domain
+libs/domain/<d>/feature-*(later) React feature slices
+```
+
+Dependency direction: features and api libs depend on `model`; `model` depends
+on nothing; the frontend never imports server code — types travel through Eden.
+
+## Toolchain
+
+- `bun run lint` / `format:check` / `knip` / `deps:circular` — also run by CI
+  and by the pre-commit hook (lint-staged → knip → madge).
+- `bun run test` — bun test in every app.
+- `bun run build` — typecheck + vite build.

package/templates/create/_github/workflows/ci.yml

@@ -0,0 +1,56 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+      - name: Install deps
+        run: bun install --frozen-lockfile
+      - name: ESLint
+        run: bun run lint
+      - name: Prettier
+        run: bun run format:check
+      - name: Knip (dead code)
+        run: bun run knip
+      - name: Circular dependencies (madge)
+        run: bun run deps:circular
+
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+      - name: Install deps
+        run: bun install --frozen-lockfile
+      - name: Test
+        run: bun run test
+
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+      - name: Install deps
+        run: bun install --frozen-lockfile
+      - name: Build
+        run: bun run build

package/templates/create/_gitignore

@@ -0,0 +1,5 @@
+node_modules/
+dist/
+*.local
+*.tsbuildinfo
+.DS_Store

package/templates/create/_husky/pre-commit

@@ -0,0 +1,3 @@
+bunx lint-staged
+bun run knip
+bun run deps:circular

package/templates/create/_prettierignore

@@ -0,0 +1,3 @@
+dist/
+*.tsbuildinfo
+bun.lock

package/templates/create/_prettierrc.json

@@ -0,0 +1,4 @@
+{
+  "singleQuote": true,
+  "printWidth": 100
+}

package/templates/create/apps/api/package.json.hbs

@@ -0,0 +1,21 @@
+{
+  "name": "@{{name}}/api",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "dev": "bun run --watch src/index.ts",
+    "test": "bun test",
+    "build": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@elysiajs/cors": "^1.3.0",
+    "elysia": "^1.3.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.2.0",
+    "typescript": "^5.8.3"
+  }
+}

package/templates/create/apps/api/src/index.test.ts.hbs

@@ -0,0 +1,10 @@
+import { describe, expect, it } from 'bun:test';
+import { app } from './index';
+
+describe('GET /health', () => {
+  it('reports the service as ok', async () => {
+    const res = await app.handle(new Request('http://localhost/health'));
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ status: 'ok', service: '{{name}}-api' });
+  });
+});

package/templates/create/apps/api/src/index.ts.hbs

@@ -0,0 +1,14 @@
+import { Elysia } from 'elysia';
+import { cors } from '@elysiajs/cors';
+
+export const app = new Elysia()
+  .use(cors())
+  .get('/health', () => ({ status: 'ok', service: '{{name}}-api' }));
+
+/** Eden anchor — the whole API's type surface, consumed by libs/shared/eden. */
+export type App = typeof app;
+
+if (import.meta.main) {
+  app.listen(3001);
+  console.log(`{{name}}-api listening on http://localhost:${app.server?.port}`);
+}

package/templates/create/apps/api/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "types": ["bun"]
+  },
+  "include": ["src"]
+}

package/templates/create/apps/web/index.html.hbs

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>{{name}}</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/templates/create/apps/web/package.json.hbs

@@ -0,0 +1,23 @@
+{
+  "name": "@{{name}}/web",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "test": "bun test",
+    "build": "tsc --noEmit && vite build"
+  },
+  "dependencies": {
+    "@{{name}}/eden": "workspace:*",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.2.0",
+    "@types/react": "^19.1.0",
+    "@types/react-dom": "^19.1.0",
+    "@vitejs/plugin-react": "^5.0.0",
+    "typescript": "^5.8.3",
+    "vite": "^7.0.0"
+  }
+}

package/templates/create/apps/web/src/App.tsx.hbs

@@ -0,0 +1,20 @@
+import { useEffect, useState } from 'react';
+import { api } from '@{{name}}/eden';
+import { describeHealth } from './health';
+
+export default function App() {
+  const [status, setStatus] = useState('checking api…');
+
+  useEffect(() => {
+    api.health.get().then(({ data, error }) => {
+      setStatus(error ? `api unreachable (start it: bun run dev)` : describeHealth(data));
+    });
+  }, []);
+
+  return (
+    <main style={ { fontFamily: 'system-ui', padding: '2rem' } }>
+      <h1>{{name}}</h1>
+      <p>{status}</p>
+    </main>
+  );
+}

package/templates/create/apps/web/src/health.test.ts.hbs

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'bun:test';
+import { describeHealth } from './health';
+
+describe('describeHealth', () => {
+  it('formats a healthy response', () => {
+    expect(describeHealth({ status: 'ok', service: '{{name}}-api' })).toBe(
+      '{{name}}-api is ok',
+    );
+  });
+
+  it('handles a missing response', () => {
+    expect(describeHealth(null)).toBe('no response from api');
+  });
+});

package/templates/create/apps/web/src/health.ts.hbs

@@ -0,0 +1,6 @@
+export type Health = { status: string; service: string } | null;
+
+export function describeHealth(health: Health): string {
+  if (!health) return 'no response from api';
+  return `${health.service} is ${health.status}`;
+}

package/templates/create/apps/web/src/main.tsx.hbs

@@ -0,0 +1,9 @@
+import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import App from './App';
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+);

package/templates/create/apps/web/src/vite-env.d.ts.hbs

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/templates/create/apps/web/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "types": ["vite/client", "bun"]
+  },
+  "include": ["src", "vite.config.ts"]
+}

package/templates/create/apps/web/vite.config.ts.hbs

@@ -0,0 +1,6 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+});

package/templates/create/bahtui.json.hbs

@@ -0,0 +1,7 @@
+{
+  "apps": { "web": "apps/web", "api": "apps/api" },
+  "libsDir": "libs",
+  "frontend": "react",
+  "backend": "elysia",
+  "edenClient": "libs/shared/eden"
+}

package/templates/create/eslint.config.js

@@ -0,0 +1,30 @@
+import js from '@eslint/js';
+import tseslint from 'typescript-eslint';
+import reactHooks from 'eslint-plugin-react-hooks';
+import prettier from 'eslint-config-prettier';
+import globals from 'globals';
+
+export default tseslint.config(
+  { ignores: ['**/dist/**', '**/node_modules/**'] },
+  js.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    languageOptions: {
+      globals: { ...globals.browser, ...globals.node },
+    },
+    rules: {
+      '@typescript-eslint/no-unused-vars': [
+        'error',
+        { argsIgnorePattern: '^_', varsIgnorePattern: '^_' },
+      ],
+      '@typescript-eslint/consistent-type-imports': 'error',
+    },
+  },
+  {
+    files: ['apps/web/**/*.{ts,tsx}'],
+    plugins: { 'react-hooks': reactHooks },
+    rules: reactHooks.configs.recommended.rules,
+  },
+  // must come last — disables rules that fight Prettier
+  prettier,
+);

package/templates/create/knip.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://unpkg.com/knip@6/schema.json",
+  "workspaces": {
+    ".": {},
+    "apps/web": {},
+    "apps/api": {},
+    "libs/shared/eden": {}
+  }
+}

package/templates/create/libs/shared/eden/index.ts.hbs

@@ -0,0 +1,9 @@
+import { treaty } from '@elysiajs/eden';
+import type { App } from '@{{name}}/api';
+
+/**
+ * The ONE http client of the monorepo. Fully typed end-to-end: every route,
+ * body and response comes from apps/api's `App` type — no codegen, no drift.
+ * Point it elsewhere per environment by editing this single spot.
+ */
+export const api = treaty<App>('http://localhost:3001');

package/templates/create/libs/shared/eden/package.json.hbs

@@ -0,0 +1,15 @@
+{
+  "name": "@{{name}}/eden",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./index.ts"
+  },
+  "dependencies": {
+    "@elysiajs/eden": "^1.3.0"
+  },
+  "devDependencies": {
+    "@{{name}}/api": "workspace:*",
+    "typescript": "^5.8.3"
+  }
+}

package/templates/create/libs/shared/eden/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "include": ["index.ts"]
+}

package/templates/create/package.json.hbs

@@ -0,0 +1,37 @@
+{
+  "name": "{{name}}-monorepo",
+  "private": true,
+  "type": "module",
+  "workspaces": ["apps/*", "libs/**"],
+  "scripts": {
+    "dev": "bun run --filter './apps/*' dev",
+    "build": "bun run --filter './apps/*' build",
+    "test": "bun run --filter './apps/*' test",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "knip": "knip",
+    "deps:circular": "madge --circular --extensions ts,tsx apps libs",
+    "prepare": "husky"
+  },
+  "lint-staged": {
+    "*.{ts,tsx}": ["eslint --fix", "prettier --write"],
+    "*.{css,json,js,mjs}": ["prettier --write"]
+  },
+  "trustedDependencies": ["esbuild"],
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "eslint": "^10.6.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-react-hooks": "^7.1.1",
+    "globals": "^17.7.0",
+    "husky": "^9.1.7",
+    "knip": "^6.24.0",
+    "lint-staged": "^17.0.8",
+    "madge": "^8.0.0",
+    "prettier": "^3.9.4",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.62.1"
+  }
+}

package/templates/create/tsconfig.base.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "resolveJsonModule": true,
+    "noEmit": true
+  }
+}