create-zenbu-app 0.0.6 → 0.0.9

package/README.md

@@ -5,9 +5,56 @@ Scaffold a new [Zenbu](https://github.com/zenbu-labs/zenbu.js) app.
 ```bash
 pnpm create zenbu-app my-app
 cd my-app
-pnpm install
 pnpm dev
 ```
 
-Zenbu currently requires pnpm 10+. The bundled .app re-installs from the
-pnpm lockfile at first launch, so the project's lockfile must be a pnpm one.
+## Interactive mode
+
+Run with no arguments to be prompted for a project name and config options:
+
+```bash
+pnpm create zenbu-app
+```
+
+You'll be asked for:
+
+- **Project name** — defaults to `my-zenbu-app` (just press enter to accept).
+- **Use Tailwind CSS?** — defaults to `yes`.
+
+Each prompt's default is selected when you press enter, so a default scaffold
+is just `enter, enter, enter`.
+
+## Flags
+
+| Flag | Description |
+|---|---|
+| `--yes`, `-y` | Skip every prompt and take each option's default. With no project name, scaffolds into the current directory. |
+| `--no-install` | Skip the post-copy `<pm> install` step. |
+
+A few common invocations:
+
+```bash
+pnpm create zenbu-app                  # interactive, then scaffolds ./my-zenbu-app
+pnpm create zenbu-app my-app           # interactive options, scaffolds ./my-app
+pnpm create zenbu-app .                # interactive options, scaffolds into cwd
+pnpm create zenbu-app --yes            # all defaults, scaffolds into cwd
+pnpm create zenbu-app my-app --yes     # all defaults, scaffolds ./my-app
+```
+
+## Templates
+
+The CLI ships full per-config copies of the project under `templates/<slug>/`
+— there are no in-template conditionals. Today:
+
+- `templates/tailwind/` — Tailwind CSS v4 wired up via `@tailwindcss/vite`.
+- `templates/vanilla/` — plain CSS, no utility framework.
+
+The selected slug is computed from the answered config options (Tailwind
+contributes `tailwind`; the empty set falls back to `vanilla`).
+
+## Package manager support
+
+The detected invoking package manager is recorded in `zenbu.config.ts` and
+used for the post-copy install. pnpm, npm, yarn, and bun are all supported,
+but the bundled `.app` re-installs from the project's lockfile at first
+launch — so currently the lockfile must be a pnpm one.

package/dist/index.mjs

@@ -3,15 +3,85 @@ import path from "node:path";
 import fs from "node:fs";
 import { fileURLToPath } from "node:url";
 import { spawnSync } from "node:child_process";
+import * as p from "@clack/prompts";
 //#region src/index.ts
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const TEMPLATE_DIR = path.resolve(__dirname, "..", "template");
-const argv = process.argv.slice(2);
-const flagsSet = new Set(argv.filter((a) => a.startsWith("-")));
-const positional = argv.filter((a) => !a.startsWith("-"));
+const TEMPLATES_DIR = path.resolve(__dirname, "..", "templates");
+const rawArgv = process.argv.slice(2);
+const flagsSet = /* @__PURE__ */ new Set();
+const positional = [];
+const dependsOn = [];
+/**
+* Parse flags. `--depends-on NAME=PATH` is consumed positionally because it
+* carries a value; everything else is a boolean flag or a positional arg.
+*/
+for (let i = 0; i < rawArgv.length; i++) {
+	const arg = rawArgv[i];
+	if (arg === "--depends-on" || arg === "--dependsOn") {
+		const value = rawArgv[++i];
+		if (!value) {
+			console.error("create-zenbu-app: --depends-on requires NAME=PATH");
+			process.exit(1);
+		}
+		dependsOn.push(parseDependsOn(value));
+	} else if (arg.startsWith("--depends-on=") || arg.startsWith("--dependsOn=")) dependsOn.push(parseDependsOn(arg.slice(arg.indexOf("=") + 1)));
+	else if (arg.startsWith("-")) flagsSet.add(arg);
+	else positional.push(arg);
+}
 const yes = flagsSet.has("--yes") || flagsSet.has("-y");
 const noInstall = flagsSet.has("--no-install");
+const noGit = flagsSet.has("--no-git");
+const pluginMode = flagsSet.has("--plugin");
+const noAddToHost = flagsSet.has("--no-add-to-host");
+if (dependsOn.length > 0 && !pluginMode) {
+	console.error("create-zenbu-app: --depends-on is only valid with --plugin");
+	process.exit(1);
+}
+function parseDependsOn(raw) {
+	const eq = raw.indexOf("=");
+	if (eq < 0) {
+		console.error(`create-zenbu-app: --depends-on must be of the form NAME=PATH (got "${raw}")`);
+		process.exit(1);
+	}
+	const name = raw.slice(0, eq).trim();
+	const rel = raw.slice(eq + 1).trim();
+	if (!name) {
+		console.error("create-zenbu-app: --depends-on NAME may not be empty");
+		process.exit(1);
+	}
+	if (!rel) {
+		console.error("create-zenbu-app: --depends-on PATH may not be empty");
+		process.exit(1);
+	}
+	const abs = path.isAbsolute(rel) ? rel : path.resolve(process.cwd(), rel);
+	if (!fs.existsSync(abs)) {
+		console.error(`create-zenbu-app: --depends-on path does not exist: ${abs}`);
+		process.exit(1);
+	}
+	return {
+		name,
+		from: abs
+	};
+}
 const ZENBU_LOCAL_CORE = process.env.ZENBU_LOCAL_CORE;
+const CONFIG_OPTIONS = [{
+	id: "tailwind",
+	default: true,
+	ask: () => p.confirm({
+		message: "Use Tailwind CSS?",
+		initialValue: true
+	}),
+	slug: (v) => v ? "tailwind" : null
+}];
+function resolveSlug(answers) {
+	const parts = [];
+	for (const opt of CONFIG_OPTIONS) {
+		const value = answers[opt.id];
+		const fragment = opt.slug(value);
+		if (fragment) parts.push(fragment);
+	}
+	return parts.length > 0 ? parts.join("-") : "vanilla";
+}
 /**
 * Detect the PM that invoked `create-zenbu-app`. Order:
 *   1. `process.versions.bun` → bun (covers `bunx create-zenbu-app`).
@@ -68,22 +138,61 @@ function probeVersion(pm) {
 	const match = (res.stdout ?? "").trim().match(/\d+\.\d+\.\d+(?:[-+][\w.]+)?/);
 	return match ? match[0] : null;
 }
-function renderTemplate(value, projectName) {
-	return value.replace(/\{\{projectName\}\}/g, projectName);
+function renderTemplate(value, ctx) {
+	return value.replace(/\{\{(\w+)\}\}/g, (full, key) => {
+		return Object.prototype.hasOwnProperty.call(ctx, key) ? ctx[key] : full;
+	});
 }
-function copyDirSync(src, dest, projectName) {
+/**
+* Copy a template directory tree to `dest`. Both file *contents* and
+* file/directory *names* go through `renderTemplate`, so a template can
+* place a file at e.g. `src/main/services/{{projectName}}.ts.tmpl` and have
+* it land at `src/main/services/<projectName>.ts`. `.tmpl` is stripped.
+*/
+function copyDirSync(src, dest, ctx) {
 	fs.mkdirSync(dest, { recursive: true });
 	for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
 		const srcPath = path.join(src, entry.name);
-		const destName = entry.name.endsWith(".tmpl") ? entry.name.slice(0, -5) : entry.name;
+		let destName = entry.name.endsWith(".tmpl") ? entry.name.slice(0, -5) : entry.name;
+		destName = renderTemplate(destName, ctx);
 		const destPath = path.join(dest, destName);
-		if (entry.isDirectory()) copyDirSync(srcPath, destPath, projectName);
+		if (entry.isDirectory()) copyDirSync(srcPath, destPath, ctx);
 		else {
 			const content = fs.readFileSync(srcPath, "utf8");
-			fs.writeFileSync(destPath, renderTemplate(content, projectName));
+			fs.writeFileSync(destPath, renderTemplate(content, ctx));
 		}
 	}
 }
