bank20baht-cli 0.0.1 → 0.0.2

package/dist/application/generate.d.ts

@@ -0,0 +1,33 @@
+import type { FileWriter, Logger } from './ports.js';
+/** Read-only fs the generators need: existence checks + bahtui.json. */
+export interface FileReader {
+    exists(path: string): boolean;
+    read(path: string): string | null;
+}
+export interface GenerateDeps {
+    reader: FileReader;
+    writer: FileWriter;
+    log: Logger;
+}
+export declare class GenerateError extends Error {
+}
+export interface InitInput {
+    root: string;
+    frontend: 'react' | null;
+    backend: 'elysia' | null;
+    dryRun: boolean;
+    force: boolean;
+}
+/** `bahtui init` (PRD P2): bahtui.json for an existing repo, paths detected. */
+export declare function runInit(input: InitInput, deps: GenerateDeps): void;
+export interface GenerateInput {
+    root: string;
+    kind: 'model' | 'form';
+    /** `<domain>` for model, `<domain>/<name>` for form. */
+    target: string;
+    fields?: string;
+    dryRun: boolean;
+    force: boolean;
+}
+/** `bahtui g model|form` (PRD P3). Engine-validates before any write. */
+export declare function runGenerate(input: GenerateInput, deps: GenerateDeps): void;

package/dist/application/generate.js

@@ -0,0 +1,91 @@
+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 {
+}
+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.');
+    }
+    try {
+        return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+    }
+    catch {
+        throw new GenerateError('bahtui.json is not valid JSON.');
+    }
+}
+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 { 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,10 +40,23 @@ const log = {
     step: (m) => console.log(`• ${m}`),
     error: (m) => console.error(`✖ ${m}`),
 };
-function main(argv) {
+/** Value-carrying flags (--flag value) pulled out before positional parsing. */
+function takeOption(argv, flag) {
+    const i = argv.indexOf(flag);
+    if (i === -1)
+        return undefined;
+    const value = argv[i + 1];
+    argv.splice(i, value !== undefined && !value.startsWith('-') ? 2 : 1);
+    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;
     if (flags.has('-v') || flags.has('--version')) {
         log.info(version());
         return 0;
@@ -41,34 +65,63 @@ function main(argv) {
         log.info(HELP);
         return command === undefined && !flags.has('-h') && !flags.has('--help') ? 1 : 0;
     }
-    if (command !== 'create') {
+    const dryRun = flags.has('--dry-run');
+    const force = flags.has('--force');
+    const generateDeps = {
+        reader: new DiskFileReader(),
+        writer: new DiskFileWriter(),
+        log,
+    };
+    try {
+        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 HbsRenderer(),
+                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.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));
+        log.error(err instanceof CreateError || err instanceof GenerateError ? err.message : String(err));
         return 1;
     }
 }

package/dist/domain/form-dsl.d.ts

@@ -0,0 +1,20 @@
+import { type FormDefinition } from 'bank20baht-validator';
+export interface DslField {
+    order: number;
+    type: string;
+    key: string;
+    label: string;
+    required?: boolean;
+    options?: Array<{
+        key: string;
+        label: string;
+    }>;
+    min?: number;
+    max?: number;
+    flag?: string;
+}
+export declare function parseFieldsDsl(dsl: string): DslField[];
+/** DSL -> FormDefinition, engine-validated. Throws FormDslError on any problem. */
+export declare function buildFormDefinition(domain: string, name: string, dsl: string): FormDefinition;
+export declare class FormDslError extends Error {
+}

package/dist/domain/form-dsl.js

@@ -0,0 +1,90 @@
+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(' ');
+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=')) {
+                field.options = mod
+                    .slice('options='.length)
+                    .split('|')
+                    .filter(Boolean)
+                    .map((o) => ({ key: o, label: titleCase(o) }));
+            }
+            else if (mod.startsWith('min='))
+                field.min = Number(mod.slice(4));
+            else if (mod.startsWith('max='))
+                field.max = Number(mod.slice(4));
+            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.d.ts

@@ -0,0 +1,23 @@
+import type { FormDefinition } from 'bank20baht-validator';
+import type { Blueprint } from './blueprint.js';
+/** bahtui.json — written by create/init, read by every `g` command (PRD). */
+export interface BahtuiConfig {
+    apps: {
+        web?: string;
+        api?: string;
+    };
+    libsDir: string;
+    frontend: 'react' | null;
+    backend: 'elysia' | null;
+    edenClient?: string;
+    wrapperPath?: string;
+}
+export declare const DEFAULT_CONFIG: BahtuiConfig;
+export declare function validateDomainName(domain: string): string[];
+/** `bahtui init` — write bahtui.json into an existing repo (root = cwd). */
+export declare function planInit(root: string, config: BahtuiConfig): Blueprint;
+export declare function modelDir(config: BahtuiConfig, domain: string): string;
+/** `bahtui g model <domain>` — the framework-free domain model lib (PRD). */
+export declare function planModel(root: string, config: BahtuiConfig, domain: string): Blueprint;
+/** `bahtui g form <domain>/<name>` — engine-validated FormDefinition JSON. */
+export declare function planForm(root: string, config: BahtuiConfig, domain: string, name: string, form: FormDefinition): Blueprint;

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.d.ts

@@ -0,0 +1,5 @@
+import type { FileReader } from '../application/generate.js';
+export declare class DiskFileReader implements FileReader {
+    exists(path: string): boolean;
+    read(path: string): string | null;
+}

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bank20baht-cli",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "type": "module",
   "description": "Scaffold bun-workspace DDD monorepos (React + Elysia + Eden) and bahtui generators.",
   "license": "MIT",
@@ -40,7 +40,8 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "handlebars": "^4.7.8"
+    "handlebars": "^4.7.8",
+    "bank20baht-validator": "^0.0.5"
   },
   "devDependencies": {
     "@types/node": "^22",