kizlo 0.6.1 → 0.8.0

package/dist/cli/commands/create.js

@@ -0,0 +1,146 @@
+import { dockerAvailable } from "../wp/docker.js";
+import { detectPackageManager, getVersion } from "../utils.js";
+import { printBanner } from "../banner.js";
+import { getPreset } from "../presets/index.js";
+import { collectConnectionInteractively, nextStepsNote, orCancel, setupLocalWordPress, syncRemote, validate, withApiPath, writeEnv } from "./_setup.js";
+import z from "zod/v4";
+import path from "node:path";
+import fs from "node:fs";
+import { defineCommand } from "citty";
+import * as p from "@clack/prompts";
+import { downloadTemplate } from "giget";
+
+//#region src/cli/commands/create.ts
+/** GitHub repo the full templates are fetched from, matching the release-tag scheme. */
+const TEMPLATE_REPO = "github:kizlo-io/kizlo";
+/**
+* The templates `create` can scaffold from. Each id is both the `templates/<id>` folder and the
+* preset that drives its WordPress setup. When only one exists the template prompt auto-selects it.
+*/
+const TEMPLATES = ["nextjs"];
+function isTemplate(value) {
+	return TEMPLATES.includes(value);
+}
+const projectName = validate(z.string().trim().min(1, "Required").refine((value) => !value.startsWith(".") && !value.includes("/") && !value.includes("\\"), "Enter a folder name (letters, numbers, dashes)"));
+/**
+* Resolve where the template is fetched from. Defaults to the GitHub repo pinned to the release
+* tag matching this CLI version (`kizlo-v<version>`), so the template and the `kizlo` dependency it
+* pulls come from the same release. `KIZLO_TEMPLATE_REF` overrides the ref (e.g. `main`) and
+* `KIZLO_TEMPLATE_LOCAL_DIR` points at a local `templates/` directory for pre-release development.
+*/
+function templateSource(template) {
+	const localDir = process.env.KIZLO_TEMPLATE_LOCAL_DIR;
+	if (localDir) return { local: path.resolve(localDir, template) };
+	return { remote: `${TEMPLATE_REPO}/templates/${template}#${process.env.KIZLO_TEMPLATE_REF ?? `kizlo-v${getVersion()}`}` };
+}
+/**
+* Copy the template into `dir`, then make it a standalone project: rewrite the `workspace:*` Kizlo
+* dependency to this CLI's version and name the package after the project folder. The template's
+* `kizlo.template.json` is an internal build input, so it's removed once the copy lands.
+*/
+async function scaffoldTemplate(template, dir, name) {
+	const source = templateSource(template);
+	if (source.local) {
+		if (!fs.existsSync(source.local)) throw new Error(`Local template not found: ${source.local}`);
+		fs.cpSync(source.local, dir, { recursive: true });
+	} else await downloadTemplate(source.remote, {
+		dir,
+		forceClean: true
+	});
+	fs.rmSync(path.join(dir, "kizlo.template.json"), { force: true });
+	const pkgPath = path.join(dir, "package.json");
+	const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+	pkg.name = name;
+	if (pkg.dependencies?.kizlo === "workspace:*") pkg.dependencies.kizlo = `^${getVersion()}`;
+	fs.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, "	")}\n`);
+}
+const create = defineCommand({
+	meta: {
+		name: "create",
+		description: "Scaffold a new project with Kizlo already wired"
+	},
+	args: {
+		template: {
+			type: "positional",
+			required: false,
+			description: `Template to scaffold from (${TEMPLATES.join(", ")})`
+		},
+		name: {
+			type: "positional",
+			required: false,
+			description: "Project folder to create"
+		}
+	},
+	async run({ args }) {
+		const cwd = process.cwd();
+		printBanner(getVersion());
+		p.intro("kizlo create");
+		const requested = args.template;
+		let template;
+		if (requested) {
+			if (!isTemplate(requested)) {
+				p.cancel(`Unknown template "${requested}". Available: ${TEMPLATES.join(", ")}`);
+				process.exit(1);
+			}
+			template = requested;
+		} else if (TEMPLATES.length === 1) template = TEMPLATES[0];
+		else template = orCancel(await p.select({
+			message: "Template",
+			options: TEMPLATES.map((id) => ({
+				value: id,
+				label: id
+			}))
+		}));
+		const name = args.name ? String(args.name).trim() : orCancel(await p.text({
+			message: "Project name",
+			placeholder: "my-app",
+			validate: projectName
+		}));
+		if (!args.name) {
+			const check = projectName(name);
+			if (check) {
+				p.cancel(check);
+				process.exit(1);
+			}
+		}
+		const dir = path.resolve(cwd, name);
+		if (fs.existsSync(dir)) {
+			p.cancel(`${name} already exists — pick a different name or remove it.`);
+			process.exit(1);
+		}
+		const preset = getPreset(template);
+		if (!preset) {
+			p.cancel(`No preset for template "${template}".`);
+			process.exit(1);
+		}
+		const conn = await collectConnectionInteractively(preset);
+		if (preset.apiPath && conn.baseUrl) conn.baseUrl = withApiPath(conn.baseUrl, preset.apiPath);
+		if (conn.mode === "local" && !await dockerAvailable()) {
+			p.cancel("Docker isn't available — start Docker (or install it) and re-run, or choose “Use my own WordPress”.");
+			process.exit(1);
+		}
+		const s = p.spinner();
+		s.start(`Creating ${name} from the ${template} template`);
+		try {
+			await scaffoldTemplate(template, dir, name);
+			s.stop(`Created ${name}`);
+		} catch (error) {
+			s.stop("Could not create the project");
+			p.cancel(error instanceof Error ? error.message : String(error));
+			process.exit(1);
+		}
+		await setupLocalWordPress(dir, conn);
+		await writeEnv(dir, preset, conn, {
+			force: true,
+			yes: false
+		});
+		await syncRemote(conn);
+		const pm = detectPackageManager(dir);
+		p.note([`cd ${name}`, `${pm} install`].join("\n"), "Get started");
+		nextStepsNote(conn.mode);
+		p.outro("Kizlo is ready 🎉");
+	}
+});
+
+//#endregion
+export { create };

package/dist/cli/commands/dev.js

@@ -2,16 +2,15 @@ import { createStack } from "../wp/docker.js";
 import { ensureGitignored, envGroups, getVersion, groupDefault, mergeEnv, pickStackPort, withSpinner } from "../utils.js";
 import { palette, printBanner } from "../banner.js";
 import { resolveDevConfig } from "../daemon/config.js";
-import { startWatcher } from "../daemon/watch.js";
 import { bootstrapDev } from "../wp/dev.js";
 import { reapOrphans, registerSession, removeProjectContainers, spawnWatchdog, unregisterSession } from "../wp/session.js";
 import { syncSiteSettings } from "../wp/settings.js";
 import { devStack } from "../wp/stack.js";
+import { startWatcher } from "../daemon/watch.js";
 import { join } from "node:path";
 import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { defineCommand } from "citty";
 import { randomBytes } from "node:crypto";
-import { networkInterfaces } from "node:os";
 
 //#region src/cli/commands/dev.ts
 async function resolve$1(cwd) {
@@ -26,22 +25,17 @@ function note(text) {
 	const { dim, reset } = palette();
 	process.stdout.write(`   ${dim}${text}${reset}\n`);
 }
-/** First non-internal IPv4 address, for the LAN-reachable "Network" URL (undefined when offline). */
-function lanAddress() {
-	for (const ifaces of Object.values(networkInterfaces())) for (const iface of ifaces ?? []) if (iface.family === "IPv4" && !iface.internal) return iface.address;
-}
 /**
-* Print the connection summary as an aligned, Next.js-style block. Shows the wp-admin
-* URL on localhost ("Local") and — when a LAN address exists — on the network, so the
-* stack can be opened from other devices. On a fresh install, also show the one-time
-* wp-admin password (it's never stored, so this is the only chance to see it).
+* Print the connection summary as an aligned, Next.js-style block. Shows the wp-admin URL on
+* the loopback ("Local") and — when the stack is installed on a LAN address rather than
+* localhost — on the network, so it can be opened from other devices. On a fresh install, also
+* show the one-time wp-admin password (it's never stored, so this is the only chance to see it).
 */
 function printSummary(info) {
 	const { cyan, dim, reset } = palette();
-	const port = new URL(info.url).port;
-	const lan = lanAddress();
-	const rows = [["WP Local", `${info.url}/wp-admin`]];
-	if (lan) rows.push(["WP Network", `http://${lan}:${port}/wp-admin`]);
+	const { port, hostname } = new URL(info.url);
+	const rows = [["WP Local", `http://localhost:${port}/wp-admin`]];
+	if (hostname !== "localhost") rows.push(["WP Network", `${info.url}/wp-admin`]);
 	rows.push(["Database Connection", `127.0.0.1:${info.dbPort}`]);
 	const width = Math.max(...rows.map(([label]) => label.length)) + 1;
 	const lines = ["", ...rows.map(([label, value]) => `   ${dim}- ${`${label}:`.padEnd(width)}${reset} ${cyan}${value}${reset}`)];
