create-wp-typia 0.1.0

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "create-wp-typia",
+  "version": "0.1.0",
+  "description": "Bun-first scaffolding CLI for WordPress Typia block templates",
+  "packageManager": "bun@1.3.10",
+  "type": "module",
+  "main": "lib/scaffold.js",
+  "bin": {
+    "create-wp-typia": "lib/entry.js"
+  },
+  "files": [
+    "dist/",
+    "lib/",
+    "src/",
+    "templates/",
+    "README.md",
+    "package.json"
+  ],
+  "scripts": {
+    "build": "bunli build --runtime node",
+    "dev": "bunli dev --runtime node",
+    "test": "bunli test --pattern ./tests/create-cli.test.ts",
+    "test:coverage": "bunli test --pattern ./tests/create-cli.test.ts --coverage && bun test tests/create-cli.test.ts --coverage --coverage-reporter=lcov --coverage-dir=coverage",
+    "clean": "rm -rf dist",
+    "prepack": "bun run build"
+  },
+  "keywords": [
+    "wordpress",
+    "gutenberg",
+    "typia",
+    "template",
+    "scaffold",
+    "cli",
+    "bun"
+  ],
+  "author": "imjlk",
+  "license": "GPL-2.0-or-later",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/imjlk/wp-typia-templates.git",
+    "directory": "packages/create-wp-typia"
+  },
+  "bugs": {
+    "url": "https://github.com/imjlk/wp-typia-templates/issues"
+  },
+  "homepage": "https://github.com/imjlk/wp-typia-templates/tree/main/packages/create-wp-typia#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=16.0.0",
+    "bun": ">=1.3.10"
+  },
+  "dependencies": {
+    "@bunli/core": "^0.8.2",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "bunli": "^0.8.2",
+    "typescript": "^5.9.2"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,329 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { access, constants as fsConstants, rm, writeFile } from "node:fs/promises";
+import { execFileSync, execSync } from "node:child_process";
+
+import { createCLI, defineCommand, defineGroup, option } from "@bunli/core";
+import { z } from "zod";
+
+import packageJson from "../package.json";
+import {
+	collectScaffoldAnswers,
+	resolvePackageManagerId,
+	resolveTemplateId,
+	scaffoldProject,
+} from "../lib/scaffold.js";
+import {
+	PACKAGE_MANAGER_IDS,
+	formatInstallCommand,
+	formatRunScript,
+	getPackageManager,
+	getPackageManagerSelectOptions,
+} from "../lib/package-managers.js";
+import {
+	TEMPLATE_IDS,
+	getTemplateById,
+	getTemplateSelectOptions,
+	listTemplates,
+} from "../lib/template-registry.js";
+
+const TOP_LEVEL_COMMANDS = new Set(["scaffold", "templates", "doctor"]);
+type TemplateRecord = ReturnType<typeof getTemplateById>;
+
+function normalizeRootArgv(argv: string[]) {
+	if (argv.length === 0) {
+		return argv;
+	}
+
+	const [first] = argv;
+	if (!first || first.startsWith("-") || TOP_LEVEL_COMMANDS.has(first)) {
+		return argv;
+	}
+
+	return ["scaffold", ...argv];
+}
+
+function formatTemplateSummary(template: TemplateRecord) {
+	return `${template.id.padEnd(14)} ${template.description}`;
+}
+
+async function collectInteractiveAnswers(prompt: any, projectName: string, templateId: string, yes: boolean) {
+	return collectScaffoldAnswers({
+		projectName,
+		templateId,
+		yes,
+		promptText: async (
+			message: string,
+			defaultValue: string,
+			validate?: (input: string) => boolean | string,
+		) =>
+			prompt.text(message, {
+				default: defaultValue,
+				validate: validate
+					? (value: string) => {
+						const result = validate(value);
+						return result === true ? true : result;
+					}
+					: undefined,
+			}),
+	});
+}
+
+async function runShellCommand(command: string, cwd: string) {
+	execSync(command, {
+		cwd,
+		stdio: "inherit",
+	});
+}
+
+function compareMajorVersion(actualVersion: string, minimumMajor: number) {
+	const parsed = Number.parseInt(actualVersion.replace(/^v/, "").split(".")[0] ?? "", 10);
+	return Number.isFinite(parsed) && parsed >= minimumMajor;
+}
+
+function readCommandVersion(command: string, args: string[] = ["--version"]) {
+	try {
+		return execFileSync(command, args, {
+			encoding: "utf8",
+			stdio: ["ignore", "pipe", "ignore"],
+		}).trim();
+	} catch {
+		return null;
+	}
+}
+
+async function checkWritableDirectory(directory: string) {
+	try {
+		await access(directory, fsConstants.W_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function checkTempDirectory() {
+	const tempFile = path.join(os.tmpdir(), `create-wp-typia-${Date.now()}.tmp`);
+	try {
+		await writeFile(tempFile, "ok", "utf8");
+		await rm(tempFile, { force: true });
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function printDoctorResult(colors: any, status: "pass" | "warn" | "fail", label: string, detail: string) {
+	const icon =
+		status === "pass" ? colors.green("PASS") : status === "warn" ? colors.yellow("WARN") : colors.red("FAIL");
+	console.log(`${icon} ${label}: ${detail}`);
+}
+
+const scaffoldCommand = defineCommand({
+	name: "scaffold",
+	description: "Scaffold a WordPress Typia block project",
+	options: {
+		template: option(z.enum(TEMPLATE_IDS as [string, ...string[]]).optional(), {
+			description: "Template ID to scaffold",
+			short: "t",
+		}),
+		yes: option(z.coerce.boolean().default(false), {
+			description: "Skip prompts and use defaults",
+			short: "y",
+		}),
+		noInstall: option(z.coerce.boolean().default(false), {
+			description: "Skip dependency installation",
+		}),
+		packageManager: option(z.enum(PACKAGE_MANAGER_IDS as [string, ...string[]]).optional(), {
+			description: "Package manager for the generated project",
+			short: "p",
+		}),
+	},
+	handler: async ({ colors, cwd, flags, positional, prompt, spinner, terminal }) => {
+		const projectInput = positional[0];
+		if (!projectInput) {
+			throw new Error("Project directory is required. Usage: create-wp-typia <project-dir>");
+		}
+
+		const projectDir = path.resolve(cwd, projectInput);
+		const projectName = path.basename(projectDir);
+		const templateId = await resolveTemplateId({
+			templateId: flags.template,
+			yes: flags.yes,
+			isInteractive: terminal.isInteractive,
+			selectTemplate: () =>
+				prompt.select("Select a template", {
+					default: "basic",
+					options: getTemplateSelectOptions(),
+				}),
+		});
+		const packageManager = await resolvePackageManagerId({
+			packageManager: flags.packageManager as "bun" | "npm" | "pnpm" | "yarn" | undefined,
+			yes: flags.yes,
+			isInteractive: terminal.isInteractive,
+			selectPackageManager: () =>
+				prompt.select("Choose a package manager", {
+					default: "bun",
+					options: getPackageManagerSelectOptions(),
+				}),
+		});
+		const answers = await collectInteractiveAnswers(prompt, projectName, templateId, flags.yes);
+
+		const copySpinner = spinner({ text: `Scaffolding ${templateId} template...` });
+		copySpinner.start();
+
+		try {
+			const result = await scaffoldProject({
+				answers,
+				installDependencies: flags.noInstall
+					? undefined
+					: async ({ packageManager: selectedPackageManager, projectDir: targetDir }) => {
+						const installSpinner = spinner({
+							text: `Installing dependencies with ${getPackageManager(selectedPackageManager).label}...`,
+						});
+						installSpinner.start();
+
+						try {
+							await runShellCommand(formatInstallCommand(selectedPackageManager), targetDir);
+							installSpinner.succeed("Dependencies installed");
+						} catch (error) {
+							installSpinner.fail("Dependency installation failed");
+							throw error;
+						}
+					},
+				noInstall: flags.noInstall,
+				packageManager,
+				projectDir,
+				templateId,
+			});
+			copySpinner.succeed(`Created ${result.variables.title}`);
+
+			console.log(`\n${colors.green("✓")} Project ready in ${projectDir}`);
+			console.log("Next steps:");
+			console.log(`  cd ${path.isAbsolute(projectInput) ? projectDir : projectInput}`);
+			if (flags.noInstall) {
+				console.log(`  ${formatInstallCommand(packageManager)}`);
+			}
+			console.log(`  ${formatRunScript(packageManager, "start")}`);
+		} catch (error) {
+			copySpinner.fail("Scaffolding failed");
+			throw error;
+		}
+	},
+});
+
+const templatesGroup = defineGroup({
+	name: "templates",
+	description: "Inspect available block templates",
+	commands: [
+		defineCommand({
+			name: "list",
+			description: "List available templates",
+			handler: async ({ colors }) => {
+				console.log(colors.bold("Available templates:\n"));
+				for (const template of listTemplates()) {
+					console.log(formatTemplateSummary(template));
+					console.log(`  ${colors.dim(template.features.join(" • "))}`);
+				}
+			},
+		}),
+		defineCommand({
+			name: "inspect",
+			description: "Inspect a template",
+			handler: async ({ colors, positional }) => {
+				const templateId = positional[0];
+				if (!templateId) {
+					throw new Error(`Template ID is required. Use one of: ${TEMPLATE_IDS.join(", ")}`);
+				}
+
+				const template = getTemplateById(templateId);
+				console.log(colors.bold(template.id));
+				console.log(template.description);
+				console.log(`Category: ${template.defaultCategory}`);
+				console.log(`Path: ${template.templateDir}`);
+				console.log(`Features: ${template.features.join(", ")}`);
+			},
+		}),
+	],
+});
+
+const doctorCommand = defineCommand({
+	name: "doctor",
+	description: "Check local CLI prerequisites",
+	handler: async ({ colors, cwd }) => {
+		const bunVersion = readCommandVersion("bun");
+		const nodeVersion = readCommandVersion("node");
+		const gitVersion = readCommandVersion("git");
+		const cwdWritable = await checkWritableDirectory(cwd);
+		const tempWritable = await checkTempDirectory();
+		let hasFailures = false;
+
+		printDoctorResult(
+			colors,
+			bunVersion && compareMajorVersion(bunVersion, 1) ? "pass" : "fail",
+			"Bun",
+			bunVersion ? `Detected ${bunVersion}` : "Not available",
+		);
+		hasFailures ||= !(bunVersion && compareMajorVersion(bunVersion, 1));
+
+		printDoctorResult(
+			colors,
+			nodeVersion && compareMajorVersion(nodeVersion, 16) ? "pass" : "fail",
+			"Node",
+			nodeVersion ? `Detected ${nodeVersion}` : "Not available",
+		);
+		hasFailures ||= !(nodeVersion && compareMajorVersion(nodeVersion, 16));
+
+		printDoctorResult(
+			colors,
+			gitVersion ? "pass" : "fail",
+			"git",
+			gitVersion ?? "Not available",
+		);
+		hasFailures ||= !gitVersion;
+
+		printDoctorResult(colors, cwdWritable ? "pass" : "fail", "Current directory", cwdWritable ? "Writable" : "Not writable");
+		hasFailures ||= !cwdWritable;
+
+		printDoctorResult(colors, tempWritable ? "pass" : "fail", "Temp directory", tempWritable ? "Writable" : "Not writable");
+		hasFailures ||= !tempWritable;
+
+		for (const template of listTemplates()) {
+			const hasAssets =
+				fs.existsSync(template.templateDir) &&
+				fs.existsSync(path.join(template.templateDir, "package.json.mustache"));
+			printDoctorResult(
+				colors,
+				hasAssets ? "pass" : "fail",
+				`Template ${template.id}`,
+				hasAssets ? template.templateDir : "Missing core template assets",
+			);
+			hasFailures ||= !hasAssets;
+		}
+
+		if (hasFailures) {
+			throw new Error("Doctor found one or more failing checks.");
+		}
+	},
+});
+
+async function main() {
+	const cli = await createCLI({
+		description: packageJson.description,
+		name: packageJson.name,
+		version: packageJson.version,
+	});
+
+	cli.command(scaffoldCommand);
+	cli.command(templatesGroup);
+	cli.command(doctorCommand);
+
+	await cli.run(normalizeRootArgv(process.argv.slice(2)));
+}
+
+main().catch((error: unknown) => {
+	console.error("❌ create-wp-typia failed:", error instanceof Error ? error.message : error);
+	process.exit(1);
+});

package/templates/advanced/README.md.mustache

@@ -0,0 +1,70 @@
+# {{title}}
+
+A WordPress block with **Typia validation** and **Interactivity API** support.
+
+## 🚀 Features
+
+- **✅ Typia Validation**: Type-safe attributes with compile-time and runtime validation
+- **⚡ Interactivity API**: Lightweight frontend interactions
+- **🎯 Auto-Sync**: Types automatically sync to `block.json` and `typia.manifest.json`
+- **🔧 TypeScript**: Full type safety throughout
+
+## 🏗️ Development
+
+```bash
+# Install dependencies
+bun install
+
+# Development with hot reload
+bun run start
+
+# Build for production  
+bun run build
+
+# Type checking
+npx tsc --noEmit
+
+# Sync block metadata manually
+bun run sync-types
+```
+
+## 📝 Type System
+
+Edit `src/types.ts` to define your block attributes:
+
+```typescript
+export interface {{titleCase}}Attributes {
+	content: string & tags.MinLength<1> & tags.Default<"Hello World">;
+	isVisible: boolean & tags.Default<true>;
+	count: number & tags.Minimum<0> & tags.Maximum<100>;
+}
+```
+
+**`block.json` and `typia.manifest.json` will be automatically updated** with these attributes when you run `bun run start` or `bun run build`!
+
+## 🎨 Styling
+
+- `src/style.scss` - Frontend and editor styles
+- Block CSS class: `.wp-block-{{slugKebabCase}}`
+
+## ⚡ Interactivity
+
+Frontend interactions are defined in `src/view.ts`:
+
+```typescript
+const { state, actions } = store('{{namespace}}/{{slug}}', {
+	state: { isActive: false },
+	actions: { toggle() { state.isActive = !state.isActive; } }
+});
+```
+
+## 📦 Generated Files
+
+- `block.json` - WordPress-facing attribute metadata generated from TypeScript types
+- `typia.manifest.json` - Full Typia constraint manifest for future PHP validation
+- `build/` - Compiled JavaScript and CSS
+- `src/types.ts` - **Edit this to change block attributes**
+
+---
+
+*Generated with [@wordpress/create-block](https://developer.wordpress.org/block-editor/reference-guides/packages/packages-create-block/) and Typia validation*

package/templates/advanced/block.json.mustache

@@ -0,0 +1,42 @@
+{
+	"$schema": "https://schemas.wp.org/trunk/block.json",
+	"apiVersion": 3,
+	"name": "{{namespace}}/{{slug}}",
+	"version": "0.1.0",
+	"title": "{{title}}",
+	"category": "{{category}}",
+	"icon": "{{dashicon}}",
+	"description": "{{description}}",
+	"keywords": [
+		"typia",
+		"{{slug}}",
+		"custom"
+	],
+	"example": {
+		"attributes": {
+			"id": "Example id",
+			"version": 1,
+			"className": "Example className",
+			"content": "",
+			"alignment": "left",
+			"isVisible": true
+		}
+	},
+	"supports": {
+		"html": false,
+		"interactivity": {
+			"clientNavigation": true
+		}
+	},
+	"textdomain": "{{textdomain}}",
+	"editorScript": "file:./index.js",
+	"editorStyle": "file:./index.css",
+	"style": "file:./style-index.css",
+	"viewScript": "file:./view.js",
+	"attributes": {
+		"content": {
+			"type": "string",
+			"default": ""
+		}
+	}
+}

package/templates/advanced/index.js

@@ -0,0 +1,21 @@
+const { join } = require( 'path' );
+
+module.exports = {
+	templatesPath: join( __dirname ),
+	defaultValues: {
+		namespace: 'create-block',
+		category: 'widgets',
+		dashicon: 'admin-site-alt3',
+		textdomain: '',
+		editorScript: 'file:./index.js',
+		editorStyle: 'file:./index.css',
+		style: 'file:./style-index.css',
+		viewScript: 'file:./view.js',
+	},
+	variants: {
+		'typia': {
+			title: 'Typia Block',
+			description: 'A WordPress block with Typia validation and Interactivity API',
+		}
+	}
+};

package/templates/advanced/package.json.mustache

@@ -0,0 +1,48 @@
+{
+	"name": "{{slugSnakeCase}}",
+	"version": "0.1.0",
+  "packageManager": "bun@1.3.10",
+	"description": "{{description}}",
+	"author": "{{author}}",
+	"license": "GPL-2.0-or-later",
+	"main": "build/index.js",
+	"scripts": {
+		"sync-types": "tsx scripts/sync-types-to-block-json.ts",
+		"generate-migrations": "tsx scripts/generate-migrations.ts",
+		"prebuild": "bun run sync-types && bun run generate-migrations",
+		"build": "wp-scripts build",
+		"start": "bun run sync-types && bun run generate-migrations && wp-scripts start",
+		"dev": "bun run start",
+		"test-migrations": "tsx -e \"import('./src/deprecated.js').then(m => m.migrationUtils.testMigration())\"",
+		"migration-stats": "tsx -e \"import('./src/deprecated.js').then(m => console.table(m.migrationUtils.getStats()))\"",
+		"migration": "tsx scripts/migration-cli.ts",
+		"migration:detect": "bun run migration detect",
+		"migration:scan": "bun run migration scan",
+		"migration:migrate": "bun run migration migrate",
+		"lint:js": "wp-scripts lint-js",
+		"lint:css": "wp-scripts lint-style",
+		"lint": "bun run lint:js && bun run lint:css",
+		"format": "wp-scripts format"
+	},
+	"devDependencies": {
+		"ajv": "^8.18.0",
+		"@types/wordpress__block-editor": "^11.5.17",
+		"@types/wordpress__blocks": "^12.5.18",
+		"@types/wordpress__components": "^23.8.0",
+		"@wordpress/browserslist-config": "^6.42.0",
+    "@wordpress/scripts": "^30.22.0",
+		"@typia/unplugin": "^12.0.1",
+		"tsx": "^4.20.5",
+		"typescript": "^5.9.2",
+		"typia": "^12.0.1",
+		"commander": "^11.0.0"
+	},
+	"dependencies": {
+		"@wordpress/block-editor": "^15.2.0",
+		"@wordpress/blocks": "^15.2.0",
+		"@wordpress/components": "^30.2.0",
+		"@wordpress/element": "^6.29.0",
+		"@wordpress/i18n": "^6.2.0",
+		"@wordpress/interactivity": "^6.29.0"
+	}
+}