+function toPascalCase(s) {
+	return s.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function relPosix(fromDir, toFile) {
+	let r = path.relative(fromDir, toFile).split(path.sep).join("/");
+	if (!r.startsWith(".")) r = "./" + r;
+	return r;
+}
+/**
+* Render a plugin's `dependsOn` literal for the scaffolded `zenbu.plugin.ts`.
+* Returns either an empty string (no deps → field omitted) or a leading-`\n`
+* fragment that slots in after the `services:` line, e.g.
+*
+*   \n  dependsOn: [\n    { name: "app", from: "../../zenbu.config.ts" },\n  ],
+*
+* Each `from` is rewritten relative to `pluginDir` so the generated file is
+* stable across moves of the surrounding workspace.
+*/
+function renderDependsOn(pluginDir, deps) {
+	if (deps.length === 0) return "";
+	const lines = [];
+	lines.push("");
+	lines.push("  dependsOn: [");
+	for (const d of deps) {
+		const fromRel = relPosix(pluginDir, d.from);
+		lines.push(`    { name: ${JSON.stringify(d.name)}, from: ${JSON.stringify(fromRel)} },`);
+	}
+	lines.push("  ],");
+	return lines.join("\n");
+}
 /**
 * Replace the `// {{packageManager}}` marker in the scaffolded
 * `zenbu.config.ts` with a real `packageManager: { ... }` line. Idempotent
@@ -97,13 +206,29 @@ function seedPackageManager(projectDir, pm) {
 	const replaced = original.replace(/\/\/\s*\{\{packageManager\}\}/, literal);
 	if (replaced !== original) fs.writeFileSync(configPath, replaced);
 }
-function rewireToLocalCore(projectDir, corePath) {
+/**
+* Pin `@zenbujs/core` to a local checkout. For apps the dep lives in
+* `dependencies`; for plugins it's in `devDependencies` (plugins peer on
+* core).
+*/
+function rewireToLocalCore(projectDir, corePath, isPlugin) {
 	const pkgPath = path.join(projectDir, "package.json");
 	const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-	pkg.dependencies = pkg.dependencies ?? {};
-	pkg.dependencies["@zenbujs/core"] = `link:${corePath}`;
+	const bucket = isPlugin ? "devDependencies" : "dependencies";
+	pkg[bucket] = pkg[bucket] ?? {};
+	pkg[bucket]["@zenbujs/core"] = `link:${corePath}`;
 	fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
 }
+/** Walk upward from `fromDir` looking for an ancestor with a `.git` dir. */
+function findGitRoot(fromDir) {
+	let dir = path.resolve(fromDir);
+	while (true) {
+		if (fs.existsSync(path.join(dir, ".git"))) return dir;
+		const parent = path.dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
 function gitInitWithInitialCommit(projectDir) {
 	if (spawnSync("git", [
 		"init",
@@ -133,6 +258,66 @@ function gitInitWithInitialCommit(projectDir) {
 		}
 	});
 }
+function appendPluginToHostConfig(hostConfigPath, entry) {
+	if (!fs.existsSync(hostConfigPath)) return "missing-file";
+	const raw = fs.readFileSync(hostConfigPath, "utf8");
+	const pluginsMatch = raw.match(/\bplugins\s*:\s*\[/);
+	if (!pluginsMatch) return "unsafe-shape";
+	const openIdx = pluginsMatch.index + pluginsMatch[0].length - 1;
+	let depth = 1;
+	let i = openIdx + 1;
+	while (i < raw.length && depth > 0) {
+		const ch = raw[i];
+		if (ch === "\"" || ch === "'" || ch === "`") {
+			const quote = ch;
+			i++;
+			while (i < raw.length && raw[i] !== quote) {
+				if (raw[i] === "\\") i++;
+				i++;
+			}
+			i++;
+			continue;
+		}
+		if (ch === "/" && raw[i + 1] === "/") {
+			while (i < raw.length && raw[i] !== "\n") i++;
+			continue;
+		}
+		if (ch === "/" && raw[i + 1] === "*") {
+			i += 2;
+			while (i < raw.length - 1 && !(raw[i] === "*" && raw[i + 1] === "/")) i++;
+			i += 2;
+			continue;
+		}
+		if (ch === "[") depth++;
+		else if (ch === "]") depth--;
+		i++;
+	}
+	if (depth !== 0) return "unsafe-shape";
+	const closeIdx = i - 1;
+	const arrayBody = raw.slice(openIdx + 1, closeIdx);
+	if (/\.\.\./.test(arrayBody)) return "unsafe-shape";
+	if (arrayBody.includes(JSON.stringify(entry))) return "already-present";
+	const lines = arrayBody.split("\n");
+	let indent = "    ";
+	for (const line of lines) {
+		if (line.trim().length === 0) continue;
+		const m = line.match(/^[ \t]+/);
+		if (m) {
+			indent = m[0];
+			break;
+		}
+	}
+	const beforeClose = raw.slice(0, closeIdx);
+	const lastLineStart = beforeClose.lastIndexOf("\n") + 1;
+	const closeLineIndent = beforeClose.slice(lastLineStart).match(/^[ \t]*/)[0];
+	let head = raw.slice(0, closeIdx).replace(/\s*$/, "");
+	if (head.length > 0 && !head.endsWith(",") && !head.endsWith("[")) head += ",";
+	const insertion = `\n${indent}${JSON.stringify(entry)},\n${closeLineIndent}`;
+	const next = head + insertion + raw.slice(closeIdx);
+	if (next === raw) return "already-present";
+	fs.writeFileSync(hostConfigPath, next);
+	return "added";
+}
 /**
 * Run `<pm> install` in the freshly-scaffolded project so the user can go
 * straight to `pnpm dev`/`bun dev`/etc. without the extra step. We run with
@@ -146,52 +331,176 @@ function runInstall(projectDir, pm) {
 		stdio: "inherit"
 	}).status === 0;
 }
-function main() {
-	const projectName = positional[0] ?? ".";
-	if (projectName === "." && !yes) {
-		console.error("Usage: npm create zenbu-app <project-name>\n       (use --yes to scaffold into the current directory)");
-		process.exit(1);
+/** Run `<pm> exec zen link [extraArgs...]` in `cwd`. */
+function runZenLink(cwd, pm, extraArgs = []) {
+	const args = [
+		"exec",
+		"zen",
+		"link",
+		...extraArgs
+	];
+	return spawnSync(pm.type === "yarn" && pm.version.startsWith("1.") ? pm.type : pm.type, pm.type === "yarn" && pm.version.startsWith("1.") ? [
+		"zen",
+		"link",
+		...extraArgs
+	] : args, {
+		cwd,
+		stdio: "inherit"
+	}).status === 0;
+}
+function bail(reason) {
+	p.cancel(reason);
+	process.exit(1);
+}
+function validateProjectName(value) {
+	const trimmed = (value ?? "").trim();
+	if (!trimmed) return "Project name is required.";
+	if (trimmed === ".") return void 0;
+	if (/[\\/]/.test(trimmed)) return "Project name cannot contain slashes.";
+	if (/\s/.test(trimmed)) return "Project name cannot contain whitespace.";
+	if (/^[._]/.test(trimmed)) return "Project name cannot start with '.' or '_'.";
+}
+async function promptProjectName() {
+	const result = await p.text({
+		message: "Project name?",
+		placeholder: "my-zenbu-app",
+		defaultValue: "my-zenbu-app",
+		validate: validateProjectName
+	});
+	if (p.isCancel(result)) bail("Scaffolding cancelled.");
+	return result;
+}
+async function promptOptions() {
+	const answers = {};
+	for (const opt of CONFIG_OPTIONS) {
+		const value = await opt.ask();
+		if (p.isCancel(value)) bail("Scaffolding cancelled.");
+		answers[opt.id] = value;
 	}
+	return answers;
+}
+function defaultAnswers() {
+	const answers = {};
+	for (const opt of CONFIG_OPTIONS) answers[opt.id] = opt.default;
+	return answers;
+}
+async function main() {
+	p.intro(pluginMode ? "create-zenbu-app (plugin)" : "create-zenbu-app");
+	let projectName;
+	if (positional[0]) projectName = positional[0];
+	else if (yes) projectName = ".";
+	else projectName = await promptProjectName();
 	const projectDir = path.resolve(process.cwd(), projectName);
 	const displayName = path.basename(projectDir);
 	if (fs.existsSync(projectDir)) {
 		const entries = fs.readdirSync(projectDir).filter((e) => e !== ".git");
-		const allowedExisting = projectName === "." && fs.existsSync(path.join(projectDir, "package.json"));
-		if (entries.length > 0 && !allowedExisting) {
-			console.error(`Error: directory "${projectName}" already exists and is not empty.`);
-			process.exit(1);
-		}
+		const allowedExisting = (projectName === "." || projectDir === process.cwd()) && fs.existsSync(path.join(projectDir, "package.json"));
+		if (entries.length > 0 && !allowedExisting) bail(`Directory "${projectName}" already exists and is not empty.`);
 	}
+	let templateDir;
+	let slug;
+	if (pluginMode) {
+		slug = "plugin";
+		templateDir = path.join(TEMPLATES_DIR, "plugin");
+	} else {
+		slug = resolveSlug(yes ? defaultAnswers() : await promptOptions());
+		templateDir = path.join(TEMPLATES_DIR, slug);
+	}
+	if (!fs.existsSync(templateDir)) bail(`No template found for configuration "${slug}".`);
 	const pm = detectPackageManager();
-	console.log(`\nScaffolding Zenbu app in "${displayName}"...`);
-	if (pm.fallback) console.log(`  → couldn't detect invoking package manager; defaulting to ${pm.type}@${pm.version}.`);
-	else console.log(`  → detected ${pm.type}@${pm.version} as the invoking package manager`);
-	console.log("");
-	copyDirSync(TEMPLATE_DIR, projectDir, displayName);
+	p.log.step(`Scaffolding Zenbu ${pluginMode ? "plugin" : "app"} in "${displayName}" (template: ${slug})`);
+	if (pm.fallback) p.log.info(`couldn't detect invoking package manager; defaulting to ${pm.type}@${pm.version}.`);
+	else p.log.info(`detected ${pm.type}@${pm.version} as the invoking package manager`);
+	const ctx = pluginMode ? {
+		projectName: displayName,
+		className: toPascalCase(displayName),
+		dependsOn: renderDependsOn(projectDir, dependsOn)
+	} : { projectName: displayName };
+	copyDirSync(templateDir, projectDir, ctx);
 	const gi = path.join(projectDir, "_gitignore");
 	if (fs.existsSync(gi)) fs.renameSync(gi, path.join(projectDir, ".gitignore"));
-	seedPackageManager(projectDir, pm);
+	if (!pluginMode) seedPackageManager(projectDir, pm);
 	if (ZENBU_LOCAL_CORE) {
 		const corePath = path.resolve(ZENBU_LOCAL_CORE);
-		rewireToLocalCore(projectDir, corePath);
-		console.log(`  → linked @zenbujs/core -> ${corePath}`);
+		rewireToLocalCore(projectDir, corePath, pluginMode);
+		p.log.info(`linked @zenbujs/core -> ${corePath}`);
 	}
 	let installed = false;
 	if (!noInstall) {
-		console.log(`  → running ${pm.type} install\n`);
+		p.log.step(`running ${pm.type} install`);
 		installed = runInstall(projectDir, pm);
-		if (!installed) console.warn(`  → ${pm.type} install failed; you can retry manually after the scaffold completes.\n`);
+		if (!installed) p.log.warn(`${pm.type} install failed; you can retry manually after the scaffold completes.`);
+	}
+	const hostsToLink = /* @__PURE__ */ new Set();
+	if (pluginMode && !noAddToHost) for (const dep of dependsOn) {
+		if (!path.basename(dep.from).startsWith("zenbu.config.")) continue;
+		const hostDir = path.dirname(dep.from);
+		const pluginManifestRel = relPosix(hostDir, path.join(projectDir, "zenbu.plugin.ts"));
+		let accept = yes;
+		if (!yes) {
+			const result = await p.confirm({
+				message: `Add "${pluginManifestRel}" to ${path.relative(process.cwd(), dep.from) || dep.from} plugins:?`,
+				initialValue: true
+			});
+			if (p.isCancel(result)) bail("Scaffolding cancelled.");
+			accept = !!result;
+		}
+		if (!accept) continue;
+		switch (appendPluginToHostConfig(dep.from, pluginManifestRel)) {
+			case "added":
+				p.log.success(`wired into ${dep.from}`);
+				hostsToLink.add(hostDir);
+				break;
+			case "already-present":
+				p.log.info(`already listed in ${dep.from}`);
+				hostsToLink.add(hostDir);
+				break;
+			case "missing-file":
+				p.log.warn(`host config not found: ${dep.from}`);
+				break;
+			case "unsafe-shape":
+				p.log.warn(`${dep.from}: couldn't safely edit plugins:[]. Add this manually:\n    ${JSON.stringify(pluginManifestRel)},`);
+				break;
+		}
+	}
+	if (installed) if (pluginMode) if (hostsToLink.size > 0) for (const hostDir of hostsToLink) {
+		p.log.step(`running zen link in ${hostDir}`);
+		if (!runZenLink(hostDir, pm)) p.log.warn(`zen link failed in ${hostDir}`);
+	}
+	else {
+		p.log.step(`running zen link --plugin .`);
+		if (!runZenLink(projectDir, pm, ["--plugin", "."])) p.log.warn(`zen link --plugin . failed`);
+	}
+	else {
+		p.log.step(`running ${pm.type} run link`);
+		if (spawnSync(pm.type, ["run", "link"], {
+			cwd: projectDir,
+			stdio: "inherit"
+		}).status !== 0) p.log.warn(`${pm.type} run link failed; you can retry manually after the scaffold completes.`);
+	}
+	if (!noGit) {
+		const ancestorRepo = findGitRoot(projectDir);
+		if (ancestorRepo) p.log.info(`inside existing repo at ${ancestorRepo} — skipping git init`);
+		else {
+			let doInit = yes;
+			if (!yes) {
+				const result = await p.confirm({
+					message: "Initialize a git repo here?",
+					initialValue: true
+				});
+				if (p.isCancel(result)) bail("Scaffolding cancelled.");
+				doInit = !!result;
+			}
+			if (doInit) gitInitWithInitialCommit(projectDir);
+		}
 	}
-	if (!fs.existsSync(path.join(projectDir, ".git"))) gitInitWithInitialCommit(projectDir);
 	const cdHint = projectName === "." ? "" : `cd ${displayName} && `;
-	if (installed) console.log(`Done. Next:\n\n  ${cdHint}${pm.type} dev\n`);
-	else console.log(`Done. Next:\n\n  ${cdHint}${pm.type} install\n  ${pm.type} dev\n`);
+	const next = pluginMode ? installed ? `${cdHint}${pm.type} run typecheck` : `${cdHint}${pm.type} install` : installed ? `${cdHint}${pm.type} dev` : `${cdHint}${pm.type} install\n  ${cdHint}${pm.type} dev`;
+	p.outro(`Done. Next:\n\n  ${next}\n`);
 }
-try {
-	main();
-} catch (err) {
+main().catch((err) => {
 	console.error("\nError:", err?.message ?? err);
 	process.exit(1);
-}
+});
 //#endregion
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-zenbu-app",
-  "version": "0.0.6",
+  "version": "0.0.9",
   "description": "Scaffold a new Zenbu app",
   "type": "module",
   "publishConfig": {
@@ -11,7 +11,7 @@
   },
   "files": [
     "dist/",
-    "template/"
+    "templates/"
   ],
   "keywords": [
     "zenbu",
@@ -29,6 +29,9 @@
     "tsdown": "^0.21.10",
     "typescript": "^5.0.0"
   },
+  "dependencies": {
+    "@clack/prompts": "^1.3.0"
+  },
   "scripts": {
     "build": "tsdown",
     "typecheck": "tsc --noEmit -p tsconfig.json"

package/templates/plugin/_gitignore

@@ -0,0 +1,3 @@
+node_modules/
+dist/
+.zenbu/

package/templates/plugin/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "{{projectName}}",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "link": "zen link --plugin .",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "peerDependencies": {
+    "@zenbujs/core": "*",
+    "react": ">=18",
+    "react-dom": ">=18"
+  },
+  "devDependencies": {
+    "@zenbujs/core": "^0.0.13",
+    "@types/node": "^22.0.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "typescript": "^5.4.5"
+  }
+}

package/templates/plugin/src/main/services/{{projectName}}.ts.tmpl

@@ -0,0 +1,9 @@
+import { Service } from "@zenbujs/core/runtime"
+
+export class {{className}}Service extends Service.create({
+  key: "{{projectName}}",
+}) {
+  evaluate() {
+    // Plugin starts here.
+  }
+}

package/templates/plugin/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "types": ["node"]
+  },
+  "include": ["src"]
+}

package/templates/plugin/zenbu.plugin.ts.tmpl

@@ -0,0 +1,6 @@
+import { definePlugin } from "@zenbujs/core/config"
+
+export default definePlugin({
+  name: "{{projectName}}",
+  services: ["./src/main/services/*.ts"],{{dependsOn}}
+})

package/{template → templates/tailwind}/package.json

@@ -12,7 +12,7 @@
     "db:generate": "zen db generate"
   },
   "dependencies": {
-    "@zenbujs/core": "^0.0.9",
+    "@zenbujs/core": "^0.0.13",
     "@tailwindcss/vite": "^4.2.0",
     "@vitejs/plugin-react": "^5.0.0",
     "react": "^19.0.0",

package/templates/tailwind/src/main/schema.ts.tmpl

@@ -0,0 +1,13 @@
+import { createSchema, z } from "@zenbujs/core/db"
+
+export default createSchema({
+  issues: z
+    .array(
+      z.object({
+        id: z.string(),
+        title: z.string(),
+        createdAt: z.number(),
+      }),
+    )
+    .default([]),
+})

package/{template/src/main/services/app.ts.tmpl → templates/tailwind/src/main/services/init.ts.tmpl}

@@ -1,11 +1,11 @@
 import { Service } from "@zenbujs/core/runtime"
 import { WindowService } from "@zenbujs/core/services"
 
-export class AppService extends Service.create({
-  key: "app",
+export class InitService extends Service.create({
+  key: "init",
   deps: { window: WindowService },
 }) {
   async evaluate() {
-    await this.ctx.window.openView({ type: "app" })
+    await this.ctx.window.openView({ type: "entrypoint" })
   }
 }