@@ -104,6 +98,23 @@ function updateWpEnv(cfg, info) {
 	};
 }
 /**
+* Re-point `KIZLO_DEV_WORDPRESS_URL` at the current dev URL on a warm resume, so a LAN address that
+* changed since the last session (a new DHCP lease, a different network) doesn't leave the app talking
+* to a dead IP. Only this one key is rewritten — the credentials and secret from the fresh install are
+* preserved — and it's a no-op when `.env` is absent (nothing provisioned yet) or already current.
+* The full fresh-install write goes through {@link updateWpEnv} instead; this covers the resume path it
+* skips. Returns true when it changed the file. The app still needs a restart to read the new value.
+*/
+function syncDevUrl(cfg, url) {
+	const envPath = join(cfg.configDir, ".env");
+	if (!existsSync(envPath)) return false;
+	const existing = readFileSync(envPath, "utf8");
+	if (readEnvValue(existing, "KIZLO_DEV_WORDPRESS_URL") === url) return false;
+	const { content } = mergeEnv(existing, { KIZLO_DEV_WORDPRESS_URL: url }, new Set(["KIZLO_DEV_WORDPRESS_URL"]), envGroups("KIZLO_BACKEND_URL"));
+	writeFileSync(envPath, content);
+	return true;
+}
+/**
 * Arm the foreground teardown — call this *before* the containers start, so a cancel at
 * any point (even mid-startup, with mysql up but wordpress still booting) stops whatever
 * already came up. The teardown is owned by a detached **watchdog** process, not by this
@@ -189,7 +200,7 @@ async function startForeground(cfg) {
 			});
 			if (!sync.ok) note(`Could not sync the site settings to WordPress (${sync.error}) — make sure the kizlo plugin is active, then set them from the Kizlo settings.`);
 		}
-	}
+	} else if (syncDevUrl(ready, creds.url)) note("Updated .env WordPress URL to the current network address — restart your app to pick it up");
 	printSummary(creds);
 	const { green, dim, bold, reset } = palette();
 	const ms = Date.now() - start;

package/dist/cli/commands/init.js

@@ -1,65 +1,16 @@
-import { composeStop, createStack, dockerAvailable } from "../wp/docker.js";
-import { addDependencyArgs, detectImportAlias, detectPackageManager, ensureGitignored, envGroups, envKeysPresent, getVersion, loadEnvFiles, mergeEnv, pickStackPort, resolveModuleImport, runCommand, writeFileIfAbsent } from "../utils.js";
+import { dockerAvailable } from "../wp/docker.js";
+import { addDependencyArgs, detectImportAlias, detectPackageManager, ensureGitignored, getVersion, loadEnvFiles, resolveModuleImport, runCommand, writeFileIfAbsent } from "../utils.js";
 import { printBanner } from "../banner.js";
-import { DEFAULT_DEV_DB_PORT, DEFAULT_DEV_PORT, resolveStackName } from "../daemon/config.js";
-import { CONTRACT_BARREL } from "../daemon/generate.js";
-import { createAdminAppPassword } from "../wp/bootstrap.js";
-import { bootstrapDev } from "../wp/dev.js";
-import { removeProjectContainers } from "../wp/session.js";
-import { syncSiteSettings } from "../wp/settings.js";
-import { devStack } from "../wp/stack.js";
 import { PRESETS, detectPreset, getPreset } from "../presets/index.js";
-import z from "zod/v4";
+import { collectConnectionFromEnv, collectConnectionInteractively, dirPath, nextStepsNote, orCancel, setupLocalWordPress, syncRemote, validate, withApiPath, writeEnv } from "./_setup.js";
+import { CONTRACT_BARREL } from "../daemon/generate.js";
+import { applyPatchToSource, patchChanged, resolvePatch, resolvePatchTargetPath, templatePatches } from "../presets/patch.js";
 import path from "node:path";
 import fs from "node:fs";
 import { defineCommand } from "citty";
 import * as p from "@clack/prompts";
-import { randomBytes } from "node:crypto";
 
 //#region src/cli/commands/init.ts
-/** Production connection keys — what a real deploy needs, and what `.env.example` always lists. */
-const PROD_WP_ENV_KEYS = [
-	"KIZLO_SITE_SECRET",
-	"KIZLO_WORDPRESS_URL",
-	"KIZLO_WORDPRESS_USERNAME",
-	"KIZLO_WORDPRESS_APPLICATION_PASSWORD"
-];
-/**
-* The `.env` keys init manages and the values to write, branched on the connection mode. A local
-* dev stack writes the `KIZLO_DEV_WORDPRESS_*` / `KIZLO_DEV_SITE_SECRET` set plus `KIZLO_TARGET=dev`, so it
-* never touches the production keys (a user can point those at a real site). A remote site writes the
-* bare production keys exactly as before — no `KIZLO_TARGET`, since `"production"` is the default target.
-*/
-function managedEnv(preset, setup) {
-	if (setup.mode === "local") return {
-		keys: [
-			preset.baseUrlEnvKey,
-			"KIZLO_TARGET",
-			"KIZLO_DEV_SITE_SECRET",
-			"KIZLO_DEV_WORDPRESS_URL",
-			"KIZLO_DEV_WORDPRESS_USERNAME",
-			"KIZLO_DEV_WORDPRESS_APPLICATION_PASSWORD"
-		],
-		values: {
-			[preset.baseUrlEnvKey]: setup.baseUrl,
-			KIZLO_TARGET: "dev",
-			KIZLO_DEV_SITE_SECRET: setup.siteSecret,
-			KIZLO_DEV_WORDPRESS_URL: setup.wpUrl,
-			KIZLO_DEV_WORDPRESS_USERNAME: setup.wpUsername,
-			KIZLO_DEV_WORDPRESS_APPLICATION_PASSWORD: setup.wpPassword
-		}
-	};
-	return {
-		keys: [preset.baseUrlEnvKey, ...PROD_WP_ENV_KEYS],
-		values: {
-			[preset.baseUrlEnvKey]: setup.baseUrl,
-			KIZLO_SITE_SECRET: setup.siteSecret,
-			KIZLO_WORDPRESS_URL: setup.wpUrl,
-			KIZLO_WORDPRESS_USERNAME: setup.wpUsername,
-			KIZLO_WORDPRESS_APPLICATION_PASSWORD: setup.wpPassword
-		}
-	};
-}
 function defaultDir(hasSrcDir) {
 	return hasSrcDir ? "src/lib/kizlo" : "lib/kizlo";
 }
