bank20baht-cli 0.0.1 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nattapong Promthong
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/application/create.js

@@ -21,7 +21,13 @@ export function runCreate(input, deps) {
     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);
+        try {
+            deps.runner.run(c.cmd, c.args, blueprint.root);
+        }
+        catch (err) {
+            const retry = `${c.cmd} ${c.args.join(' ')}`;
+            throw new CreateError(`${err.message}\nproject files are written — cd ${input.name} and rerun: ${retry}`);
+        }
     }
     deps.log.info('');
     deps.log.info(`Done. Next:`);

package/dist/application/generate.js

@@ -0,0 +1,121 @@
+import { buildFormDefinition, FormDslError } from '../domain/form-dsl.js';
+import { DEFAULT_CONFIG, modelDir, planForm, planInit, planModel, validateDomainName, } from '../domain/generate-plan.js';
+export class GenerateError extends Error {
+}
+/**
+ * bahtui.json path-ish fields feed directly into fs paths (modelDir(), eden
+ * client wiring). A cloned repo's bahtui.json is untrusted input — reject
+ * anything that could escape the project root before it ever reaches a path
+ * join (defense in depth alongside DiskFileWriter's own root confinement).
+ */
+const SAFE_RELATIVE_PATH = /^[A-Za-z0-9._/-]+$/;
+function validateConfigPath(field, value) {
+    if (!SAFE_RELATIVE_PATH.test(value)) {
+        throw new GenerateError(`bahtui.json "${field}" contains invalid characters: ${JSON.stringify(value)}.`);
+    }
+    if (value.startsWith('/')) {
+        throw new GenerateError(`bahtui.json "${field}" must be a relative path: ${JSON.stringify(value)}.`);
+    }
+    if (value.split('/').includes('..')) {
+        throw new GenerateError(`bahtui.json "${field}" must not contain ".." segments: ${JSON.stringify(value)}.`);
+    }
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function loadConfig(root, reader) {
+    const raw = reader.read(`${root}/bahtui.json`);
+    if (raw === null) {
+        throw new GenerateError('No bahtui.json here — run "bahtui init" (or create) first.');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new GenerateError('bahtui.json is not valid JSON.');
+    }
+    if (!isPlainObject(parsed)) {
+        throw new GenerateError('bahtui.json must contain a JSON object.');
+    }
+    const config = { ...DEFAULT_CONFIG, ...parsed };
+    validateConfigPath('libsDir', config.libsDir);
+    if (config.edenClient !== undefined)
+        validateConfigPath('edenClient', config.edenClient);
+    return config;
+}
+function emit(blueprint, dryRun, deps) {
+    if (dryRun) {
+        deps.log.info(`dry-run — would write in ${blueprint.root}:`);
+        for (const f of blueprint.files)
+            deps.log.info(`  ${f.path}`);
+        return;
+    }
+    deps.writer.writeFiles(blueprint);
+    for (const f of blueprint.files)
+        deps.log.step(f.path);
+}
+/** `bahtui init` (PRD P2): bahtui.json for an existing repo, paths detected. */
+export function runInit(input, deps) {
+    if (deps.reader.exists(`${input.root}/bahtui.json`) && !input.force && !input.dryRun) {
+        throw new GenerateError('bahtui.json already exists — use --force to overwrite.');
+    }
+    const config = {
+        ...DEFAULT_CONFIG,
+        frontend: input.frontend,
+        backend: input.backend,
+        apps: {
+            ...(deps.reader.exists(`${input.root}/apps/web`) ? { web: 'apps/web' } : {}),
+            ...(deps.reader.exists(`${input.root}/apps/api`) ? { api: 'apps/api' } : {}),
+        },
+    };
+    if (input.backend === null)
+        delete config.edenClient;
+    emit(planInit(input.root, config), input.dryRun, deps);
+    if (!input.dryRun)
+        deps.log.info('bahtui.json written — `bahtui g model <domain>` is ready.');
+}
+/** `bahtui g model|form` (PRD P3). Engine-validates before any write. */
+export function runGenerate(input, deps) {
+    const config = loadConfig(input.root, deps.reader);
+    if (input.kind === 'model') {
+        const domain = input.target;
+        const errors = validateDomainName(domain);
+        if (errors.length > 0)
+            throw new GenerateError(errors.join(' '));
+        const dir = `${input.root}/${modelDir(config, domain)}`;
+        if (deps.reader.exists(dir) && !input.force) {
+            throw new GenerateError(`${modelDir(config, domain)} already exists — use --force.`);
+        }
+        emit(planModel(input.root, config, domain), input.dryRun, deps);
+        return;
+    }
+    // form: <domain>/<name>
+    const [domain, name, ...rest] = input.target.split('/');
+    if (!domain || !name || rest.length > 0) {
+        throw new GenerateError('g form needs <domain>/<name>, e.g. "ticket/create-ticket".');
+    }
+    const nameErrors = [...validateDomainName(domain), ...validateDomainName(name)];
+    if (nameErrors.length > 0)
+        throw new GenerateError(nameErrors.join(' '));
+    if (!input.fields) {
+        throw new GenerateError('g form needs --fields, e.g. --fields "title:text:required,qty:number:min=1".');
+    }
+    if (!deps.reader.exists(`${input.root}/${modelDir(config, domain)}`)) {
+        throw new GenerateError(`${modelDir(config, domain)} does not exist — run "bahtui g model ${domain}" first.`);
+    }
+    let form;
+    try {
+        form = buildFormDefinition(domain, name, input.fields); // invalid spec = zero files
+    }
+    catch (err) {
+        if (err instanceof FormDslError)
+            throw new GenerateError(err.message);
+        throw err;
+    }
+    const filePath = `${input.root}/${modelDir(config, domain)}/src/${name}.form.json`;
+    if (deps.reader.exists(filePath) && !input.force) {
+        throw new GenerateError(`${name}.form.json already exists — use --force.`);
+    }
+    emit(planForm(input.root, config, domain, name, form), input.dryRun, deps);
+}

package/dist/cli.js

@@ -3,20 +3,31 @@ import { resolve } from 'node:path';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { runCreate, CreateError } from './application/create.js';
+import { runGenerate, runInit, GenerateError } from './application/generate.js';
 import { DiskTemplateSource } from './infrastructure/template-source.js';
-import { HbsRenderer } from './infrastructure/hbs-renderer.js';
+import { TemplateRenderer } from './infrastructure/template-renderer.js';
 import { DiskFileWriter } from './infrastructure/fs-writer.js';
+import { DiskFileReader } from './infrastructure/fs-reader.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>
+  bahtui create <name> [options]        scaffold a new monorepo in ./<name>
+  bahtui init [options]                 write bahtui.json into an existing repo
+  bahtui g model <domain>               libs/domain/<d>/model package
+  bahtui g form <domain>/<name> --fields "key:type:mod,…"
+                                        engine-validated FormDefinition JSON
+Field DSL:
+  title:text:required,priority:dropdown:options=low|medium|high,qty:number:min=1
 
 Options:
+  --fields <dsl>       g form: the field list (required)
+  --frontend <react|none>  init: default react
+  --backend <elysia|none>  init: default elysia
   --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
+  --no-install   create: skip "bun install" (also skips the initial commit)
+  --no-git       create: skip git init + initial commit
+  --force        overwrite existing files/dirs
   -h, --help     this help
   -v, --version  print version
 `;
@@ -29,46 +40,125 @@ const log = {
     step: (m) => console.log(`• ${m}`),
     error: (m) => console.error(`✖ ${m}`),
 };
-function main(argv) {
+/** Boolean flags recognized anywhere on the command line (no value). */
+const KNOWN_FLAGS = new Set([
+    '-v',
+    '--version',
+    '-h',
+    '--help',
+    '--dry-run',
+    '--force',
+    '--no-install',
+    '--no-git',
+]);
+/**
+ * Value-carrying flags pulled out before positional parsing. Supports both
+ * `--flag value` and `--flag=value`. If the token after `--flag value` looks
+ * like another flag (starts with `-`), the option is treated as missing
+ * rather than swallowing that flag as the value.
+ */
+function takeOption(argv, flag) {
+    const eqPrefix = `${flag}=`;
+    const eqIndex = argv.findIndex((a) => a.startsWith(eqPrefix));
+    if (eqIndex !== -1) {
+        const value = argv[eqIndex].slice(eqPrefix.length);
+        argv.splice(eqIndex, 1);
+        return value;
+    }
+    const i = argv.indexOf(flag);
+    if (i === -1)
+        return undefined;
+    const value = argv[i + 1];
+    if (value === undefined || value.startsWith('-')) {
+        argv.splice(i, 1);
+        return undefined;
+    }
+    argv.splice(i, 2);
+    return value;
+}
+function main(rawArgv) {
+    const argv = [...rawArgv];
+    const fields = takeOption(argv, '--fields');
+    const frontend = takeOption(argv, '--frontend');
+    const backend = takeOption(argv, '--backend');
     const args = argv.filter((a) => !a.startsWith('-'));
     const flags = new Set(argv.filter((a) => a.startsWith('-')));
-    const [command, name] = args;
+    const [command, name, sub] = args;
+    const unknownFlags = [...flags].filter((f) => !KNOWN_FLAGS.has(f));
+    if (unknownFlags.length > 0) {
+        log.error(`Unknown flag${unknownFlags.length > 1 ? 's' : ''}: ${unknownFlags.join(', ')}`);
+        return 1;
+    }
     if (flags.has('-v') || flags.has('--version')) {
         log.info(version());
         return 0;
     }
-    if (command === undefined || flags.has('-h') || flags.has('--help')) {
+    if (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;
+        return 0;
     }
-    if (!name) {
-        log.error('create needs a project name: bahtui create <name>');
+    if (command === undefined) {
+        log.error('No command given — see usage below.');
+        log.error(HELP);
         return 1;
     }
+    const dryRun = flags.has('--dry-run');
+    const force = flags.has('--force');
+    const generateDeps = {
+        reader: new DiskFileReader(),
+        writer: new DiskFileWriter(),
+        log,
+    };
     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;
+        if (command === 'create') {
+            if (!name) {
+                log.error('create needs a project name: bahtui create <name>');
+                return 1;
+            }
+            runCreate({
+                name,
+                targetDir: resolve(process.cwd(), name),
+                install: !flags.has('--no-install'),
+                git: !flags.has('--no-git'),
+                dryRun,
+                force,
+            }, {
+                templates: new DiskTemplateSource(),
+                renderer: new TemplateRenderer(),
+                writer: new DiskFileWriter(),
+                runner: new ShellRunner(),
+                log,
+            });
+            return 0;
+        }
+        if (command === 'init') {
+            runInit({
+                root: process.cwd(),
+                frontend: frontend === 'none' ? null : 'react',
+                backend: backend === 'none' ? null : 'elysia',
+                dryRun,
+                force,
+            }, generateDeps);
+            return 0;
+        }
+        if (command === 'g') {
+            if (name !== 'model' && name !== 'form') {
+                log.error('Unknown generator — bahtui g model <domain> | g form <domain>/<name>.');
+                return 1;
+            }
+            if (!sub) {
+                log.error(`g ${name} needs a target: bahtui g ${name} <${name === 'model' ? 'domain' : 'domain/name'}>`);
+                return 1;
+            }
+            runGenerate({ root: process.cwd(), kind: name, target: sub, fields, dryRun, force }, generateDeps);
+            return 0;
+        }
+        log.error(`Unknown command "${command}".`);
+        log.error(HELP);
+        return 1;
     }
     catch (err) {
-        log.error(err instanceof CreateError ? err.message : String(err));
+        log.error(err instanceof CreateError || err instanceof GenerateError ? err.message : String(err));
         return 1;
     }
 }

package/dist/domain/create-plan.js

@@ -2,7 +2,7 @@
  * 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).
+ *   never meet the renderer).
  * - leading `_` on a basename → `.` (npm pack silently drops/renames real
  *   .gitignore files inside packages, so templates ship `_gitignore`).
  */

package/dist/domain/form-dsl.js

@@ -0,0 +1,105 @@
+import { parseSchema } from 'bank20baht-validator';
+/**
+ * Compact field DSL for `bahtui g form` (spec 04-adjacent, PRD P3):
+ *
+ *   --fields "title:text:required,priority:dropdown:options=low|medium|high,qty:number"
+ *
+ * field  = key ':' type (':' modifier)*
+ * mods   = 'required' | 'options=a|b|c' | 'min=N' | 'max=N' | 'flag=NAME'
+ *
+ * The result is engine-validated (parseSchema) BEFORE any file is written —
+ * an invalid spec exits 1 with zero files (the P1 guarantee, kept).
+ */
+const FIELD_TYPES = new Set([
+    'text',
+    'textarea',
+    'number',
+    'email',
+    'dropdown',
+    'multiselect',
+    'checkbox',
+    'radio',
+    'toggle',
+    'date',
+    'file',
+]);
+const KEY_PATTERN = /^[a-z][a-z0-9_]*$/;
+const titleCase = (key) => key
+    .split('_')
+    .map((w) => (w ? w[0].toUpperCase() + w.slice(1) : w))
+    .join(' ');
+/** `min=`/`max=` must be a real, non-empty number — never silently coerced to NaN/0. */
+function parseNumberMod(name, raw, part) {
+    const n = Number(raw);
+    if (raw.trim() === '' || !Number.isFinite(n)) {
+        throw new FormDslError(`Bad ${name} value ${JSON.stringify(raw)} in "${part}" — expected a number.`);
+    }
+    return n;
+}
+export function parseFieldsDsl(dsl) {
+    const fields = [];
+    const parts = dsl
+        .split(',')
+        .map((p) => p.trim())
+        .filter(Boolean);
+    if (parts.length === 0)
+        throw new FormDslError('No fields given — pass --fields "key:type,…".');
+    for (const [i, part] of parts.entries()) {
+        const [key, type, ...mods] = part.split(':').map((s) => s.trim());
+        if (!key || !KEY_PATTERN.test(key)) {
+            throw new FormDslError(`Bad field key ${JSON.stringify(key ?? '')} in "${part}".`);
+        }
+        if (!type || !FIELD_TYPES.has(type)) {
+            throw new FormDslError(`Unknown field type ${JSON.stringify(type ?? '')} in "${part}" — one of: ${[...FIELD_TYPES].join(', ')}.`);
+        }
+        const field = { order: i + 1, type, key, label: titleCase(key) };
+        for (const mod of mods) {
+            if (mod === 'required')
+                field.required = true;
+            else if (mod.startsWith('options=')) {
+                const opts = mod
+                    .slice('options='.length)
+                    .split('|')
+                    .map((o) => o.trim())
+                    .filter(Boolean);
+                if (opts.length === 0) {
+                    throw new FormDslError(`options modifier needs at least one value in "${part}".`);
+                }
+                if (new Set(opts).size !== opts.length) {
+                    throw new FormDslError(`Duplicate option keys in "${part}".`);
+                }
+                field.options = opts.map((o) => ({ key: o, label: titleCase(o) }));
+            }
+            else if (mod.startsWith('min='))
+                field.min = parseNumberMod('min', mod.slice(4), part);
+            else if (mod.startsWith('max='))
+                field.max = parseNumberMod('max', mod.slice(4), part);
+            else if (mod.startsWith('flag='))
+                field.flag = mod.slice(5);
+            else
+                throw new FormDslError(`Unknown modifier ${JSON.stringify(mod)} in "${part}".`);
+        }
+        fields.push(field);
+    }
+    const keys = fields.map((f) => f.key);
+    if (new Set(keys).size !== keys.length) {
+        throw new FormDslError('Field keys must be unique.');
+    }
+    return fields;
+}
+/** DSL -> FormDefinition, engine-validated. Throws FormDslError on any problem. */
+export function buildFormDefinition(domain, name, dsl) {
+    const form = {
+        formId: `${domain}-${name}`,
+        formName: titleCase(name.replace(/-/g, '_')).replace(/ /g, '_'),
+        field_data: parseFieldsDsl(dsl),
+    };
+    try {
+        return parseSchema(JSON.stringify(form));
+    }
+    catch (err) {
+        throw new FormDslError(`Engine rejected the form spec: ${err.message}`);
+    }
+}
+export class FormDslError extends Error {
+}

package/dist/domain/generate-plan.js

@@ -0,0 +1,60 @@
+export const DEFAULT_CONFIG = {
+    apps: { web: 'apps/web', api: 'apps/api' },
+    libsDir: 'libs',
+    frontend: 'react',
+    backend: 'elysia',
+    edenClient: 'libs/shared/eden',
+};
+const DOMAIN_PATTERN = /^[a-z][a-z0-9-]*$/;
+export function validateDomainName(domain) {
+    return DOMAIN_PATTERN.test(domain)
+        ? []
+        : [`"${domain}" is not a valid domain name — lowercase letters, digits, dashes.`];
+}
+/** `bahtui init` — write bahtui.json into an existing repo (root = cwd). */
+export function planInit(root, config) {
+    return {
+        root,
+        files: [{ path: 'bahtui.json', contents: JSON.stringify(config, null, 2) + '\n' }],
+        postCommands: [],
+    };
+}
+export function modelDir(config, domain) {
+    return `${config.libsDir}/domain/${domain}/model`;
+}
+/** `bahtui g model <domain>` — the framework-free domain model lib (PRD). */
+export function planModel(root, config, domain) {
+    const dir = modelDir(config, domain);
+    const pkg = {
+        name: `domain-${domain}-model`,
+        version: '0.0.0',
+        private: true,
+        type: 'module',
+        exports: { '.': './src/index.ts' },
+    };
+    return {
+        root,
+        files: [
+            { path: `${dir}/package.json`, contents: JSON.stringify(pkg, null, 2) + '\n' },
+            {
+                path: `${dir}/src/index.ts`,
+                contents: `// ${domain} domain model — entities and form JSON live here.\n// NO react, NO elysia in this package (dependency rule: everything points AT model).\nexport {};\n`,
+            },
+        ],
+        postCommands: [],
+    };
+}
+/** `bahtui g form <domain>/<name>` — engine-validated FormDefinition JSON. */
+export function planForm(root, config, domain, name, form) {
+    const dir = modelDir(config, domain);
+    return {
+        root,
+        files: [
+            {
+                path: `${dir}/src/${name}.form.json`,
+                contents: JSON.stringify(form, null, 2) + '\n',
+            },
+        ],
+        postCommands: [],
+    };
+}

