@tailor-platform/erp-kit 0.2.2 → 0.3.0

package/dist/cli.mjs

@@ -430,6 +430,60 @@ async function runCheck(config, cwd) {
 	return results.some((code) => code !== 0) ? 1 : 0;
 }
 //#endregion
+//#region src/commands/init-module.ts
+function runInitModule(name, dir) {
+	const moduleDir = path.resolve(dir, name);
+	if (fs.existsSync(moduleDir)) {
+		console.error(`Directory already exists: ${moduleDir}`);
+		return 1;
+	}
+	fs.mkdirSync(moduleDir, { recursive: true });
+	return 0;
+}
+async function runInitModuleWithReadme(name, dir, cwd) {
+	const initResult = runInitModule(name, dir);
+	if (initResult !== 0) return initResult;
+	const moduleDir = path.resolve(cwd, dir, name);
+	const readmePath = path.join(moduleDir, "README.md");
+	const schemaPath = MODULE_SCHEMAS.module;
+	const { exitCode, stdout, stderr } = await runMdschema([
+		"generate",
+		"--schema",
+		schemaPath,
+		"--output",
+		readmePath
+	], cwd);
+	if (stdout.trim()) console.log(stdout);
+	if (stderr.trim()) console.error(stderr);
+	return exitCode;
+}
+function runInitApp(name, dir) {
+	const appDir = path.resolve(dir, name);
+	if (fs.existsSync(appDir)) {
+		console.error(`Directory already exists: ${appDir}`);
+		return 1;
+	}
+	fs.mkdirSync(appDir, { recursive: true });
+	return 0;
+}
+async function runInitAppWithReadme(name, dir, cwd) {
+	const initResult = runInitApp(name, dir);
+	if (initResult !== 0) return initResult;
+	const appDir = path.resolve(cwd, dir, name);
+	const readmePath = path.join(appDir, "README.md");
+	const schemaPath = APP_COMPOSE_SCHEMAS.app;
+	const { exitCode, stdout, stderr } = await runMdschema([
+		"generate",
+		"--schema",
+		schemaPath,
+		"--output",
+		readmePath
+	], cwd);
+	if (stdout.trim()) console.log(stdout);
+	if (stderr.trim()) console.error(stderr);
+	return exitCode;
+}
+//#endregion
 //#region src/commands/parse-doc-test-cases.ts
 function isHeading$1(node) {
 	return node.type === "heading";
@@ -655,158 +709,6 @@ function formatSyncCheckReport(result) {
 	return lines.join("\n");
 }
 //#endregion
-//#region src/commands/scaffold.ts
-const MODULE_TYPES = [
-	"module",
-	"feature",
-	"command",
-	"model",
-	"query"
-];
-const APP_TYPES = [
-	"app",
-	"actors",
-	"business-flow",
-	"story",
-	"screen",
-	"resolver"
-];
-[...MODULE_TYPES, ...APP_TYPES];
-const MODULE_DIR_MAP = {
-	feature: "docs/features",
-	command: "docs/commands",
-	model: "docs/models",
-	query: "docs/queries"
-};
-const APP_DIR_MAP = {
-	actors: "docs/actors",
-	"business-flow": "docs/business-flow",
-	screen: "docs/screen",
-	resolver: "docs/resolver"
-};
-function resolveScaffoldPath(type, parentName, name, root) {
-	if (type === "module" || type === "app") return path.join(root, parentName, "README.md");
-	if (!name) throw new Error(`Name is required for scaffold type "${type}"`);
-	if (type === "business-flow") return path.join(root, parentName, "docs/business-flow", name, "README.md");
-	if (type === "story") {
-		const parts = name.split("/");
-		if (parts.length !== 2) throw new Error(`Story name must be "<flow>/<story>" (e.g., "onboarding/admin--create-user")`);
-		return path.join(root, parentName, "docs/business-flow", parts[0], "story", `${parts[1]}.md`);
-	}
-	if (MODULE_DIR_MAP[type]) return path.join(root, parentName, MODULE_DIR_MAP[type], `${name}.md`);
-	if (APP_DIR_MAP[type]) return path.join(root, parentName, APP_DIR_MAP[type], `${name}.md`);
-	throw new Error(`Unknown scaffold type: ${type}`);
-}
-async function runScaffold(type, parentName, name, root, cwd) {
-	const outputPath = resolveScaffoldPath(type, parentName, name, root);
-	const absoluteOutput = path.resolve(cwd, outputPath);
-	if (fs.existsSync(absoluteOutput)) {
-		console.error(`File already exists: ${outputPath}`);
-		return 1;
-	}
-	const schemaPath = ALL_SCHEMAS[type];
-	if (!schemaPath) {
-		console.error(`No schema found for type: ${type}`);
-		return 2;
-	}
-	try {
-		fs.mkdirSync(path.dirname(absoluteOutput), { recursive: true });
-	} catch (err) {
-		console.error(`Failed to create directory: ${err instanceof Error ? err.message : String(err)}`);
-		return 1;
-	}
-	const { exitCode, stdout, stderr } = await runMdschema([
-		"generate",
-		"--schema",
-		schemaPath,
-		"--output",
-		absoluteOutput
-	], cwd);
-	if (stdout.trim()) console.log(stdout);
-	if (stderr.trim()) console.error(stderr);
-	if (exitCode !== 0) return exitCode;
-	if (type === "module") scaffoldModuleSrc(path.dirname(absoluteOutput), parentName);
-	if (type === "app") scaffoldAppSrc(path.dirname(absoluteOutput), parentName);
-	return exitCode;
-}
-function copyTemplateDir(srcDir, destDir, replacements, placeholderFiles) {
-	for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
-		const srcPath = path.join(srcDir, entry.name);
-		const destName = entry.name === "__dot__gitignore" ? ".gitignore" : entry.name;
-		const destPath = path.join(destDir, destName);
-		if (entry.isDirectory()) {
-			fs.mkdirSync(destPath, { recursive: true });
-			copyTemplateDir(srcPath, destPath, replacements, placeholderFiles);
-		} else {
-			fs.mkdirSync(path.dirname(destPath), { recursive: true });
-			if (placeholderFiles.has(entry.name)) {
-				let content = fs.readFileSync(srcPath, "utf-8");
-				for (const [from, to] of Object.entries(replacements)) content = content.replaceAll(from, to);
-				fs.writeFileSync(destPath, content);
-			} else fs.copyFileSync(srcPath, destPath);
-		}
-	}
-}
-function scaffoldModuleSrc(moduleDir, moduleName) {
-	copyTemplateDir(path.join(PACKAGE_ROOT, "templates", "scaffold", "module"), moduleDir, { "template-module": moduleName }, new Set(["permissions.ts", "tailor.config.ts"]));
-}
-function scaffoldAppSrc(appDir, appName) {
-	const templateDir = path.join(PACKAGE_ROOT, "templates", "scaffold", "app");
-	const erpKitVersion = readErpKitVersion();
-	copyTemplateDir(templateDir, appDir, {
-		"template-app-frontend": `${appName}-frontend`,
-		"template-app-backend": appName,
-		"template-app": appName,
-		"\"workspace:*\"": `"${erpKitVersion}"`
-	}, new Set([
-		"package.json",
-		"tailor.config.ts",
-		"index.html"
-	]));
-}
-//#endregion
-//#region src/commands/module/list.ts
-const MODULES_DIR = join(PACKAGE_ROOT, "src", "modules");
-const EXCLUDED_DIRS = new Set(["shared", "testing"]);
-function countFiles(dir, pattern, exclusions) {
-	if (!existsSync(dir)) return 0;
-	return readdirSync(dir).filter((f) => pattern.test(f) && !exclusions.some((p) => p.test(f))).length;
-}
-function listModules() {
-	if (!existsSync(MODULES_DIR)) return [];
-	return readdirSync(MODULES_DIR, { withFileTypes: true }).filter((d) => d.isDirectory() && !EXCLUDED_DIRS.has(d.name)).map((d) => {
-		const modDir = join(MODULES_DIR, d.name);
-		return {
-			name: d.name,
-			commands: countFiles(join(modDir, "command"), /\.ts$/, [/\.test\.ts$/]),
-			models: countFiles(join(modDir, "db"), /\.ts$/, [/\.test\.ts$/, /^index\.ts$/]),
-			features: countFiles(join(modDir, "docs", "features"), /\.md$/, [])
-		};
-	}).sort((a, b) => a.name.localeCompare(b.name));
-}
-function formatModuleList(modules) {
-	if (modules.length === 0) return "No modules found.";
-	const lines = [];
-	lines.push(chalk.bold("Modules:\n"));
-	const nameWidth = Math.max(...modules.map((m) => m.name.length), 4);
-	for (const mod of modules) {
-		const counts = [
-			`${mod.commands} commands`,
-			`${mod.models} models`,
-			`${mod.features} features`
-		].join(", ");
-		lines.push(`  ${mod.name.padEnd(nameWidth)}  ${counts}`);
-	}
-	lines.push("");
-	lines.push(`${modules.length} modules`);
-	return lines.join("\n");
-}
-function runModuleList() {
-	const modules = listModules();
-	console.log(formatModuleList(modules));
-	return 0;
-}
-//#endregion
 //#region src/generator/parse-command-doc.ts
 function parseCommandDoc(fileName, markdown) {
 	const commandName = fileName.charAt(0).toLowerCase() + fileName.slice(1);
@@ -995,6 +897,18 @@ describe("${doc.commandName}", () => {
 });
 `;
 }
+function generateDbStub(modelName) {
+	return `import { db, unsafeAllowAllGqlPermission, unsafeAllowAllTypePermission } from "@tailor-platform/sdk";
+
+export const ${modelName} = db
+  .type("${modelName.charAt(0).toUpperCase() + modelName.slice(1)}", {
+    // TODO: define fields
+    ...db.fields.timestamps(),
+  })
+  .permission(unsafeAllowAllTypePermission)
+  .gqlPermission(unsafeAllowAllGqlPermission);
+`;
+}
 function generatePermissions(moduleName, commandNames) {
 	return `// @generated — do not edit
 import { definePermissions } from "../../../shared";
@@ -1004,18 +918,63 @@ ${[...commandNames].sort().map((name) => `  "${name}",`).join("\n")}
 ] as const);
 `;
 }
+function copyTemplateDir(srcDir, destDir, replacements, placeholderFiles) {
+	for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+		const srcPath = path.join(srcDir, entry.name);
+		const destName = entry.name === "__dot__gitignore" ? ".gitignore" : entry.name;
+		const destPath = path.join(destDir, destName);
+		if (entry.isDirectory()) {
+			fs.mkdirSync(destPath, { recursive: true });
+			copyTemplateDir(srcPath, destPath, replacements, placeholderFiles);
+		} else {
+			if (fs.existsSync(destPath)) continue;
+			fs.mkdirSync(path.dirname(destPath), { recursive: true });
+			if (placeholderFiles.has(entry.name)) {
+				let content = fs.readFileSync(srcPath, "utf-8");
+				for (const [from, to] of Object.entries(replacements)) content = content.replaceAll(from, to);
+				fs.writeFileSync(destPath, content);
+			} else fs.copyFileSync(srcPath, destPath);
+		}
+	}
+}
+function scaffoldModuleBoilerplate(moduleDir, moduleName) {
+	copyTemplateDir(path.join(PACKAGE_ROOT, "templates", "scaffold", "module"), moduleDir, { "template-module": moduleName }, new Set(["permissions.ts", "tailor.config.ts"]));
+}
+function scaffoldAppBoilerplate(appDir, appName) {
+	const templateDir = path.join(PACKAGE_ROOT, "templates", "scaffold", "app");
+	const erpKitVersion = readErpKitVersion();
+	copyTemplateDir(templateDir, appDir, {
+		"template-app-frontend": `${appName}-frontend`,
+		"template-app-backend": appName,
+		"template-app": appName,
+		"\"workspace:*\"": `"${erpKitVersion}"`
+	}, new Set([
+		"package.json",
+		"tailor.config.ts",
+		"index.html"
+	]));
+}
+function runGenerateAppCode(appPath) {
+	const appName = path.basename(appPath);
+	scaffoldAppBoilerplate(appPath, appName);
+	console.log(`Generated boilerplate for ${appName}`);
+	return 0;
+}
 function runGenerateCode(modulePath, moduleName) {
+	scaffoldModuleBoilerplate(modulePath, moduleName);
 	const docsDir = path.join(modulePath, "docs", "commands");
 	const libDir = path.join(modulePath, "lib");
 	const commandDir = path.join(modulePath, "command");
 	if (!fs.existsSync(docsDir)) {
-		console.error(`No docs/commands/ directory found at ${docsDir}`);
-		return 1;
+		console.log(`No docs/commands/ directory found — skipping code generation`);
+		console.log(`Generated boilerplate for ${moduleName}`);
+		return 0;
 	}
 	const mdFiles = fs.readdirSync(docsDir).filter((f) => f.endsWith(".md"));
 	if (mdFiles.length === 0) {
-		console.error(`No command docs found in ${docsDir}`);
-		return 1;
+		console.log(`No command docs found — skipping code generation`);
+		console.log(`Generated boilerplate for ${moduleName}`);
+		return 0;
 	}
 	const parsedDocs = [];
 	for (const file of mdFiles) {
@@ -1090,41 +1049,185 @@ function runGenerateCode(modulePath, moduleName) {
 			}
 		}
 	}
+	const modelDocsDir = path.join(modulePath, "docs", "models");
+	if (fs.existsSync(modelDocsDir)) {
+		const modelFiles = fs.readdirSync(modelDocsDir).filter((f) => f.endsWith(".md"));
+		if (modelFiles.length > 0) {
+			const dbDir = path.join(modulePath, "db");
+			fs.mkdirSync(dbDir, { recursive: true });
+			for (const file of modelFiles) {
+				const modelName = path.basename(file, ".md");
+				const camelName = modelName.charAt(0).toLowerCase() + modelName.slice(1);
+				const dbFile = path.join(dbDir, `${camelName}.ts`);
+				if (!fs.existsSync(dbFile)) {
+					fs.writeFileSync(dbFile, generateDbStub(camelName));
+					console.log(`  scaffolded ${path.relative(modulePath, dbFile)}`);
+				}
+			}
+		}
+	}
 	console.log(`Generated ${generated} file(s) for ${moduleName}`);
 	return 0;
 }
 //#endregion
+//#region src/commands/generate-doc.ts
+const MODULE_DOC_TYPES = [
+	"feature",
+	"command",
+	"model",
+	"query"
+];
+const APP_DOC_TYPES = [
+	"actors",
+	"business-flow",
+	"story",
+	"screen",
+	"resolver"
+];
+[...MODULE_DOC_TYPES, ...APP_DOC_TYPES];
+const MODULE_DIR_MAP = {
+	feature: "docs/features",
+	command: "docs/commands",
+	model: "docs/models",
+	query: "docs/queries"
+};
+const APP_DIR_MAP = {
+	actors: "docs/actors",
+	"business-flow": "docs/business-flow",
+	screen: "docs/screen",
+	resolver: "docs/resolver"
+};
+function resolveDocPath(type, name, modulePath) {
+	if (!name) throw new Error(`Name is required for doc type "${type}"`);
+	if (type === "business-flow") return path.join(modulePath, "docs/business-flow", name, "README.md");
+	if (type === "story") {
+		const parts = name.split("/");
+		if (parts.length !== 2) throw new Error(`Story name must be "<flow>/<story>" (e.g., "onboarding/admin--create-user")`);
+		return path.join(modulePath, "docs/business-flow", parts[0], "story", `${parts[1]}.md`);
+	}
+	if (MODULE_DIR_MAP[type]) return path.join(modulePath, MODULE_DIR_MAP[type], `${name}.md`);
+	if (APP_DIR_MAP[type]) return path.join(modulePath, APP_DIR_MAP[type], `${name}.md`);
+	throw new Error(`Unknown doc type: ${type}`);
+}
+async function runGenerateDoc(type, name, modulePath, cwd) {
+	const outputPath = resolveDocPath(type, name, modulePath);
+	const absoluteOutput = path.resolve(cwd, outputPath);
+	if (fs.existsSync(absoluteOutput)) {
+		console.error(`File already exists: ${outputPath}`);
+		return 1;
+	}
+	const schemaPath = ALL_SCHEMAS[type];
+	if (!schemaPath) {
+		console.error(`No schema found for type: ${type}`);
+		return 2;
+	}
+	try {
+		fs.mkdirSync(path.dirname(absoluteOutput), { recursive: true });
+	} catch (err) {
+		console.error(`Failed to create directory: ${err instanceof Error ? err.message : String(err)}`);
+		return 1;
+	}
+	const { exitCode, stdout, stderr } = await runMdschema([
+		"generate",
+		"--schema",
+		schemaPath,
+		"--output",
+		absoluteOutput
+	], cwd);
+	if (stdout.trim()) console.log(stdout);
+	if (stderr.trim()) console.error(stderr);
+	return exitCode;
+}
+//#endregion
 //#region src/commands/module/generate.ts
 const cwd$3 = process.cwd();
-const generateCommand = defineCommand({
+const pathArgs$2 = z.object({ path: arg(z.string(), {
+	alias: "p",
+	description: "Path to the module directory"
+}) });
+const generateCommand$1 = defineCommand({
 	name: "generate",
-	description: "Generate code from model definitions and docs",
-	subCommands: { code: defineCommand({
-		name: "code",
-		description: "Generate errors, permissions, command shells, and query shells from docs",
-		args: z.object({
-			root: arg(z.string(), {
-				alias: "r",
-				description: "Path to modules directory"
+	description: "Generate docs and code for a module",
+	subCommands: {
+		doc: defineCommand({
+			name: "doc",
+			description: "Create a documentation file from a schema template",
+			args: pathArgs$2.extend({
+				type: arg(z.enum(MODULE_DOC_TYPES), {
+					positional: true,
+					description: `Doc type (${MODULE_DOC_TYPES.join(", ")})`
+				}),
+				name: arg(z.string().optional(), {
+					positional: true,
+					description: "Item name (required for all types)"
+				})
 			}),
-			module: arg(z.string(), {
-				positional: true,
-				description: "Module name (e.g., primitives, item-management)"
-			})
+			run: async (args) => {
+				const exitCode = await runGenerateDoc(args.type, args.name, args.path, cwd$3);
+				process.exit(exitCode);
+			}
 		}),
-		run: (args) => {
-			const modulePath = path.resolve(cwd$3, args.root, args.module);
-			console.log(`Generating code for ${args.module}...`);
-			const exitCode = runGenerateCode(modulePath, args.module);
-			process.exit(exitCode);
-		}
-	}) }
+		code: defineCommand({
+			name: "code",
+			description: "Generate boilerplate, implementation stubs, and generated code from docs",
+			args: pathArgs$2,
+			run: (args) => {
+				const modulePath = path.resolve(cwd$3, args.path);
+				const moduleName = path.basename(modulePath);
+				console.log(`Generating code for ${moduleName}...`);
+				const exitCode = runGenerateCode(modulePath, moduleName);
+				process.exit(exitCode);
+			}
+		})
+	}
 });
 //#endregion
+//#region src/commands/module/list.ts
+const MODULES_DIR = join(PACKAGE_ROOT, "src", "modules");
+const EXCLUDED_DIRS = new Set(["shared", "testing"]);
+function countFiles(dir, pattern, exclusions) {
+	if (!existsSync(dir)) return 0;
+	return readdirSync(dir).filter((f) => pattern.test(f) && !exclusions.some((p) => p.test(f))).length;
+}
+function listModules() {
+	if (!existsSync(MODULES_DIR)) return [];
+	return readdirSync(MODULES_DIR, { withFileTypes: true }).filter((d) => d.isDirectory() && !EXCLUDED_DIRS.has(d.name)).map((d) => {
+		const modDir = join(MODULES_DIR, d.name);
+		return {
+			name: d.name,
+			commands: countFiles(join(modDir, "command"), /\.ts$/, [/\.test\.ts$/]),
+			models: countFiles(join(modDir, "db"), /\.ts$/, [/\.test\.ts$/, /^index\.ts$/]),
+			features: countFiles(join(modDir, "docs", "features"), /\.md$/, [])
+		};
+	}).sort((a, b) => a.name.localeCompare(b.name));
+}
+function formatModuleList(modules) {
+	if (modules.length === 0) return "No modules found.";
+	const lines = [];
+	lines.push(chalk.bold("Modules:\n"));
+	const nameWidth = Math.max(...modules.map((m) => m.name.length), 4);
+	for (const mod of modules) {
+		const counts = [
+			`${mod.commands} commands`,
+			`${mod.models} models`,
+			`${mod.features} features`
+		].join(", ");
+		lines.push(`  ${mod.name.padEnd(nameWidth)}  ${counts}`);
+	}
+	lines.push("");
+	lines.push(`${modules.length} modules`);
+	return lines.join("\n");
+}
+function runModuleList() {
+	const modules = listModules();
+	console.log(formatModuleList(modules));
+	return 0;
+}
+//#endregion
 //#region src/commands/module/index.ts
 const cwd$2 = process.cwd();
-const rootArgs$1 = z.object({ root: arg(z.string(), {
-	alias: "r",
+const pathArgs$1 = z.object({ path: arg(z.string(), {
+	alias: "p",
 	description: "Path to modules directory"
 }) });
 const listCommand = defineCommand({
@@ -1138,41 +1241,37 @@ const listCommand = defineCommand({
 const checkCommand$1 = defineCommand({
 	name: "check",
 	description: "Validate module docs against schemas",
-	args: rootArgs$1,
+	args: pathArgs$1,
 	run: async (args) => {
-		const exitCode = await runCheck({ modulesRoot: args.root }, cwd$2);
+		const exitCode = await runCheck({ modulesRoot: args.path }, cwd$2);
 		process.exit(exitCode);
 	}
 });
 const syncCheckCommand$1 = defineCommand({
 	name: "sync-check",
 	description: "Validate source <-> doc correspondence",
-	args: rootArgs$1,
+	args: pathArgs$1,
 	run: async (args) => {
-		const result = await runSyncCheck({ modulesRoot: args.root }, cwd$2);
+		const result = await runSyncCheck({ modulesRoot: args.path }, cwd$2);
 		console.log(formatSyncCheckReport(result));
 		process.exit(result.exitCode);
 	}
 });
-const scaffoldCommand$1 = defineCommand({
-	name: "scaffold",
-	description: "Generate module doc from schema template",
-	args: rootArgs$1.extend({
-		type: arg(z.enum(MODULE_TYPES), {
-			positional: true,
-			description: `Scaffold type (${MODULE_TYPES.join(", ")})`
-		}),
-		parent: arg(z.string(), {
+const initCommand$2 = defineCommand({
+	name: "init",
+	description: "Bootstrap a new module with directory structure and README",
+	args: z.object({
+		name: arg(z.string(), {
 			positional: true,
 			description: "Module name"
 		}),
-		name: arg(z.string().optional(), {
+		dir: arg(z.string(), {
 			positional: true,
-			description: "Item name (required for feature, command, model)"
+			description: "Parent directory where the module will be created"
 		})
 	}),
 	run: async (args) => {
-		const exitCode = await runScaffold(args.type, args.parent, args.name, args.root, cwd$2);
+		const exitCode = await runInitModuleWithReadme(args.name, args.dir, cwd$2);
 		process.exit(exitCode);
 	}
 });
@@ -1183,65 +1282,95 @@ const moduleCommand = defineCommand({
 		list: listCommand,
 		check: checkCommand$1,
 		"sync-check": syncCheckCommand$1,
-		scaffold: scaffoldCommand$1,
-		generate: generateCommand
+		init: initCommand$2,
+		generate: generateCommand$1
 	}
 });
 //#endregion
 //#region src/commands/app/index.ts
 const cwd$1 = process.cwd();
-const rootArgs = z.object({ root: arg(z.string(), {
-	alias: "r",
+const pathArgs = z.object({ path: arg(z.string(), {
+	alias: "p",
 	description: "Path to app-compose directory"
 }) });
 const checkCommand = defineCommand({
 	name: "check",
 	description: "Validate app docs against schemas",
-	args: rootArgs,
+	args: pathArgs,
 	run: async (args) => {
-		const exitCode = await runCheck({ appRoot: args.root }, cwd$1);
+		const exitCode = await runCheck({ appRoot: args.path }, cwd$1);
 		process.exit(exitCode);
 	}
 });
 const syncCheckCommand = defineCommand({
 	name: "sync-check",
 	description: "Validate source <-> doc correspondence",
-	args: rootArgs,
+	args: pathArgs,
 	run: async (args) => {
-		const result = await runSyncCheck({ appRoot: args.root }, cwd$1);
+		const result = await runSyncCheck({ appRoot: args.path }, cwd$1);
 		console.log(formatSyncCheckReport(result));
 		process.exit(result.exitCode);
 	}
 });
-const scaffoldCommand = defineCommand({
-	name: "scaffold",
-	description: "Generate app doc from schema template",
-	args: rootArgs.extend({
-		type: arg(z.enum(APP_TYPES), {
-			positional: true,
-			description: `Scaffold type (${APP_TYPES.join(", ")})`
-		}),
-		parent: arg(z.string(), {
+const initCommand$1 = defineCommand({
+	name: "init",
+	description: "Bootstrap a new app with directory structure and README",
+	args: z.object({
+		name: arg(z.string(), {
 			positional: true,
 			description: "App name"
 		}),
-		name: arg(z.string().optional(), {
+		dir: arg(z.string(), {
 			positional: true,
-			description: "Item name (required for most types)"
+			description: "Parent directory where the app will be created"
 		})
 	}),
 	run: async (args) => {
-		const exitCode = await runScaffold(args.type, args.parent, args.name, args.root, cwd$1);
+		const exitCode = await runInitAppWithReadme(args.name, args.dir, cwd$1);
 		process.exit(exitCode);
 	}
 });
+const generateCommand = defineCommand({
+	name: "generate",
+	description: "Generate docs and code for an app",
+	subCommands: {
+		doc: defineCommand({
+			name: "doc",
+			description: "Create a documentation file from a schema template",
+			args: pathArgs.extend({
+				type: arg(z.enum(APP_DOC_TYPES), {
+					positional: true,
+					description: `Doc type (${APP_DOC_TYPES.join(", ")})`
+				}),
+				name: arg(z.string().optional(), {
+					positional: true,
+					description: "Item name (required for most types)"
+				})
+			}),
+			run: async (args) => {
+				const exitCode = await runGenerateDoc(args.type, args.name, args.path, cwd$1);
+				process.exit(exitCode);
+			}
+		}),
+		code: defineCommand({
+			name: "code",
+			description: "Generate boilerplate source files from docs",
+			args: pathArgs,
+			run: (args) => {
+				const exitCode = runGenerateAppCode(path.resolve(cwd$1, args.path));
+				process.exit(exitCode);
+			}
+		})
+	}
+});
 const appCommand = defineCommand({
 	name: "app",
 	description: "App-compose management",
 	subCommands: {
 		check: checkCommand,
 		"sync-check": syncCheckCommand,
-		scaffold: scaffoldCommand
+		init: initCommand$1,
+		generate: generateCommand
 	}
 });
 //#endregion