@@ -75,18 +26,6 @@ export default defineConfig({
 })
 `;
 }
-/** Appends the API path to the base URL so the client and route handler agree. */
-function withApiPath(baseUrl, apiPath) {
-	try {
-		const url = new URL(baseUrl);
-		const current = url.pathname.replace(/\/+$/, "");
-		if (current.endsWith(apiPath)) return url.toString().replace(/\/+$/, "");
-		url.pathname = `${current}${apiPath}`;
-		return url.toString().replace(/\/+$/, "");
-	} catch {
-		return baseUrl;
-	}
-}
 /** Whether two URLs share an origin (scheme + host + port); false when either can't be parsed. */
 function sameOrigin(a, b) {
 	try {
@@ -100,22 +39,6 @@ function detectAppDir(cwd, hasSrcDir) {
 	if (fs.existsSync(path.join(cwd, "app"))) return "app";
 	return hasSrcDir ? "src/app" : "app";
 }
-const requiredString = z.string().trim().min(1, "Required");
-const urlString = requiredString.pipe(z.url("Must be a valid URL (e.g. https://example.com)"));
-const dirPath = requiredString.refine((value) => !value.endsWith(".ts"), "Enter a directory, not a file");
-function validate(schema) {
-	return (value) => {
-		const result = schema.safeParse(value ?? "");
-		return result.success ? void 0 : result.error.issues[0]?.message;
-	};
-}
-function orCancel(value) {
-	if (p.isCancel(value)) {
-		p.cancel("Setup cancelled.");
-		process.exit(0);
-	}
-	return value;
-}
 /**
 * The single overwrite policy for every scaffolded file: create it when absent, overwrite on
 * `--force`, and otherwise ask before clobbering an existing file (keeping it when the user
@@ -146,76 +69,7 @@ function reportScaffold(file, result, yes) {
 	else p.log.success(`${result === "overwritten" ? "Overwrote" : "Created"} ${file.label} (${file.relPath})`);
 }
 async function collectInteractively(ctx) {
-	let siteUrl;
-	let baseUrl;
-	if (ctx.preset.apiPath) baseUrl = orCancel(await p.text({
-		message: "Public app URL",
-		placeholder: "https://your-app.com",
-		validate: validate(urlString)
-	}));
-	else {
-		siteUrl = orCancel(await p.text({
-			message: "Public site URL",
-			placeholder: "https://your-app.com",
-			validate: validate(urlString)
-		}));
-		baseUrl = orCancel(await p.text({
-			message: "Kizlo backend URL (where the handler is mounted)",
-			placeholder: "https://your-app.com/kizlo",
-			validate: validate(urlString)
-		}));
-	}
-	const siteSecret = orCancel(await p.select({
-		message: "Site secret (webhook signing key)",
-		initialValue: "generate",
-		options: [{
-			value: "generate",
-			label: "Generate a secure secret automatically",
-			hint: "recommended"
-		}, {
-			value: "enter",
-			label: "Enter my own"
-		}]
-	})) === "enter" ? orCancel(await p.password({
-		message: "Enter the site secret",
-		validate: validate(requiredString)
-	})) : randomBytes(32).toString("hex");
-	const mode = orCancel(await p.select({
-		message: "WordPress connection",
-		initialValue: "local",
-		options: [{
-			value: "local",
-			label: "Set up a local dev environment",
-			hint: "runs WordPress in Docker"
-		}, {
-			value: "remote",
-			label: "Use my own WordPress",
-			hint: "connect to an existing site"
-		}]
-	}));
-	let wpUrl = "";
-	let wpUsername = "";
-	let wpPassword = "";
-	let devPath;
-	if (mode === "remote") {
-		wpUrl = orCancel(await p.text({
-			message: "WordPress URL",
-			placeholder: "https://wp.your-app.com",
-			validate: validate(urlString)
-		}));
-		wpUsername = orCancel(await p.text({
-			message: "WordPress username",
-			validate: validate(requiredString)
-		}));
-		wpPassword = orCancel(await p.password({
-			message: "WordPress application password",
-			validate: validate(requiredString)
-		}));
-	} else devPath = orCancel(await p.text({
-		message: "Local WordPress folder",
-		initialValue: "wordpress",
-		validate: validate(dirPath)
-	}));
+	const conn = await collectConnectionInteractively(ctx.preset);
 	const dir = orCancel(await p.text({
 		message: "Kizlo directory",
 		initialValue: defaultDir(ctx.hasSrcDir),
@@ -232,14 +86,7 @@ async function collectInteractively(ctx) {
 		})).trim();
 	}
 	return {
-		mode,
-		baseUrl,
-		siteUrl,
-		siteSecret,
-		wpUrl,
-		wpUsername,
-		wpPassword,
-		devPath,
+		...conn,
 		dir,
 		alias
 	};
@@ -250,14 +97,10 @@ async function collectInteractively(ctx) {
 * later. Never fails — `--yes` always scaffolds a fillable project.
 */
 function collectFromEnv(ctx) {
+	const conn = collectConnectionFromEnv(ctx.preset);
 	const dir = defaultDir(ctx.hasSrcDir);
 	return {
-		mode: "remote",
-		baseUrl: process.env[ctx.preset.baseUrlEnvKey]?.trim() ?? "",
-		siteSecret: process.env.KIZLO_SITE_SECRET?.trim() || randomBytes(32).toString("hex"),
-		wpUrl: process.env.KIZLO_WORDPRESS_URL?.trim() ?? "",
-		wpUsername: process.env.KIZLO_WORDPRESS_USERNAME?.trim() ?? "",
-		wpPassword: process.env.KIZLO_WORDPRESS_APPLICATION_PASSWORD?.trim() ?? "",
+		...conn,
 		dir,
 		alias: ctx.preset.apiPath ? aliasWithSlash(detectImportAlias(ctx.cwd, path.join(dir, "server"))?.prefix) : ""
 	};
@@ -265,66 +108,6 @@ function collectFromEnv(ctx) {
 function readPkg(pkgPath) {
 	return JSON.parse(fs.readFileSync(pkgPath, "utf8"));
 }
-/** Build a {@link ResolvedDevConfig} from the chosen install folder, matching `resolveDevConfig`'s
-* defaults — built directly so init never has to round-trip through the config file it's writing. */
-function devConfigFor(cwd, devPath) {
-	return {
-		configDir: cwd,
-		project: `${resolveStackName(cwd)}-dev`,
-		port: DEFAULT_DEV_PORT,
-		portExplicit: false,
-		dbPort: DEFAULT_DEV_DB_PORT,
-		dbPortExplicit: false,
-		fixtures: [],
-		wordpressPath: devPath,
-		wordpressDir: path.resolve(cwd, devPath)
-	};
-}
-/**
-* Boot the local dev stack once to produce working credentials, then stop it (volumes
-* persist, so a later `kizlo dev` resumes instantly). The dev stack mints no application
-* password — that's a test-stack concern — so we create one here for REST auth in `.env`.
-* While the stack is still up, push the dev site settings (`siteSecret` plus the Kizlo server's
-* `url`/`backend_url`, derived from `baseUrl`) into the plugin so webhook signing and event delivery
-* work.
-*/
-async function provisionLocalStack(cfg, siteSecret, baseUrl) {
-	await removeProjectContainers(cfg.project);
-	const port = await pickStackPort(cfg.port, {
-		fixed: cfg.portExplicit,
-		configKey: "dev.port"
-	});
-	const dbPort = await pickStackPort(cfg.dbPort, {
-		fixed: cfg.dbPortExplicit,
-		host: "127.0.0.1",
-		configKey: "dev.dbPort"
-	});
-	const ready = {
-		...cfg,
-		port,
-		dbPort
-	};
-	createStack(devStack(ready));
-	const info = await bootstrapDev(ready);
-	const appPassword = info.appPassword ?? await createAdminAppPassword("kizlo");
-	const sync = await syncSiteSettings({
-		url: info.url,
-		username: info.username,
-		password: appPassword
-	}, {
-		secret: siteSecret,
-		backendUrl: baseUrl,
-		containerized: true
-	});
-	await composeStop();
-	return {
-		url: info.url,
-		username: info.username,
-		appPassword,
-		adminPassword: info.secrets?.password,
-		secretSyncError: sync.ok ? void 0 : sync.error
-	};
-}
 const init = defineCommand({
 	meta: {
 		name: "init",
@@ -409,63 +192,17 @@ const init = defineCommand({
 			if (!ok) p.log.warn(`Install it yourself: ${addDependencyArgs(pm, "kizlo@latest").join(" ")}`);
 		}
 		if (preset.apiPath && setup.baseUrl) setup.baseUrl = withApiPath(setup.baseUrl, preset.apiPath);
-		let adminPassword;
-		if (setup.mode === "local" && setup.devPath) {
-			ensureGitignored(cwd, setup.devPath);
-			const s = p.spinner();
-			s.start("Setting up local WordPress (first run downloads images, this can take a while)");
-			try {
-				const local = await provisionLocalStack(devConfigFor(cwd, setup.devPath), setup.siteSecret, setup.baseUrl);
-				setup.wpUrl = local.url;
-				setup.wpUsername = local.username;
-				setup.wpPassword = local.appPassword;
-				adminPassword = local.adminPassword;
-				s.stop("Local WordPress ready");
-				if (local.secretSyncError) p.log.warn(`Could not sync KIZLO_DEV_SITE_SECRET to the local plugin (${local.secretSyncError})`);
-			} catch (error) {
-				s.stop("Local WordPress setup failed");
-				p.cancel(error instanceof Error ? error.message : String(error));
-				process.exit(1);
-			}
-		}
-		const { keys, values: envValues } = managedEnv(preset, setup);
-		const envPath = path.join(cwd, ".env");
-		const envExisted = fs.existsSync(envPath);
-		const existingEnv = envExisted ? fs.readFileSync(envPath, "utf8") : "";
-		const conflicts = envKeysPresent(existingEnv, keys);
-		let overwriteKeys = new Set(keys);
-		if (conflicts.length && !force) if (yes) {
-			overwriteKeys = /* @__PURE__ */ new Set();
-			p.log.info("Keeping existing .env values (pass --force to overwrite)");
-		} else {
-			p.log.warn("Some environment variables already exist in .env");
-			if (!orCancel(await p.confirm({
-				message: "Overwrite their existing values?",
-				initialValue: true
-			}))) overwriteKeys = /* @__PURE__ */ new Set();
-		}
-		const merge = mergeEnv(existingEnv, envValues, overwriteKeys, envGroups(preset.baseUrlEnvKey));
-		fs.writeFileSync(envPath, merge.content);
-		if (setup.mode === "remote" && setup.wpUrl && setup.wpUsername && setup.wpPassword) {
-			const sync = await syncSiteSettings({
-				url: setup.wpUrl,
-				username: setup.wpUsername,
-				password: setup.wpPassword
-			}, {
-				secret: setup.siteSecret,
-				siteUrl: setup.siteUrl,
-				backendUrl: setup.baseUrl
-			});
-			if (!sync.ok) p.log.warn(`Could not sync the site settings to WordPress (${sync.error}) — make sure the kizlo plugin is active, then set them from the Kizlo settings.`);
-		}
-		const exampleKeys = [preset.baseUrlEnvKey, ...PROD_WP_ENV_KEYS];
-		const { content: exampleEnv } = mergeEnv("", Object.fromEntries(exampleKeys.map((key) => [key, ""])), new Set(exampleKeys), envGroups(preset.baseUrlEnvKey));
-		const exampleBody = `${exampleEnv}\n# Point the app at a local dev stack (managed by \`kizlo dev\`) instead of the keys above:\n# KIZLO_TARGET=dev\n`;
-		const exampleCreated = writeFileIfAbsent(path.join(cwd, ".env.example"), exampleBody);
+		await setupLocalWordPress(cwd, setup);
+		await writeEnv(cwd, preset, setup, {
+			force,
+			yes
+		});
+		await syncRemote(setup);
 		const dirRel = setup.dir.replace(/^\.\//, "").replace(/\/+$/, "");
 		const serverDirRel = path.join(dirRel, "server");
 		const clientUrl = setup.siteUrl && !sameOrigin(setup.siteUrl, setup.baseUrl) ? setup.baseUrl : void 0;
 		const scaffold = {
+			kizloDir: dirRel,
 			serverDirName: path.basename(serverDirRel),
 			serverEntryPath: path.join(serverDirRel, "index.ts"),
 			clientPath: path.join(dirRel, "client.ts"),
@@ -490,29 +227,45 @@ const init = defineCommand({
 		writeFileIfAbsent(path.join(cwd, generatedDirRel, "contract.json"), "{}\n");
 		writeFileIfAbsent(path.join(cwd, generatedDirRel, "index.ts"), CONTRACT_BARREL);
 		const gitignore = ensureGitignored(cwd, ".env");
-		if (!envExisted) p.log.success("Created .env");
-		else if (merge.updated.length || merge.added.length) p.log.success("Updated .env");
-		else p.log.info("Left .env unchanged");
-		p.log.success(exampleCreated ? "Created .env.example" : "Skipped .env.example (exists)");
 		for (const { file, result } of scaffolded) reportScaffold(file, result, yes);
-		if (gitignore !== "present") p.log.success(`${gitignore === "created" ? "Created" : "Updated"} .gitignore (ignoring .env)`);
-		if (setup.mode === "local") {
-			p.log.success(`Local WordPress configured (${setup.devPath}) — .env points at ${setup.wpUrl}`);
-			if (adminPassword) p.log.warn(`wp-admin login: ${setup.wpUsername} / ${adminPassword} — save it, it's shown only once`);
+		for (const patch of templatePatches(preset.id)) {
+			const resolved = resolvePatch(patch, scaffold);
+			const abs = resolvePatchTargetPath(cwd, resolved.relPath);
+			if (!abs) {
+				p.log.info(`Skipped ${resolved.label} wiring — ${resolved.relPath} not found (add it yourself)`);
+				continue;
+			}
+			const relTarget = path.relative(cwd, abs);
+			const src = fs.readFileSync(abs, "utf8");
+			let text;
+			let changes;
+			try {
+				({text, changes} = applyPatchToSource(src, resolved, { replaceConflicts: force }));
+			} catch (err) {
+				p.log.error(`Could not parse ${resolved.label} (${relTarget}) to wire Kizlo into it: ${err instanceof Error ? err.message : String(err)}`);
+				throw err;
+			}
+			if (!force && !yes && changes.keptExports.length) {
+				p.log.warn(`${resolved.label} (${relTarget}) already defines ${changes.keptExports.join(", ")}`);
+				if (orCancel(await p.confirm({
+					message: "Replace with Kizlo's version?",
+					initialValue: true
+				}))) ({text, changes} = applyPatchToSource(src, resolved, { replaceConflicts: true }));
+			}
+			if (patchChanged(changes)) {
+				fs.writeFileSync(abs, text);
+				const parts = [
+					...changes.replacedExports.length ? [`replaced ${changes.replacedExports.join(", ")}`] : [],
+					...changes.addedExports.length ? [`added ${changes.addedExports.join(", ")}`] : [],
+					...changes.addedImports.length ? ["imports"] : []
+				];
+				p.log.success(`Wired Kizlo into your ${resolved.label} (${relTarget}) — ${parts.join(", ")}`);
+			}
+			if (changes.keptExports.length) p.log.info(`Kept your existing ${changes.keptExports.join(", ")} in ${resolved.label} — pass --force to replace`);
+			else if (!patchChanged(changes)) p.log.info(`Your ${resolved.label} is already wired (${relTarget})`);
 		}
-		p.note([
-			...setup.mode === "local" ? [
-				`Start your local WordPress dev stack (also watches your extensions):`,
-				`  npx kizlo dev`,
-				``
-			] : [
-				`Watch your extensions and regenerate the contract during development:`,
-				`  npx kizlo watch`,
-				``
-			],
-			`Generate the contract once for production builds:`,
-			`  npx kizlo generate`
-		].join("\n"), "Next steps");
+		if (gitignore !== "present") p.log.success(`${gitignore === "created" ? "Created" : "Updated"} .gitignore (ignoring .env)`);
+		nextStepsNote(setup.mode);
 		p.outro("Kizlo is ready 🎉");
 	}
 });

package/dist/cli/index.js

@@ -7,9 +7,10 @@ runMain(defineCommand({
 	meta: {
 		name: "kizlo",
 		version: getVersion(),
-		description: "Kizlo CLI — headless WordPress toolkit"
+		description: "Kizlo CLI — headless WordPress framework"
 	},
 	subCommands: {
+		create: () => import("./commands/create.js").then((m) => m.create),
 		init: () => import("./commands/init.js").then((m) => m.init),
 		watch: () => import("./commands/watch.js").then((m) => m.watch),
 		generate: () => import("./commands/generate.js").then((m) => m.generate),