package/dist/infrastructure/fs-reader.js

@@ -0,0 +1,14 @@
+import { existsSync, readFileSync } from 'node:fs';
+export class DiskFileReader {
+    exists(path) {
+        return existsSync(path);
+    }
+    read(path) {
+        try {
+            return readFileSync(path, 'utf8');
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/infrastructure/fs-writer.js

@@ -1,9 +1,12 @@
-import { existsSync, mkdirSync, readdirSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { existsSync, mkdirSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, resolve, sep } from 'node:path';
 export class DiskFileWriter {
     ensureUsableDir(dir, force) {
         if (!existsSync(dir))
             return;
+        if (!statSync(dir).isDirectory()) {
+            throw new Error(`${dir} exists and is not a directory.`);
+        }
         if (readdirSync(dir).length === 0)
             return;
         if (force)
@@ -11,8 +14,12 @@ export class DiskFileWriter {
         throw new Error(`${dir} already exists and is not empty (use --force to write anyway).`);
     }
     writeFiles(blueprint) {
+        const root = resolve(blueprint.root);
         for (const file of blueprint.files) {
-            const abs = join(blueprint.root, file.path);
+            const abs = resolve(root, file.path);
+            if (abs !== root && !abs.startsWith(root + sep)) {
+                throw new Error(`Refusing to write "${file.path}" — it resolves outside the target directory ${root}.`);
+            }
             mkdirSync(dirname(abs), { recursive: true });
             writeFileSync(abs, file.contents);
         }

package/dist/infrastructure/shell-runner.js

@@ -2,8 +2,12 @@ import { spawnSync } from 'node:child_process';
 export class ShellRunner {
     run(cmd, args, cwd) {
         const result = spawnSync(cmd, args, { cwd, stdio: 'inherit' });
-        if (result.error)
+        if (result.error) {
+            if (result.error.code === 'ENOENT') {
+                throw new Error(`'${cmd}' not found on PATH — install it first.`);
+            }
             throw result.error;
+        }
         if (result.status !== 0) {
             throw new Error(`${cmd} ${args.join(' ')} exited with code ${result.status}`);
         }

package/dist/infrastructure/template-renderer.js

@@ -0,0 +1,16 @@
+/**
+ * The create template set's only expression form is `{{key}}` substitution —
+ * a full template engine (handlebars, ~1.5 MB installed) buys nothing here.
+ * Unknown variables throw, matching the old handlebars strict-mode behavior.
+ * No escaping: these are code/config files, not HTML — quotes must survive.
+ */
+export class TemplateRenderer {
+    render(raw, data) {
+        return raw.replaceAll(/\{\{\s*([\w.]+)\s*\}\}/g, (_, key) => {
+            if (!Object.hasOwn(data, key)) {
+                throw new Error(`unknown template variable "${key}"`);
+            }
+            return String(data[key]);
+        });
+    }
+}

package/dist/infrastructure/template-source.js

@@ -1,4 +1,4 @@
-import { readdirSync, readFileSync } from 'node:fs';
+import { existsSync, 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. */
@@ -9,6 +9,9 @@ export class DiskTemplateSource {
     }
     load(set) {
         const setRoot = join(this.root, set);
+        if (!existsSync(setRoot)) {
+            throw new Error(`template set '${set}' missing — reinstall bank20baht-cli`);
+        }
         const entries = readdirSync(setRoot, { recursive: true, withFileTypes: true });
         const files = [];
         for (const entry of entries) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bank20baht-cli",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "type": "module",
   "description": "Scaffold bun-workspace DDD monorepos (React + Elysia + Eden) and bahtui generators.",
   "license": "MIT",
@@ -27,6 +27,9 @@
   "publishConfig": {
     "access": "public"
   },
+  "engines": {
+    "node": ">=20.12"
+  },
   "bin": {
     "bahtui": "./dist/cli.js"
   },
@@ -40,7 +43,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "handlebars": "^4.7.8"
+    "bank20baht-validator": "^0.1.0"
   },
   "devDependencies": {
     "@types/node": "^22",

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

@@ -12,7 +12,7 @@ export default function App() {
   }, []);
 
   return (
-    <main style={ { fontFamily: 'system-ui', padding: '2rem' } }>
+    <main style={{ fontFamily: 'system-ui', padding: '2rem' }}>
       <h1>{{name}}</h1>
       <p>{status}</p>
     </main>

package/dist/application/create.d.ts

@@ -1,16 +0,0 @@
-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/ports.d.ts

@@ -1,23 +0,0 @@
-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/cli.d.ts

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

package/dist/domain/blueprint.d.ts

@@ -1,23 +0,0 @@
-/**
- * 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/create-plan.d.ts

@@ -1,24 +0,0 @@
-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/naming.d.ts

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

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

@@ -1,6 +0,0 @@
-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/hbs-renderer.d.ts

@@ -1,4 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

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

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

@@ -1,7 +0,0 @@
-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[];
-}